抽象工厂模式是一种创建型设计模式，它提供了一种方式，可以创建一系列相关或相互依赖的对象，而无需指定它们的具体类。抽象工厂模式强调的是系列的概念，即每个工厂创建的对象属于一个系列。

using System;

namespace DesignMethod.抽象工厂
{
    public class Program : OpenDesign
    {
        public override void Open()
        {
            // 创建南昌工厂实例
            AbstractFactory nanChangFac = new NanChangFactory();
            // 使用南昌工厂创建南昌鸭脖
            YaBo nanChangYaBo = nanChangFac.CreateYaBo();
            // 打印南昌鸭脖信息
            nanChangYaBo.Print();

            // 创建上海工厂实例
            AbstractFactory shangHaiFac = new ShangHaiFactory();
            // 使用上海工厂创建上海鸭架
            shangHaiFac.CreateYaJia().Print();
            // 使用上海工厂创建上海鸭脖
            shangHaiFac.CreateYaBo().Print();

            // 等待用户输入
            Console.Read();
        }
    }
}

• 功能: 在 Open 方法中，分别创建了南昌工厂和上海工厂的实例，并使用它们创建对应的鸭脖和鸭架对象，然后调用 Print 方法打印信息。

  using System;
  
  namespace DesignMethod.抽象工厂
  {
      // 抽象工厂类
      public abstract class AbstractFactory
      {
          // 抽象方法：创建鸭脖
          public abstract YaBo CreateYaBo();
  
          // 抽象方法：创建鸭架
          public abstract YaJia CreateYaJia();
      }
  
      // 南昌工厂类，继承自抽象工厂
      public class NanChangFactory : AbstractFactory
      {
          // 实现创建鸭脖的方法，返回南昌鸭脖实例
          public override YaBo CreateYaBo()
          {
              return new NanChangYaBo();
          }
  
          // 实现创建鸭架的方法，返回南昌鸭架实例
          public override YaJia CreateYaJia()
          {
              return new NanChangYaJia();
          }
      }
  
      // 上海工厂类，继承自抽象工厂
      public class ShangHaiFactory : AbstractFactory
      {
          // 实现创建鸭脖的方法，返回上海鸭脖实例
          public override YaBo CreateYaBo()
          {
              return new ShangHaiYaBo();
          }
  
          // 实现创建鸭架的方法，返回上海鸭架实例
          public override YaJia CreateYaJia()
          {
              return new ShangHaiYaJia();
          }
      }

• 抽象工厂类: AbstractFactory 定义了创建鸭脖和鸭架的抽象方法。

• 具体工厂类:

  • NanChangFactory 和 ShangHaiFactory 分别实现了抽象工厂类，提供了创建南昌和上海鸭脖及鸭架的具体实现。

        #region 食品抽象类
    
        // 南昌鸭脖类，继承自鸭脖抽象类
        public class NanChangYaBo : YaBo
        {
            // 实现打印方法，输出南昌鸭脖信息
            public override void Print()
            {
                Console.WriteLine("南昌的鸭脖");
            }
        }
    
        // 南昌鸭架类，继承自鸭架抽象类
        public class NanChangYaJia : YaJia
        {
            // 实现打印方法，输出南昌鸭架信息
            public override void Print()
            {
                Console.WriteLine("南昌的鸭架");
            }
        }
    
        // 上海鸭脖类，继承自鸭脖抽象类
        public class ShangHaiYaBo : YaBo
        {
            // 实现打印方法，输出上海鸭脖信息
            public override void Print()
            {
                Console.WriteLine("上海鸭脖");
            }
        }
    
        // 上海鸭架类，继承自鸭架抽象类
        public class ShangHaiYaJia : YaJia
        {
            // 实现打印方法，输出上海鸭架信息
            public override void Print()
            {
                Console.WriteLine("上海鸭架");
            }
        }
    
        // 鸭脖抽象类
        public abstract class YaBo
        {
            // 抽象打印方法
            public abstract void Print();
        }
    
        // 鸭架抽象类
        public abstract class YaJia
        {
            // 抽象打印方法
            public abstract void Print();
        }
    
        #endregion 食品抽象类
    }

  • 产品抽象类:

    • YaBo 和 YaJia 分别是鸭脖和鸭架的抽象类，定义了 Print 抽象方法。

  • 具体产品类:

    • NanChangYaBo、NanChangYaJia、ShangHaiYaBo 和 ShangHaiYaJia 分别实现了对应的抽象产品类，提供了具体的 Print 方法实现。

主要组成部分

1. 抽象工厂类 (AbstractFactory):

   • 定义了创建不同类型产品的抽象方法。

   • 例如，AbstractFactory 定义了 CreateYaBo 和 CreateYaJia 方法。

2. 具体工厂类 (ConcreteFactory):

   • 实现了抽象工厂类，提供了创建具体产品的方法。

   • 例如，NanChangFactory 和 ShangHaiFactory 分别实现了 AbstractFactory，创建南昌和上海的鸭脖及鸭架。

3. 抽象产品类 (AbstractProduct):

   • 定义了产品的接口，可以是抽象类或接口。

   • 例如，YaBo 和 YaJia 是抽象产品类，定义了 Print 方法。

4. 具体产品类 (ConcreteProduct):

   • 实现了抽象产品类，提供了具体的功能。

   • 例如，NanChangYaBo、NanChangYaJia、ShangHaiYaBo 和 ShangHaiYaJia 是具体产品类，实现了 Print 方法。

工作原理

1. 客户端代码使用抽象工厂接口来创建产品对象，而不直接使用具体工厂类。

2. 具体工厂类决定创建哪些具体产品对象。

3. 抽象工厂模式确保所有创建的产品对象都属于同一个系列，保持一致性。

适用场景

1. 需要创建一系列相关或相互依赖的对象:

   • 当对象的创建需要考虑一系列产品，而不仅仅是单一产品时，使用抽象工厂模式。

   • 例如，创建不同地区的食品系列（南昌食品、上海食品等）。

2. 系统需要独立于产品的创建、构成和表示:

   • 当系统需要动态地切换产品系列，或者希望将产品的创建和使用解耦时，使用抽象工厂模式。

   • 例如，根据用户选择的地区动态创建对应的食品。

3. 强调一系列产品的设计，以便通过相同的方式使用它们:

   • 当需要确保一系列产品一起使用时，使用抽象工厂模式。

   • 例如，确保使用南昌的鸭脖和鸭架时，它们的行为和风格一致。

优点

1. 分离接口和实现:

   • 客户端代码只依赖于抽象工厂和抽象产品，不依赖于具体工厂和具体产品。

   • 这使得系统更容易维护和扩展。

2. 易于切换产品系列:

   • 只需要更换具体工厂类，就可以切换整个产品系列。

   • 例如，将南昌食品切换为上海食品，只需更改工厂实例。

3. 保证产品的一致性:

   • 确保同一工厂创建的产品属于同一系列，避免混用不同系列的产品。

缺点

1. 增加系统复杂度:

   • 引入了大量的抽象类和接口，增加了系统的复杂度。

   • 对于简单的应用场景，可能显得过于复杂。

2. 具体工厂类的实现较为繁琐:

   • 每个具体工厂类都需要实现所有抽象方法，可能导致代码冗长。