GOF之抽象工厂模式

动机(Motivation)

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作;同时，由于需求的变化，往往存在更多系列的对象的创建工作。

如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

意图(Intene)

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定他们具体的类。

结构(Stucture)

具体代码实现：

对应图中的AbstractFactory
abstract class FacilitiesFactory
    {
        public abstract Road CreateRoad();
        public abstract Building CreateBuilding();
    }

对应图中的AbstractProductA
abstract class Road
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public abstract void RoadMethod();
    }

对应图中的AbstractProductB
abstract class Building
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public abstract void BuildingMethod();
    }

对应图中的ConcreteFactory1
 class ModenFacilities:FacilitiesFactory
    {
        public override Road CreateRoad()
        {
            return new ModenRoad("现代风格的");
        }

        public override Building CreateBuilding()
        {
            return new ModenBuilding("现代风格的");
        }
    }

对应图中的ConcreteFactory2
class ClassicFacilities:FacilitiesFactory
    {
        public override Road CreateRoad()
        {
            return new ClassicRoad("古典风格的");
        }

        public override Building CreateBuilding()
        {
            return new ClassicBuilding("古典风格的");
        }
    }

对应图中的Client 
class GameManage
    {
        private FacilitiesFactory facilitiesFactory;
        private Road road;
        private Building building;
        public GameManage(FacilitiesFactory facilitiesFactory)
        {
            this.facilitiesFactory = facilitiesFactory;
        }
        public void BuildFacilities()
        {
            road = facilitiesFactory.CreateRoad();
            building = facilitiesFactory.CreateBuilding();
        }
        public void Run()
        {
            road.RoadMethod();
            building.BuildingMethod();
        }
    }

对应图中的ProductA1
class ModenRoad:Road
    {
        public override void RoadMethod()
        {
            Console.WriteLine("{0}的道路",this.Name);
        }
        public ModenRoad(string name)
        {
            this.Name = name;
        }
    }

对应图中ProductB1 
class ModenBuilding:Building
    {

        public override void BuildingMethod()
        {
            Console.WriteLine("{0}的建筑物",this.Name);
        }
        public ModenBuilding(string name)
        {
            this.Name = name;
        }
    }

对应图中ProductA2 
class ClassicRoad:Road
    {
        public override void RoadMethod()
        {
            Console.WriteLine("{0}的道路", this.Name);
        }
        public ClassicRoad(string name)
        {
            this.Name = name;
        }
    }

对应图中ProductB2  
 class ClassicBuilding:Building
    {
        public override void BuildingMethod()
        {
            Console.WriteLine("{0}的建筑物", this.Name);
        }
        public ClassicBuilding(string name)
        {
            this.Name = name;
        }
    }

这是主函数的调用
 static void Main(string[] args)
 {
      GameManage g = new GameManage(new ClassicFacilities());
      g.BuildFacilities();
      g.Run();
      Console.ReadKey();
8  }

Abstract Factory模式的几个要点

如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的静态工厂。

“系列对象”指的是这些对象之间有相互依赖、或作用的关系，例如游戏开发场景中的“道路”与“房屋”的依赖。

Abstract Factory模式主要在于应对“新系列”的需求变动，其缺点在于难以应对“新对象”的需求变动。

Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。