抽象工厂模式

所谓抽象工厂，就是在工厂模式的基础上，将工厂也抽象出来，工厂模式是在工厂类中返回指定的具体类，而抽象工厂正是具有全部的工厂类，返回指定的工厂类

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建

其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

Abstract Factory注意的几点：
    如果不存在”多系列对象创建“的需求变化，则没必要应用Abstract Factory模式，静态工厂方法足矣。
    "系列对象"指的是这些对象之间有相互依赖、或作用的关系。例如游戏开发场景中的"道路"与"房屋"依赖，“道路”与“地道”的依赖。
Abstract Factory模式主要在于应对"新系列"的需求变动。其缺点在于难以应对”新对象“的需求变动。
Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。

下方简单实现抽象模式的思想，结合策略模式，书写以下示例代码：

  #region 工厂类
    class Factory1
    {
        /*
         public Road CreateRoad()
         {
              return new Road();
         }
         */
        //...
    }
    class Factory2
    {
        /*
       public Load CreateLoad()
       {
            return new Load();
       }
       */
        //...
    }
    #endregion

  #region 抽象工厂
    abstract class AbstractFactory
    {
        protected Hashtable hash = new Hashtable();
        protected Center _center;
        public abstract object GetInstance(string name, Center center);

    }
    #endregion

  #region 抽象工厂实现类
    class ConcreteFactory: AbstractFactory
    {
        public override object GetInstance(string name, Center center)
        {
            _center = center;
            if (hash[name] == null)
            {
                center.getFactory(hash, name);
            }
            return hash[name];
        }
    }
    #endregion

 #region 策略模式的中间类
     interface Center
    {
        void getFactory(Hashtable hash, string name);
    }
    class Center1: Center
    {
        public void getFactory(Hashtable hash,string name)
        {
            if(name=="1")
            {
                hash[name] = new Factory1();
            }
            else if(name == "2")
            {
                hash[name] = new Factory2();
            }
        }
    }
    #endregion

  static void Main(string[] args)
        {
            AbstractFactory abstractfactory = new ConcreteFactory();
            Factory1 f1=(Factory1)abstractfactory.GetInstance("1",new Center1());//这样创建出来的就是借助Center1通过抽象工厂创建出来的Factory1
            Console.ReadKey();
        }

之所以使用策略模式，是考虑以后的扩展性，以后工厂模式如果不止2个的话，那么我在创建的时候输入的字符串也不同，那么我就需要修改抽象工厂子类中的GetInstance代码，无法完成封装，我使用策略模式，将无法封装的替换为中介类来实现，这样以后变化了我只需要修改该中间类，或者直接新增一个中间类(主要是为了这个)，无需任何修改。