C# 设计模式 创建型模式 之 抽象工厂模式

抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

下面 举例实现下 抽象工厂模式

namespace 抽象工厂模式
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //使用方法
            CarFactory carFactory = new CarFactory();
            AbstractFactory abstractFactoryCar = FactoryProducer.GetFactory(carFactory);
            Car carBenz = abstractFactoryCar.GetCar(new Benz());
            Car carBMW = abstractFactoryCar.GetCar(new BMW());
            string strBenz = carBenz.Run();
            string strBMW = carBMW.Run();

            ColorFactory colorFactory = new ColorFactory();
            AbstractFactory abstractFactoryColor = FactoryProducer.GetFactory(colorFactory);
            Color colorRed = abstractFactoryColor.GetColor(new Red());
            Color colorBlue = abstractFactoryColor.GetColor(new Blue());
            string strRed = colorRed.GetColor();
            string strBlue = colorBlue.GetColor();

            Console.WriteLine(strRed + strBenz);
            Console.WriteLine(strBlue+ strBMW);
            //控制台输出
            //红色奔驰在奔跑
            //蓝色宝马在奔跑

        }
    }
    //定义 Car接口
    public interface Car
    {
        string Run();
    }
    //实现Car接口
    public class Benz : Car
    {
        public string Run()
        {
            return "奔驰在奔跑";
        }
    }
    //实现Car接口
    public class BMW : Car
    {
        public string Run()
        {
            return "宝马在奔跑";
        }
    }
    //定义 Color接口
    public interface Color
    {
        public string GetColor();
    }
    //实现 Color接口
    public class Red : Color
    {
        public string GetColor()
        {
            return "红色";
        }
    }
    //实现 Color接口
    public class Blue : Color
    {
        public string GetColor()
        {
            return "蓝色";
        }
    }
    //为 Color 和 Car 对象创建抽象类来获取工厂
    public abstract class AbstractFactory
    {
        public abstract Car GetCar(Car car);
        public abstract Color GetColor(Color color);
    }
    //创建扩展了 AbstractFactory 的工厂类
    public class CarFactory : AbstractFactory
    {
        public override Car GetCar(Car car)
        {
           return car;
        }
        //这里是 Car工厂 所以 Color功能返回null，不在使用
        public override Color GetColor(Color color)
        {
            return null;
        }
    }
    public class ColorFactory : AbstractFactory
    {
        //这里是  Color工厂 所以 Car功能返回null，不在使用
        public override Car GetCar(Car car)
        {
            return null;
        }

        public override Color GetColor(Color color)
        {
            return color;
        }
    }
    //创建一个工厂生成器类
    public class FactoryProducer
    {
        public static AbstractFactory GetFactory(AbstractFactory abstractFactory)
        {
            return abstractFactory;
        }
    }
}

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。 

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 工厂 里加代码，又要在具体的里面加代码