搏客 Winning
After three days without programming, life becomes meaningless
posts - 46,  comments - 41,  trackbacks - 21
工厂模式
简单工厂模式：
由一个工厂类根据参数决定创建抽象产品类的哪一个具体类的实例
namespace DesignPattern.Factory.SimpleFactory
{
    public abstract class AbstractButtonProduct
    {
        public abstract string TypeName
        {
            get;
        }
    }

    public class ButtonFactory
    {
        public static AbstractButtonProduct GetSpecialButton(string plaf)
        {
            if(plaf=="windows") 
                return new WindowsButtonProduct();
            else if(plaf=="linux")
                return new LinuxButtonProduct();
            else return null;
        }
    }

    public class LinuxButtonProduct : AbstractButtonProduct
    {
        public override string TypeName
        {
            get
            {
                return "LinuxButton";
            }
        }

    }

    public class WindowsButtonProduct : AbstractButtonProduct
    {
        public override string TypeName
        {
            get
            {
                return "WindowsButton";
            }
        }
    }

    public class Consume
    {
        public static void Main()
        {
            AbstractButtonProduct ab=ButtonFactory.GetSpecialButton("windows");
            Console.Write(ab.TypeName);
        }
    }
}


工厂方法模式：不再由一个工厂类决定产品类的哪一个子类应该被实例化而是交给抽象工厂类的具体子类去做

namespace DesignPattern.Factory.FactoryMethod
{
    public abstract class AbstractButtonFactory
    {
        public abstract AbstractButtonProduct GetButton();
    }

    public abstract class AbstractButtonProduct
    {
        public abstract string TypeName
        {
            get;
        }
    }

    public class WindowsButtonFactory : AbstractButtonFactory 
    {
        public override AbstractButtonProduct GetButton()
        {
            return new WindowsButtonProduct();
        }

    }

    public class WindowsButtonProduct : AbstractButtonProduct
    {
        public override string TypeName
        {
            get
            {
                return "WindowsButton";
            }
        }
    }

    public class LinuxButtonFactory : AbstractButtonFactory
    {
        public override AbstractButtonProduct GetButton()
        {
            return new LinuxButtonProduct();
        }
    }

    public class LinuxButtonProduct : AbstractButtonProduct
    {
        public override string TypeName
        {
            get
            {
                return "LinuxButton";
            }
        }
    }

    public class Consume
    {
        public static void Main()
        {
            AbstractButtonFactory af=new WindowsButtonFactory();
            AbstractButtonProduct ab=af.GetButton();
            Console.Write(ab.TypeName);
        }
    }
}

抽象工厂模式：抽象产品有一个或多个构成一个产品族在只有一个产品族的情况下退回到工厂方法模式
namespace DesignPattern.Factory.AbstractFactory
{
    public abstract class AbstractGUIFactory
    {
        public abstract AbstractGUIProduct GetGUIControl(string plaf);
    }

    public abstract class AbstractGUIProduct
    {
        public abstract string TypeName
        {
            get;
        }
    }

    public abstract class AbstractButtonProduct : AbstractGUIProduct
    {
        public abstract override string TypeName
        {
            get;
        }

    }

    public abstract class AbstractLabelProduct: AbstractGUIProduct
    {
        public override abstract string TypeName
        {
            get;
        }
    }

    public override AbstractGUIProduct GetGUIControl(string plaf)
    {
            if(plaf=="windows") return new WindowsButtonProduct();
            else if(plaf=="linux") return new LinuxButtonProduct();
            else return null;
    }

    public override AbstractGUIProduct GetGUIControl(string plaf)
    {
            if(plaf=="windows") return new WindowsLabelProduct();
            else if(plaf=="linux") return new LinuxLableProduct();
            else return null;
    }

    public class LinuxButtonProduct : AbstractButtonProduct
    {
        public override string TypeName
        {
            get{return "Linux Button";}
        }
    }

    public class LinuxLableProduct : AbstractLabelProduct
    {
        public override string TypeName
        {
            get{return "LinuxLable";}
        }
    }

    public class WindowsButtonProduct : AbstractButtonProduct
    {
        public override string TypeName
        {
            get{return "WindowsButton";}
        }
    }

    public class WindowsLabelProduct : AbstractLabelProduct
    {
        public override string TypeName
        {
            get{return "WindowsLabel";}
        }
    }

    public class Consume
    {
        public static void Main()
        {
            AbstractGUIFactory agf=new LabelFactory();
            AbstractGUIProduct agp=agf.GetGUIControl("windows");
            Console.Write(agp.TypeName);
        }
    }
}
posted on 2005-04-07 13:19 搏客 Winning 阅读(832) 评论(1)  编辑 收藏 所属分类: 架构设计

FeedBack:
#1楼 [楼主]
2005-04-29 10:52 | 搏客 Winning      
    在我们的项目中做到跨数据库是常有的需求，基本的思想是创建不同数据库统一的访问接口，然后为每一种数据库提供不同的实现，然后用工厂方法创建指定的数据库访问类，用接口访问数据库而不是具体的类。例如下面的Demo实现了用Web.Config中指定的类型和连接串创建数据库连接。
 
using System.Data;
using System.Data.OleDb;
using System.Configuration;
using System.Data.SqlClient;

namespace Demo
{
    //定义数据库管理的相同接口
    public interface IDBDialect
    {    
        IDbConnection CreateConnection();
    }

    //默认的数据库管理类，包含一个不同数据库管理类的共同接口成员
    //实现接口成员实例化为指定的类型后始终用这个类型执行数据库操作

    public class DefaultDB
    {
        private static IDBDialect idd=null;
        private static string connStr=null;

        //静态初始化保证对数据库类型的判断只做一次
        static DefaultDB()
        {
            connStr=ConfigurationSettings.AppSettings["ConnStr"];
        

            switch(ConfigurationSettings.AppSettings["DBType"])
            {
                case "SqlServer":
                    idd=new SqlDialect();
                    break;
                case "OleDb":
                default:
                    idd=new OleDbDialect();
                    break;
            }
        }

        public static string ConnStr
        {
            get{return connStr;}
        }

        public static IDbConnection CreateConnection()
        {