设计模式—抽象工厂模式

前言：

工厂方法模式是为了克服简单工厂模式的确定而设计的，简单工厂模式的工厂类会随着产品类的增加而增加额外的代码（case）,而工厂方法模式每个具体工厂类只完成单个实例的创建，所以它具有很好的扩展性；但是现实生活中，一个工厂只生成一种产品显然是不可能的，如果使用工厂方法模式那么我们的代码中就会出现很多的工厂类，很多的实例，显然这是我们不想要的。那么抽象工厂就出现了

抽象工厂介绍：

1）实际例子

首先用生活中的例子‘绝味’在代码层中去实现。例如：绝味鸭脖想在江西南昌和上海开分店，但是由于当地人的口味不一样，在南昌的所有绝味的东西会做的辣一点，而上海不喜欢吃辣的，所以上海的所有绝味的东西都 不会做的像南昌的那样辣，然而这点不同导致南昌绝味工厂和上海的绝味工厂生成所有绝味的产品都不同，也就是某个具体工厂需要负责一系列产品(指的是绝味所 有食物)的创建工作，下面就具体看看如何使用抽象工厂模式来实现这种情况。

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

namespace ConsoleApplication1
{
    #region 产品集
    /// <summary>
    /// 鸭脖抽象类，供每个地方的鸭脖类继承
    /// </summary>
    public abstract class YaBo
    {
        public abstract void Print();
    }
    /// <summary>
    /// 鸭架抽象类，供每个地方的鸭架类继承
    /// </summary>
    public abstract class YaJia
    {
        public abstract void Print();
    }

    /// <summary>
    /// 南昌的鸭脖类，因为江西人喜欢吃辣的，所以南昌的鸭脖稍微会比上海做的辣
    /// </summary>
    public class NanChangYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("南昌鸭脖");
        }
    }
    /// <summary>
    /// 上海的鸭脖没有南昌的鸭脖做的辣
    /// </summary>
    public class ShangHaiYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("上海鸭脖");
        }
    }
    /// <summary>
    /// 南昌的鸭架
    /// </summary>
    public class NanChangYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("南昌鸭架");
        }
    }
    /// <summary>
    /// 上海的鸭架
    /// </summary>
    public class ShangHaiYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("上海鸭架");
        }
    }
    #endregion

    #region 工厂集
    /// <summary>
    /// 抽象工厂类，提供创建两个不同地方的鸭架和鸭脖的接口
    /// </summary>
    public abstract class AbstractFactory
    {
        // 抽象工厂提供创建一系列产品的接口，这里作为例子，只给出了绝味中鸭脖和鸭架的创建接口
        public abstract YaBo CreateYaBo();
        public abstract YaJia CreateYaJia();
    }

    /// <summary>
    /// 南昌绝味工厂负责制作南昌的鸭脖和鸭架
    /// </summary>
    public class NanChangFactory : AbstractFactory
    {
        // 制作南昌鸭脖
        public override YaBo CreateYaBo()
        {
            return new NanChangYaBo();
        }
        // 制作南昌鸭架
        public override YaJia CreateYaJia()
        {
            return new NanChangYaJia();
        }
    }
    /// <summary>
    /// 上海绝味工厂负责制作上海的鸭脖和鸭架
    /// </summary>
    public class ShangHaiFactory : AbstractFactory
    {
        // 制作上海鸭脖
        public override YaBo CreateYaBo()
        {
            return new ShangHaiYaBo();
        }
        // 制作上海鸭架
        public override YaJia CreateYaJia()
        {
            return new ShangHaiYaJia();
        }
    }
    #endregion
}

调用方式：

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

namespace ConsoleApplication1
{
    class Program
    {
        /// <summary>
        /// 下面以绝味鸭脖连锁店为例子演示下抽象工厂模式
        /// 因为每个地方的喜欢的口味不一样，有些地方喜欢辣点的，有些地方喜欢吃不辣点
        /// 客户端调用
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            // 南昌工厂制作南昌的鸭脖和鸭架
            AbstractFactory nanchangFactory = new NanChangFactory();
            nanchangFactory.CreateYaBo().Print();
            nanchangFactory.CreateYaJia().Print();

            // 上海工厂制作上海的鸭脖和鸭架
            AbstractFactory shanghaiFactory = new ShangHaiFactory();
            shanghaiFactory.CreateYaBo().Print();
            shanghaiFactory.CreateYaJia().Print();
        }
    }
}

2）抽象工厂模式：提供一个创建产品的接口来负责创建相关或依赖的对象，而不明确指定具体类

抽象工厂允许客户使用抽象的接口来创建一组相关产品，而不需要知道实际生产出来的具体产品是什么，这样客户就可以从具体产品中被解耦

3）需求变更

如果要在湖南开一家分店，那就是麻辣味的了，抽象工厂模块可能轻松的对代码进行扩展

/// <summary>
    /// 如果绝味又想开一家湖南的分店时，因为湖南喜欢吃麻的
    /// 所以这是有需要有一家湖南的工厂专门制作
    /// </summary>
    public class HuNanFactory : AbstractFactory
    {
        
// 制作湖南鸭脖
        public override YaBo CreateYaBo()
        {
            return new HuNanYaBo();
        }
 
        
// 制作湖南鸭架
        public override YaJia CreateYaJia()
        {
            return new HuNanYajia();
        }
    }
 
    /// <summary>
    /// 湖南的鸭脖
    /// </summary>
    public class HuNanYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("湖南的鸭脖");
        }
    }
 
    /// <summary>
    /// 湖南的鸭架
    /// </summary>
    public class HuNanYajia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("湖南的鸭架子");
        }
    }

4）抽象工厂分析

抽象工厂模式将具体产品的创建延迟到具体工厂子类中，将对象封装起来，可以减少客户端与具体产品之间的依赖，这样有利于后期的维护和扩展，这是抽象工厂的优点。

同时抽象工厂也有不足的地方，如下：

很难支持新种类产品的变化，因为抽象工厂接口中已经确定了可以被创建的产品集合，如果要添加新产品必须要修改抽象工厂的接口，而且涉及到抽象工厂类以及子类的变化，这样就违背了‘开发-封闭’原则

5）使用抽象工厂场景

一个系统不要求知道产品类如果创建，组合，表达

这个系统有多个系列产品，而系统中只消费其中某一系列产品

要求提供一个产品类的库，所以产品以同样的接口出现，客户端不需要依赖具体实现

6）简单方法工厂和抽象工厂模式区别

其实工厂方法模式是用来创建一个产品的等级结构的，而抽象工厂模式用来创建多个产品的等级结构的。

工厂方法类创建只有一个方法创建一种产品，抽象工厂类一般有多个方法创建多个产品。

工厂方法模式只有一个抽象产品类，抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

简而言之-> 
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。   
              一个抽象工厂类，可以派生出多个具体工厂类。   
              每个具体工厂类只能创建一个具体产品类的实例。   
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
              一个抽象工厂类，可以派生出多个具体工厂类。   
              每个具体工厂类可以创建多个具体产品类的实例。