C# 抽象工厂模式

抽象工厂模式 (Abstract Factory Pattern)

抽象工厂是一个超级工厂，它能创建其他工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的方式。

主要解决：主要解决接口选择的问题。
何时使用：系统的产品有多个的产品族，而系统只消费其中某一族产品。
如何解决：在一个产品族里面，定义多个产品。

实例如下：
系统：丰田中国公司
产品族：长春一汽丰田、广州广汽丰田
产品：一丰（RAV4、卡罗拉、亚洲龙） 广丰（雷凌、凯美瑞）

 	class Program
    {
        static void Main(string[] args)
        {
            ToyotaFactory toyota = FactoryProducer.GetFactory(ToyotaFactoryType.Changchun);
            IChangchun cc = toyota.GetInfo(ChangchunType.RAV4);
            cc.ProduceLine();

            ToyotaFactory toyota1 = FactoryProducer.GetFactory(ToyotaFactoryType.Guangzhou);
            IGuangzhou gz = toyota1.GetInfo(GuangzhouType.Camry);
            gz.ProduceLine();

            Console.ReadKey();
        }
    }

    //产品族
    public interface IChangchun
    {
        void ProduceLine();
    }
    public interface IGuangzhou
    {
        void ProduceLine();
    }

    //产品族下面的产品
    public class RAV4 : IChangchun
    {
        public void ProduceLine()
        {
            Console.WriteLine("一汽丰田RAV4生产线");
        }
    }

    public class Corolla : IChangchun
    {
        public void ProduceLine()
        {
            Console.WriteLine("一汽丰田卡罗拉生产线");
        }
    }

    public class Avalon : IChangchun
    {
        public void ProduceLine()
        {
            Console.WriteLine("一汽丰田亚洲龙生产线");
        }
    }

    public class Levin : IGuangzhou
    {
        public void ProduceLine()
        {
            Console.WriteLine("广汽丰田雷凌生产线");
        }
    }

    public class Camry : IGuangzhou
    {
        public void ProduceLine()
        {
            Console.WriteLine("广汽丰田凯美瑞生产线");
        }
    }

    //枚举产品对象
    public enum ChangchunType
    {
        RAV4,
        Corolla,
        Avalon
    }

    public enum GuangzhouType
    {
        Levin,
        Camry
    }

    public enum ToyotaFactoryType
    {
        Changchun,
        Guangzhou
    }

    //定义抽象工厂
    public abstract class ToyotaFactory
    {
        public abstract IChangchun GetInfo(ChangchunType type);
        public abstract IGuangzhou GetInfo(GuangzhouType type);
    }

    public class ChangchunFactory : ToyotaFactory
    {
        public override IChangchun GetInfo(ChangchunType type)
        {
            if (type == ChangchunType.RAV4)
            {
                return new RAV4();
            }
            else if (type == ChangchunType.Corolla)
            {
                return new Corolla();
            }
            else
            {
                return new Avalon();
            }
        }

        public override IGuangzhou GetInfo(GuangzhouType type)
        {
            return null;
        }
    }

    public class GuangzhouFactory : ToyotaFactory
    {
        public override IChangchun GetInfo(ChangchunType type)
        {
            return null;
        }

        public override IGuangzhou GetInfo(GuangzhouType type)
        {
            if (type == GuangzhouType.Levin)
            {
                return new Levin();
            }
            else
            {
                return new Camry();
            }
        }
    }

    public static class FactoryProducer
    {
        public static ToyotaFactory GetFactory(ToyotaFactoryType type)
        {
            if (type == ToyotaFactoryType.Changchun)
            {
                return new ChangchunFactory();
            }
            else
            {
                return new GuangzhouFactory();
            }
        }
    }

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难。