编辑说明

概述

提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类

结构图

代码实现

 产品

    /// <summary>
    /// 抽象产品族A
    /// </summary>
    public abstract class AbstractProductA
    {
    }

    /// <summary>
    /// 抽象产品族B
    /// </summary>
    public abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    /// <summary>
    /// 产品A类实现1
    /// </summary>
    public class ProductA1 : AbstractProductA
    {
    }

    /// <summary>
    /// 产品A类实现2
    /// </summary>
    public class ProductA2 : AbstractProductA
    {
    }

    /// <summary>
    /// 产品B类实现1
    /// </summary>
    public class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    /// <summary>
    /// 产品B类实现2
    /// </summary>
    public class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

工厂

    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    /// <summary>
    /// 具体工厂1
    /// </summary>
    public class ConcreteFactory1 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    /// <summary>
    /// 具体工厂2
    /// </summary>
    public class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

工厂生成

    /// <summary>
    /// 抽象工厂生成类
    /// </summary>
   public class FactoryProducer
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        // Constructor 
        public FactoryProducer(AbstractFactory factory)
        {
            AbstractProductB = factory.CreateProductB();
            AbstractProductA = factory.CreateProductA();
        }

        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }

客户端

    class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory factory1 = new ConcreteFactory1();
            FactoryProducer c1 = new FactoryProducer(factory1);
            c1.Run();

            AbstractFactory factory2 = new ConcreteFactory2();
            FactoryProducer c2 = new FactoryProducer(factory2);
            c2.Run();

            Console.Read();
        }
    }

运行结果

优势

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

使用场景

系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

缺陷

产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

Demo