设计模式--2: Net设计模式实例之抽象工厂模式(Abstract Factory Pattern)

1.抽象工厂模式：

　　抽象工厂模式，提供一个创建一系列相关或者相互依赖对象的接口，而无需制定他们的具体类。

　　优点：易于交换产品系列，由于具体工厂类在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂类变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。抽象工厂的另一个优点是，它让具体的创建实例与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户的代码中。

2.解决的问题：

　　常用天解决数据访问程序，也就是说程序通过使用抽象工厂模式后，可以灵活地在不同的数据库之间切换，而不需要费时费力地改变原有程序。

3.抽象工厂模式结构：

　　IProductA、IProductA接口：两个产品接口，他们都有可能有两种不同的实现。

ProductA1、ProductA2，ProductB1、ProductB2具体实现类：对两个产品接口的具体分类的实现。

AbstractFactory抽象类：抽象工厂接口，它里面应该包含所有产品创建的抽象方法。

ConcreteFactory1、ConcreteFactory2具体工厂类：创建具有特定实现的产品对象

3.1操作实现：　　

    /// <summary>
    /// 产品IProductA接口
    /// </summary>
    public interface IProductA
    {
        void Show();
    }

    /// <summary>
    /// 产品IProductA接口的具体实现ProductA1
    /// </summary>
    public class ProductA1 : IProductA
    {
        public void Show()
        {
            Console.WriteLine("具体产品类{0}展示方法。", this.GetType().Name);
        }
    }

    /// <summary>
    ///  产品IProductA接口的具体实现ProductA2
    /// </summary>
    public class ProductA2 : IProductA
    {
        public void Show()
        {
            Console.WriteLine("具体产品类{0}展示方法。", this.GetType().Name);
        }
    }

    /// <summary>
    /// 产品IProductB接口
    /// </summary>
    public interface IProductB
    {
        void Insert();
    }

    /// <summary>
    ///  产品IProductB接口的具体实现ProductB1
    /// </summary>
    public class ProductB1 : IProductB
    {
        public void Insert()
        {
            Console.WriteLine("具体产品类{0}插入方法。", this.GetType().Name);
        }
    }

    /// <summary>
    ///  产品IProductB接口的具体实现ProductB2
    /// </summary>
    public class ProductB2 : IProductB
    {
        public void Insert()
        {
            Console.WriteLine("具体产品类{0}插入方法。", this.GetType().Name);
        }
    }
 
 
2、抽象工厂接口AbstractFactory,及其具体的工厂AbstractFactory1、AbstractFactory2
    /// <summary>
    /// 抽象工厂接口AbstractFactory
    /// </summary>
    public abstract class AbstractFactory
    {
        public abstract IProductA CreateProductA();
        public abstract IProductB CreateProductB();      

    }

    /// <summary>
    /// 具体的工厂AbstractFactory1
    /// </summary>
    public class AbstractFactory1 : AbstractFactory
    {
        public override IProductA CreateProductA()
        {
            IProductA pa1 = new ProductA1();
            return pa1;
        }
        public override IProductB CreateProductB()
        {
            IProductB pb1 = new ProductB1();
            return pb1;
        }
    }

    /// <summary>
    /// 具体的工厂AbstractFactory2
    /// </summary>
    public class AbstractFactory2 : AbstractFactory
    {
        public override IProductA CreateProductA()
        {
            IProductA pa2 = new ProductA2();
            return pa2;
        }

        public override IProductB CreateProductB()
        {
            IProductB pb2 = new ProductB2();
            return pb2;
        }
    }
 
 
3、客户端代码
        static void Main(string[] args)
        {
            //根据需求调用具体工厂AbstractFactory1
            AbstractFactory f1 = new AbstractFactory1();
            IProductA pa1 = f1.CreateProductA();
            IProductB pb1 = f1.CreateProductB();
            pa1.Show();
            pb1.Insert();
            Console.WriteLine("\n");

            //根据需求调用具体工厂AbstractFactory2
            AbstractFactory2 f2 = new AbstractFactory2();
            IProductA pa2 = f2.CreateProductA();
            IProductB pb2 = f2.CreateProductB();
            pa2.Show();
            pb2.Insert();
            Console.WriteLine("\n");
            Console.Read();

        }

3.2 运行结果

 

4.总结：

抽象工厂模式（Abstract Factory Pattern），提供一个创建一系列相关或者相互依赖对象的接口，而无需制定他们的具体类。抽象工厂模式的典型应用就是，使用抽象工厂+反射+配置文件实现数据访问层程序。