深入理解C#设计模式的简单工厂模式、工厂方法模式和抽象工厂模式的区别和应用

深入理解C#设计模式的简单工厂模式、工厂方法模式和抽象工厂模式

1. 简单工厂模式：
   如果我们有一个逻辑，可能需要产生多种对象的时候，我们就将创建对象的过程放在工厂中，我们主程序 的逻辑却不需要修改。例如我们输入两个数以及一个操作符来进行运算。

class OperationSimpleFactory
    {
        static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.CreatOperation("*");
            oper.NumberA = 10;
            oper.NumberB = 5;
            Console.WriteLine(oper.GetResult().ToString());
        }
    }
    class Operation
    {
        private double _numberA;

        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        private double _numberB;

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    class OpertionAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OpertionSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class OpertionMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OpertionDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0");
            result = NumberA / NumberB;
            return result;
        }
    }
    class OperationFactory
    {
        public static Operation CreatOperation(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OpertionAdd();
                    break;
                case "-":
                    oper = new OpertionSub();
                    break;
                case "*":
                    oper = new OpertionMul();
                    break;
                case "/":
                    oper = new OpertionDiv();
                    break;
                default:
                    break;
            }
            return oper;
        }
    }

在其中的CreatOperation类中即是我们创建的简单工厂，都过输入运算类型及可返回相应的运算类。简单工厂依赖于运算类即可。即相当于一个工厂生产一个商品的基类，通过内部逻辑实现的子类。


简单工厂的应用场景：
当工厂类负责创建的对象比较少时可以考虑使用简单工厂模式（）
客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时可以考虑使用简单工厂模式
2. 工厂方法
简单工厂模式系统难以扩展，一旦添加新产品就不得不修改简单工厂方法，这样就会造成简单工厂的实现逻辑过于复杂，如果我们想添加一个幂运算就需要修改工厂的静态方法。我们就将工厂抽象。

class Program
    {
        static void Main(string[] args)
        {
            OperationFactory addFactory = new AddFactory();
            Operation ope = addFactory.create();
            ope.NumberA = 10;
            ope.NumberB = 100;
            Console.WriteLine( ope.GetResult().ToString());
        }
    }
    public class Operation
    {
        private double _numberA;
        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        private double _numberB;
        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class OperationMulti : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0");
            result = NumberA / NumberB;
            return result;
        }
    }
    public abstract class OperationFactory
    {
        public abstract Operation create();
    }

    public class AddFactory : OperationFactory
    {
        public override Operation create()
        {
            return new OperationAdd();
        }
    }
    public class SubFactory : OperationFactory
    {
        public override Operation create()
        {
            return new OperationSub();
        }
    }
    public class MultiFactory : OperationFactory
    {
        public override Operation create()
        {
            return new OperationMulti();
        }
    }
    public class DivFactory : OperationFactory
    {
        public override Operation create()
        {
            return new OperationDiv();
        }
    }

就相当于我将工厂抽象化，对应一个子类工厂实例化一个对象，那么就会有多上个对象就有多少个工厂类，此时如果我想添加一个幂数运算只需要添加一个幂数运算的工厂以及运算类即可。


工厂方法模式通过面向对象编程中的多态性来将对象的创建延迟到具体工厂中，从而解决了简单工厂模式中存在的问题，也很好地符合了开放封闭原则（即对扩展开发，对修改封闭）。

3. 抽象工厂模式
为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。在现实生活中，一个工厂只创建单个产品这样的例子很少，因为现在的工厂都多元化了，一个工厂创建一系列的产品，如果我们要设计这样的系统时，工厂方法模式显然在这里不适用。一个程序里面一组的对象，比如说，在上面的运算类中，再添加一个菜 的产品；

  class Program
    {
        static void Main(string[] args)
        {
            Factory factory = new AddFactory();
            Operation ope = factory.OperCreate();
            ope.NumberA = 10;
            ope.NumberB = 100;
            Console.WriteLine(ope.GetResult().ToString());
            Food food = factory.FoodCreat();
            food.Cook();
            Console.WriteLine(food.Name);
        }
    }
    public class Operation
    {
        private double _numberA;
        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        private double _numberB;

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    public abstract class Food
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public abstract void Cook();
    }
    public class KongpaoChicken : Food
    {
        public override void Cook()
        {
            Name = "KongpaoChicken";
        }
    }
    public class Manhanquanxi : Food
    {
        public override void Cook()
        {
            Name = "Manhanquanxi";
        }
    }
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    public abstract class Factory
    {
        public abstract Operation OperCreate();
        public abstract Food FoodCreat();
    }
    public class AddFactory : Factory
    {
        public override Operation OperCreate()
        {
            return new OperationAdd();
        }
        public override Food FoodCreat()
        {
            return new Manhanquanxi();
        }
    }
    public class SubFactory : Factory
    {
        public override Operation OperCreate()
        {
            return new OperationSub();
        }
        public override Food FoodCreat()
        {
            return new KongpaoChicken();
        }
    }

通过工厂菜和运算类就紧密的联系了起来。
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。
它与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。