C#设计模式-工厂模式

引入人、工厂、和斧子的问题

1. 原始社会时，劳动社会基本没有分工，需要斧子的人(调用者)只好自己去磨一把斧子，每个人拥有自己的斧子，如果把大家的石斧改为铁斧，需要每个人都要学会磨铁斧的本领，工作效率极低。（对应Java里的情形是：java程序里的调用者new一个被调用者的实例。类耦合度极高，修改维护烦琐，效率极低。）
2. 工业社会时，工厂出现，斧子不再由普通人完成，而由工厂生产，当人们需要斧子的时候，可以到工厂购买斧子，无需关心斧子是怎么制造出来的，如果废弃铁斧为钢斧，只需改变工厂的制造工艺即可，制作工艺是工厂决定的，工厂生产什么斧子，工人们就得用什么斧子。（对应的Java里的情形是：Java程序的调用者可以以来简单工厂创建被调用者，变化点被隔离到了简单工厂里，虽然耦合度降低，但是调用者会和工厂耦合，而且需要定位自己的工厂。）
3. 近代工业社会，工厂蓬勃发展，人们需要什么斧子，只需要提供一个斧子图形，商家会按照你提供的图形将你的斧子订做好，送上门。

工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A(). 工厂模式也是用来创建实例对象的，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

工厂方式封装：

Sample有个继承如MySample

public class Factory
    {
        public static Sample Creator(int which)
        {
            //getClass 产生Sample 一般可使用动态类装载装入类。  
            if (which == 1)
                return new SampleA();
            else if (which == 2)
                return new SampleB();
        }
    }

在程序中，如果要实例化Sample时，就使用

Sample _sampleA = Factory.Creator(1);

在列举个例子：

比如你写了个应用，里面用到了数据库的封装，你的应用可以今后需要在不同的数据库环境下运行，可能是oracle,db2,sql server等，那么连接数据库的代码是不一样的，你用传统的方法，就不得不进行代码修改来适应不同的环境，非常麻烦，但是如果你采用工厂类的话，将各种可能的数据库连接全部实现在工厂类里面，通过你配置文件的修改来达到连接的是不同的数据库，那么你今后做迁移的时候代码就不用进行修改了。

一、 抽象工厂（Abstract Factory）模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。

为了方便引进抽象工厂模式，引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。如图：

图中一共有四个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。

引进抽象工厂模式

所谓的抽象工厂是指一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。如果用图来描述的话，如下图：

二、 Abstract Factory模式的结构：

图中描述的东西用产品族描述如下：

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

具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

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

具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

三、 程序举例：

该程序演示了抽象工厂的结构，本身不具有任何实际价值。

// Abstract Factory pattern -- Structural example  
using System;

// "AbstractFactory"
abstract class AbstractFactory
{
    // Methods
    abstract public AbstractProductA CreateProductA();
    abstract public AbstractProductB CreateProductB();
}

// "ConcreteFactory1"
class ConcreteFactory1 : AbstractFactory
{
    // Methods
    override public AbstractProductA CreateProductA()
    {
        return new ProductA1();
    }
    override public AbstractProductB CreateProductB()
    {
        return new ProductB1();
    }
}

// "ConcreteFactory2"
class ConcreteFactory2 : AbstractFactory
{
    // Methods
    override public AbstractProductA CreateProductA()
    {
        return new ProductA2();
    }

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

// "AbstractProductA"
abstract class AbstractProductA
{
}

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

// "ProductA1"
class ProductA1 : AbstractProductA
{
}

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

// "ProductA2"
class ProductA2 : AbstractProductA
{
}

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

// "Client" - the interaction environment of the products
class Environment
{
    // Fields
    private readonly AbstractProductA _abstractProductA;
    private readonly AbstractProductB _abstractProductB;

    // Constructors
    public Environment(AbstractFactory factory)
    {
        _abstractProductB = factory.CreateProductB();
        _abstractProductA = factory.CreateProductA();
    }

    // Methods
    public void Run()
    {
        _abstractProductB.Interact(_abstractProductA);
    }
}

/// <summary>
/// ClientApp test environment
/// </summary>
class ClientApp
{
    public static void Main(string[] args)
    {
        AbstractFactory factory1 = new ConcreteFactory1();
        var e1 = new Environment(factory1);
        e1.Run();

        AbstractFactory factory2 = new ConcreteFactory2();
        var e2 = new Environment(factory2);
        e2.Run();
    }
}

四、 在什么情形下使用抽象工厂模式：

在以下情况下应当考虑使用抽象工厂模式：

• 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。
• 这个系统有多于一个的产品族，而系统只消费其中某一产品族。
• 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。
• 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

五、 抽象工厂的起源

据说最早的应用是用来创建在不同操作系统的视窗环境下都能够运行的系统。比如在Windows与Unix系统下都有视窗环境的构件，在每一个操作系统中，都有一个视窗构件组成的构件家族。我们可以通过一个抽象角色给出功能描述，而由具体子类给出不同操作系统下的具体实现，如图：

可以发现上面产品类图有两个产品等级结构，分别是Button与Text；同时有两个产品族：Unix产品族与Windows产品族。

系统对产品对象的创建要求由一个工厂的等级结构满足。其中有两个具体工厂角色，即UnixFactory和WinFactory。UnixFactory对象负责创建Unix产品族中的产品，而WinFactory负责创建Windows产品族中的产品。

显然一个系统只能够在某一个操作系统的视窗环境下运行，而不能同时在不同的操作系统上运行。所以，系统实际上只能消费属于同一个产品族的产品。

在现代的应用中，抽象工厂模式的使用范围已经大大扩大了，不再要求系统只能消费某一个产品族了。

六、 Abstract Factory模式在实际系统中的实现

Herbivore：草食动物
Carnivore：食肉动物
Bison：['baisn]，美洲或欧洲的野牛

下面实际代码演示了一个电脑游戏中创建不同动物的抽象工厂。尽管在不同大陆下动物物种是不一样的，但动物间的关系仍然保留了下来。

// Abstract Factory pattern -- Real World example  
using System;

// "AbstractFactory"
abstract class ContinentFactory
{
    // Methods
    abstract public Herbivore CreateHerbivore();
    abstract public Carnivore CreateCarnivore();
}

// "ConcreteFactory1"
class AfricaFactory : ContinentFactory
{
    // Methods
    override public Herbivore CreateHerbivore()
    { return new Wildebeest(); }

    override public Carnivore CreateCarnivore()
    { return new Lion(); }
}

// "ConcreteFactory2"
class AmericaFactory : ContinentFactory
{
    // Methods
    override public Herbivore CreateHerbivore()
    { return new Bison(); }

    override public Carnivore CreateCarnivore()
    { return new Wolf(); }
}

// "AbstractProductA"
abstract class Herbivore
{
}

// "AbstractProductB"
abstract class Carnivore
{
    // Methods
    abstract public void Eat(Herbivore h);
}

// "ProductA1"
class Wildebeest : Herbivore
{
}

// "ProductB1"
class Lion : Carnivore
{
    // Methods
    override public void Eat(Herbivore h)
    {
        // eat wildebeest
        Console.WriteLine(this + " eats " + h);
    }
}

// "ProductA2"
class Bison : Herbivore
{
}

// "ProductB2"
class Wolf : Carnivore
{
    // Methods
    override public void Eat(Herbivore h)
    {
        // Eat bison
        Console.WriteLine(this + " eats " + h);
    }
}

// "Client"
class AnimalWorld
{
    // Fields
    private readonly Herbivore _herbivore;
    private readonly Carnivore _carnivore;

    // Constructors
    public AnimalWorld(ContinentFactory factory)
    {
        _carnivore = factory.CreateCarnivore();
        _herbivore = factory.CreateHerbivore();
    }

    // Methods
    public void RunFoodChain()
    { _carnivore.Eat(_herbivore); }
}

/// <summary>
///  GameApp test class
/// </summary>
class GameApp
{
    public static void Main(string[] args)
    {
        // Create and run the Africa animal world
        ContinentFactory africa = new AfricaFactory();
        var world = new AnimalWorld(africa);
        world.RunFoodChain();

        // Create and run the America animal world
        ContinentFactory america = new AmericaFactory();
        world = new AnimalWorld(america);
        world.RunFoodChain();
    }
}

抽象工厂的另外一个例子：

如何设计抽象类工厂留作思考。

七、 "开放－封闭"原则

"开放－封闭"原则要求系统对扩展开放，对修改封闭。通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统，其功能增强包括两方面：

增加产品族：Abstract Factory很好的支持了"开放－封闭"原则。

增加新产品的等级结构：需要修改所有的工厂角色，没有很好支持"开放－封闭"原则。

综合起来，抽象工厂模式以一种倾斜的方式支持增加新的产品，它为新产品族的增加提供方便，而不能为新的产品等级结构的增加提供这样的方便。