AbstractFactoryPattern

意图

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

 

适用性

一个系统要独立于它的产品的创建、组合和表示时.

一个系统要由多个产品系列中的一个来配置时.

当你要强调一系列相关产品对象的设计以便进行联合使用时.

当你提供一个产品类库,而只想显示它们的接口而不是实现时.

 

抽象工厂模式的构成

抽象工厂角色(AbstractFactory):声明生成抽象产品的方法

具体工厂角色(ConcreteFactory):执行生成抽象产品的方法,生成一个具体产品.

抽象产品(AbstractProduct):为一种产品声明接口.

具体产品(ConcreteProduct):定义具体工厂生成的具体产品的对象,实现产品接口.

客户角色(Client):我们的应用程序,使用抽象产品和抽象工厂生成对象.

 

抽象方法模式和工厂方法模式最大的不同是:工厂方法模式的工厂角色每次只生成一个对象, 但是抽象工厂模式的工厂角色每次至少会生成两个对象或者是两个以上的对象.并且这些对象之间是有交互的,互相影响,互相依赖的关系.

 

ClassDiagram:

 

  SequenceDiagram:

 

 class Program
    {
        static void Main(string[] args)
        {
            AbstractFactory factory = new ConcreteFactory1();

            Client c = new Client(factory);

            c.Run();

            factory = new ConcreteFactory2();

            c = new Client(factory);

            c.Run();

            Console.ReadKey();
        }
    }

    class Client
    {
        private AbstractProductA a;

        private AbstractProductB b;

        public Client(AbstractFactory factory)
        {
            a = factory.CreateProductA();
            b = factory.CreateProductB();
        }

        public void Run()
        {
            b.Interact(a);
        }
    }

    /// <summary>
    /// 抽象工厂角色(用来生成抽象产品的方法)
    /// </summary>
    abstract class AbstractFactory
    {
        //创建抽象产品A相应的具体产品
        public abstract AbstractProductA CreateProductA();

        //创建抽象产品B相应的具体产品
        public abstract AbstractProductB CreateProductB();
    }

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

        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

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

        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }



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

    }

    /// <summary>
    /// 具体产品A1
    /// </summary>
    class ProductA1 : AbstractProductA
    {

    }

    /// <summary>
    /// 具体产品A2
    /// </summary>
    class ProductA2 : AbstractProductA
    {

    }

    /// <summary>
    /// 抽象产品B
    /// </summary>
    abstract class AbstractProductB
    {
        //定义了与AbstractProductA交互的方法.
        public abstract void Interact(AbstractProductA a);
    }

    /// <summary>
    /// 具体产品B1
    /// </summary>
    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " Interact With " + a.GetType().Name);
        }
    }

    /// <summary>
    /// 具体产品B2
    /// </summary>
    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name + " Interact With " + a.GetType().Name);
        }
    }

   附件中有一个抽象工厂的示例:

   可以下载参考,下面是该示例的引用关系: