模式三(抽象工厂模式)

抽象工厂是指一个等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。

抽象工厂角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

具体工厂角色：这个角色直接在客户端的调用下创建产品的实例。

抽象产品角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

具体产品角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。

using System;
using System.Collections.Generic;
using System.Text;

namespace Simple_Factory
{
    /// <summary>
    /// 抽象工厂产生抽象产品
    /// </summary>
    abstract class Abstractory
    {
        abstract public AbstractProductA CreateProductA();

        abstract public AbstractProductB CreateProductB();
    }

    /// <summary>
    /// 实体工厂产生实体产品
    /// </summary>
    class ConcreateFactory1 : Abstractory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }

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

    class ConcreteFactory2 : Abstractory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }

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

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

    abstract class AbstractProductB
    {
        abstract public void Interact(AbstractProductA a);
    }

    /// <summary>
    /// 实体产品
    /// </summary>
    class ProductA1 : AbstractProductA { }

    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this + "interacts with " + a);
        }
    }

    class ProductA2 : AbstractProductA { }

    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this + " interact with " + a);
        }
    }

    /// <summary>
    /// 工厂类
    /// </summary>
    class Environment
    {
        private AbstractProductA AbstractProductA;

        private AbstractProductB AbstractProductB;

        public Environment(Abstractory factory)
        {
            AbstractProductA = factory.CreateProductA();

            AbstractProductB = factory.CreateProductB();
        }

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

    class Abstract_Factory
    {
        public static void Main()
        {
            Abstractory factory1 = new ConcreateFactory1();

            Environment e1 = new Environment(factory1);

            e1.Run();

            Abstractory factory2 = new ConcreteFactory2();

            Environment e2 = new Environment();

            e2.Run();
        }
    }
}