抽象工厂模式(Abstract Factory) C#

抽象工厂模式 C#

AbstractProductA.cs

    /// <summary>
    /// 抽象产品类A
    /// </summary>
    abstract class AbstractProductA
    {
        abstract public void Feature();
    }

AbstractProductB.cs

    /// <summary>
    /// 抽象产品类B
    /// </summary>
    abstract class AbstractProductB
    {
        abstract public void Feature();
    }

ProductA_one.cs

    /// <summary>
    /// 具体产品类A1
    /// </summary>
    class ProductA_one : AbstractProductA
    {
        public override void Feature()
        {
            Console.WriteLine("产品A1");
        }
    }

ProductA_two.cs

    /// <summary>
    /// 具体产品类A2
    /// </summary>
    class ProductA_two : AbstractProductA
    {
        public override void Feature()
        {
            Console.WriteLine("产品A2");
        }
    }

ProductB_one.cs

    /// <summary>
    /// 具体产品类B1
    /// </summary>
    class ProductB_one : AbstractProductB
    {
        public override void Feature()
        {
            Console.WriteLine("产品B1");
        }
    }

ProductB_two.cs

    /// <summary>
    /// 具体产品类B2
    /// </summary>
    class ProductB_two : AbstractProductB
    {
        public override void Feature()
        {
            Console.WriteLine("产品B2");
        }
    }

AbstractFactory.cs

    /// <summary>
    /// 抽象工厂（初始定义好要创建的族产品）
    /// </summary>
    abstract class AbstractFactory
    {
        /// <summary>
        /// 创建A族产品    
        /// </summary> 
        abstract public AbstractProductA GetProductA();
        /// <summary>
        /// 创建B族产品    
        /// </summary>
        abstract public AbstractProductB GetProductB();
    }

Factory1.cs

    /// <summary>
    /// 具体工厂类1
    /// </summary>
    class Factory1 : AbstractFactory
    {
        /// <summary>
        /// 创建产品A1  
        /// 创建不同族，但是属于同一系列的产品（同一后缀名one）
        /// </summary>
        /// <returns></returns>
        public override AbstractProductA GetProductA()
        {
            return new ProductA_one();
        }
        /// <summary>
        /// 创建产品B1   
        /// </summary>
        /// <returns></returns>
        public override AbstractProductB GetProductB()
        {
            return new ProductB_one();
        }
    }

Factory2.cs

/// <summary>
    /// 具体工厂类2
    /// 创建不同族，但是属于同一系列的产品（同一后缀名two）
    /// </summary>
    class Factory2 : AbstractFactory
    {
        /// <summary>
        /// 创建产品A2 
        /// </summary>
        /// <returns></returns>
        public override AbstractProductA GetProductA()
        {
            return new ProductA_two();
        }
        /// <summary>
        /// 创建产品B2   
        /// </summary>
        /// <returns></returns>
        public override AbstractProductB GetProductB()
        {
            return new ProductB_two();
        }
    }

AbstractFactoryDemo.cs

    /// <summary>
    /// 抽象工厂：创建对象，创建一组密不可分的对象
    /// 创建产品簇，多个对象是个整体，不可分割
    /// 
    /// 工厂+约束
    /// 工厂
    /// 
    /// 倾斜的可扩展性设计
    /// 扩展种族很方便 (加Factory3,新加类就可以)
    /// 增加产品很麻烦 (加AbstractProductC,需要改动代码)
    /// </summary>
    class AbstractFactoryDemo
    {
        public static void Show()
        {
            Console.WriteLine("=====抽象工厂模式=====");
            AbstractFactory factory = new Factory1();
            // 创建工厂1        
            AbstractProductA product = factory.GetProductA();
            // 创建产品A1        
            product.Feature();
            // 产品对象的特征方法   
        }
    }

个人看法

创建一个类的对象可以是很复杂也可以是很简单
把创建的过程写在工厂类里面，后面只要调工厂类的一个方法就可以给你创建出你想要的对象
抽象工厂就是把你要创建的对象的过程再加一层分批管理
(像上面特征相似但具体又不同的一系列类才进行分批,如不适合，不要强行分批，试试使用其他创建型模式).

代码看法

大部分设计模式在实现自己功能的同时遵循新加类而不直接修改原有代码的原则
上面代码如果你要加一个AbstractProductC需要去修改AbstractFactory这个已经定好的类，在里面加一个GetProductC()方法
而添加一个Factory3只需要新添加类ProductA_three和ProductB_three就可以,不动原来任何代码