深入浅出设计模式——抽象工厂模式（Abstract Factory）

模式动机
在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。
为了更清晰地理解工厂方法模式，需要先引入两个概念：
产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
产品族与产品等级结构示意图

当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。
抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。
抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建 。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。
抽象工厂模式示意图

模式定义

抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。
Abstract Factory Pattern: Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
Frequency of use: high
抽象工厂模式UML图

模式结构
抽象工厂模式包含如下角色：
抽象工厂（Abstract Factory)：声明生成一系列抽象产品的方法
具体工厂（Concrete Factory）：执行生成一系列抽象产品的方法，生成一系列具体的产品
抽象产品（Abstract Product）：为这一系列的某一种产品声明接口
具体产品（Product）：定义具体工厂生成的具体产品的对象，实现产品接口
客户（Client）：我们的应用程序客户端（不要理解成人），使用抽象产品和抽象工厂生成对象。

抽象工厂模式在生活中的实例
咱们继续拿怎么穿衣服来说明这个抽象工厂模式。
就拿你来说吧。工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。咱们假设一种情况(现实中是不存在的,要不然,没法进入共产主义了,但有利于说明抽象工厂模式)，在你的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用OO的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。

先把各个角色揪出来。
抽象工厂：虚拟的衣柜，它只是个概念而已。在项目中可能是一个接口或抽象类，定义规则，取出上衣，裤子。
具体工厂：具体的存在的衣柜，它用于存放某一种成套的衣服，换句话说，这种成套的衣服都是从这个衣柜中取出的。在项目中继承于抽象工厂，实现抽象工厂中的方法，取出具体产品，某一件上衣，某一条裤子。
抽象产品：虚拟的衣服，也只是个概念。在项目中可能是多个接口或抽象类，定义规则，有什么特性，起什么作用。
具体产品：具体的实际存在的产品，它指的就是用于组装成某一套衣服的某一件上衣或裤子。它继承自某一个抽象产品。实现抽象产品中制定的规则，特性。
它们之间怎么联系呢？客户在用的时候，依赖的又是什么呢？

客户在要的时候，首先要说出你要的什么系列的衣服，然后根据它的要求生成一个具体工厂的实例，剩下的工作就都是这个倒霉的具体工厂了，它会根据自己的实现生成一个上衣，生成一个裤子，然后把它交给客户。客户在这一过程中并不知道具体工厂都做了什么。也就是说，客户只依赖于抽象工厂和抽象产品了。在初始化的时候会用到一次具体工厂类名，我们根据.NET特有的反射机制又可以把这个在客户端唯一的具体的非抽象类放到一个应用程序配置文件中，防止它变化。
这就符合了设计模式中的“开放--封闭”原则，依赖倒转原则，里氏代换原则等等。
体系结构

抽象产品角色 AbstractCoat.cs

namespace AbstractFactory
{
    /// <summary>
    /// 抽象产品----上衣抽象类
    /// </summary>
    public abstract class AbstractCoat
    {
        //性别属性
        public abstract bool Sex
        {
            get;
        }

        //样式属性
        public abstract string Style
        {
            get;
        }
    }
}

抽象产品角色 AbstractTrousers.cs

namespace AbstractFactory
{
    /// <summary>
    /// 抽象产品----裤子抽象类
    /// </summary>
    public abstract class AbstractTrousers
    {
        //性别属性
        public abstract bool Sex
        {
            get;
        }

        //样式属性
        public abstract string Style
        {
            get;
        }
    }
}

抽象工厂角色 AbstractClothes.cs

namespace AbstractFactory
{
    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public abstract class AbstractClothes
    {
        //抽象方法:创建一个上衣
        abstract public AbstractCoat CreateCoat();
        //抽象方法:创建一个裤子
        abstract public AbstractTrousers CreateTrousers();
    }
}

具体工厂角色 FashionManClothes.cs

namespace AbstractFactory
{
    /// <summary>
    /// 具体工厂角色：时尚男装 
    /// </summary>
    public class FashionManClothes : AbstractClothes
    {
        public override AbstractFactory.AbstractCoat CreateCoat()
        {
            return new CoatA();
        }

        public override AbstractTrousers CreateTrousers()
        {
            return new TrousersA();
        }
    }
}

具体工厂角色 FashionWomanClothes.cs

namespace AbstractFactory
{
    /// <summary>
    /// 具体工厂角色：时尚女装
    /// </summary>
    public class FashionWomanClothes : AbstractClothes
    {
        public override AbstractCoat CreateCoat()
        {
            return new CoatB();
        }

        public override AbstractTrousers CreateTrousers()
        {
            return new TrousersB();
        }
    }
}

具体产品角色 CoatA.cs

namespace AbstractFactory
{
    /// <summary>
    /// 具体产品角色：时尚男性上衣
    /// </summary>
    public class CoatA : AbstractFactory.AbstractCoat
    {
        private bool sex = true;
        private string style = "时尚";

        /// <summary>
        /// 重写基类的Sex属性
        /// </summary>
        public override bool Sex
        {
            get
            {
                return sex;
            }
        }

        /// <summary>
        /// 重写基类的Style属性
        /// </summary>
        public override string Style
        {
            get
            {
                return style;
            }
        }
    }
}

具体产品角色 TrousersA.cs

namespace AbstractFactory
{
    /// <summary>
    /// 具体产品角色：时尚男性裤子
    /// </summary>
    public class TrousersA : AbstractTrousers
    {
        private bool sex = true;
        private string style = "时尚";
        public override bool Sex
        {
            get
            {
                return sex;
            }
        }

        public override string Style
        {
            get
            {
                return style;
            }
        }
    }
}

具体产品角色 CoatB.cs

namespace AbstractFactory
{
    /// <summary>
    /// 具体产品角色：时尚女性上衣
    /// </summary>
    public class CoatB : AbstractFactory.AbstractCoat
    {
        private bool sex = false;
        private string style = "时尚";

        /// <summary>
        /// 重写基类的Sex属性
        /// </summary>
        public override bool Sex
        {
            get
            {
                return sex;
            }
        }

        /// <summary>
        /// 重写基类的Style属性
        /// </summary>
        public override string Style
        {
            get
            {
                return style;
            }
        }
    }
}

具体产品角色 TrousersB.cs

namespace AbstractFactory
{
    /// <summary>
    /// 具体产品角色：时尚女性裤子
    /// </summary>
    public class TrousersB : AbstractTrousers
    {
        private bool sex = false;
        private string style = "时尚";
        public override bool Sex
        {
            get
            {
                return sex;
            }
        }

        public override string Style
        {
            get
            {
                return style;
            }
        }
    }
}

创建衣服类 Program.cs、客户端代码

using System;
using System.Configuration;
using System.Reflection;

namespace AbstractFactory
{
    /// <summary>
    /// 创建衣服类
    /// </summary>
    public class CreateClothes
    {
        private AbstractCoat myCoat;
        private AbstractTrousers myTrousers;
        public CreateClothes(AbstractClothes clothes)
        {
            myCoat = clothes.CreateCoat();
            myTrousers = clothes.CreateTrousers();
        }

        public void ShowMyClothes()
        {
            Console.WriteLine("My Clothes:");
            string sex = myCoat.Sex ? "男" : "女";
            Console.WriteLine("Coat:{0} {1}", sex, myCoat.Style);

            sex = myTrousers.Sex ? "男" : "女";
            Console.WriteLine("Trousers:{0} {1}", sex, myTrousers.Style);
        }
    }

    public class Client
    {
        static void Main(string[] args)
        {
            //创建一个工厂类的实例
            string assemblyName = ConfigurationManager.AppSettings["assemblyName"];
            string fullTypeName = string.Concat(ConfigurationManager.AppSettings["nameSpaceName"], ".", ConfigurationManager.AppSettings["typename"]);

            AbstractClothes factory = (AbstractClothes)Assembly.Load(assemblyName).CreateInstance(fullTypeName);
            CreateClothes clothes = new CreateClothes(factory);
            clothes.ShowMyClothes();
            Console.Read();
        }
    }
}

App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <appSettings>
        <!--一般情况下只需改第三个"typename"就行了,具体工厂类    -->
        <add key="assemblyName" value="AbstractFactory"/>
        <add key="nameSpaceName" value="AbstractFactory"/>
        <add key="typename" value="FashionWomanClothes"/>
    </appSettings>    
</configuration>

抽象工厂模式的优点
抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

抽象工厂模式的缺点
在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）

模式适用环境
在以下情况下可以使用抽象工厂模式：
一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
系统中有多于一个的产品族，而每次只使用其中某一产品族。
属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。