C#设计模式2创建型模式2.4 抽象工厂模式（Abstract Factory Pattern）

2.4.1 定义

提供一个创建一系列相关或相互依赖对象的接口，而且无需指定他们具体的类。

2.4.2 抽象工厂模式的结构图

 

AbstractProductA和AbstractProductB是两个抽象产品。之所以抽象，是因为它们都有可能有两种实现，而ProductA1、ProductA2和ProductB1和ProductB2就是对两个抽象产品的具体实现。

IFactory是一个抽象工厂接口，它里面应该包括所有的产品创建的抽象方法，而ConcreteFactory1和ConcreteFactory2就是具体的工厂了

通常在运行的时候再创建一个ConcreteFactory类的实例，这个具体的工厂再创建具有特定实现的产品对象，也就是说，为创建不同的产品对象，客户端应使用不同的具体工厂。

2.4.3 模拟场景

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

2.4.4 代码演示

namespace AbstractFatoryPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            // 南昌工厂制作南昌的鸭脖和鸭架
            IFactory nanChangFactory = new NanChangFactory();
            YaBo nanChangYabo = nanChangFactory.CreateYaBo();
            nanChangYabo.Print();
            YaJia nanChangYajia = nanChangFactory.CreateYaJia();
            nanChangYajia.Print();

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

            Console.ReadLine();
        }

        /// <summary>
        /// 鸭脖抽象类，供每个地方的鸭脖类继承
        /// </summary>
        public abstract class YaBo
        {
            /// <summary>
            /// 打印方法，用于输出信息
            /// </summary>
            public abstract void Print();
        }

        /// <summary>
        /// 鸭架抽象类，供每个地方的鸭架类继承
        /// </summary>
        public abstract class YaJia
        {
            /// <summary>
            /// 打印方法，用于输出信息
            /// </summary>
            public abstract void Print();
        }

        public class NanChangYaBo : YaBo
        {
            public override void Print()
            {
                Console.WriteLine("南昌的鸭脖");
            }
        }

        public class ShangHaiYaBo : YaBo
        {
            public override void Print()
            {
                Console.WriteLine("上海的鸭脖");
            }
        }

        public class NanChangYaJia : YaJia
        {
            public override void Print()
            {
                Console.WriteLine("南昌的鸭架子");
            }
        }

        /// <summary>
        /// 上海的鸭架
        /// </summary>
        public class ShangHaiYaJia : YaJia
        {
            public override void Print()
            {
                Console.WriteLine("上海的鸭架子");
            }
        }

        /// <summary>
        /// 抽象工厂接口，提供创建两个不同地方的鸭架和鸭脖的方法
        /// </summary>
        public interface IFactory
        {
            YaBo CreateYaBo();
            YaJia CreateYaJia();
        }

        /// <summary>
        /// 南昌绝味工厂负责制作南昌的鸭脖和鸭架
        /// </summary>
        public class NanChangFactory : IFactory
        {
            public YaBo CreateYaBo()
            {
                return new NanChangYaBo();
            }

            public YaJia CreateYaJia()
            {
                return new NanChangYaJia();
            }
        }

        /// <summary>
        /// 上海绝味工厂负责制作上海的鸭脖和鸭架
        /// </summary>
        public class ShangHaiFactory : IFactory
        {
            public YaBo CreateYaBo()
            {
                return new ShangHaiYaBo();
            }

            public YaJia CreateYaJia()
            {
               return new ShangHaiYaJia();
            }
        }
    }
}

2.4.5 优缺点

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

缺点：抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。

2.4.6 使用场景

1）一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。

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

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

 参考链接：https://www.cnblogs.com/zhaoshujie/p/9741882.html