C#设计模式(一)---简单工厂模式(Simple Factory Pattern) || 工厂方法模式（Factory Method）

简单工厂模式，在OO程序设计中经常会在不知不觉中应用到一种模式就是简单工厂模式(Simple Factory Pattern)。根据提供给它的数据，返回几个可能类中的一个类的实例。这便是简单工厂模式从OO思想上的基本概念。继续前面概念的说明：通常情况下，它返回的实例的类都有一个共同的父类和共同的方法，但各自方法执行的任务不同，而且根据不同的数据进行了优化。简单工厂模式不属于23个GoF模式。 

 简单工厂模式又叫静态工厂模式，顾名思义，它是用来实例化目标类的静态类。下面我主要通过一个简单的实例说明简单工厂及其优点。

    简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。 

下面我们来看下具体的实例：

我们使用一个计算器的实例来看 

①创建运算父类:

class Operation
    {
        double numberA;
        double numberB;

        public double NumberA
        {
            get { return numberA; }
            set { numberA = value; }
        }
        public double NumberB
        {
            get { return numberB; }
            set { numberB = value; }
        }

        public virtual  double  GetResult()
        {
            double result = 0;
            return result;
        }
    }

②继承父类， 实现 GetResult（）方法：

 //sum
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }       
    }
    //sub
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    //Mul
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    //Div
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB==0)
            {
                throw new Exception("NumberB is Zero");
            }
            result = NumberA / NumberB;
            return result;
        }
    }
③现在我们有个4个类实现了运算的方法，需要调用时只要创建他的实例就可以直接使用了 ，

可是那样是很麻烦的，可是到底实例化那个对象呢？将来会不会增加实例化的对象呢？

--------举例说明、比如增加平方根算法、在②和③中改动就可以了...

所以我们使用一个单独的类，来实现专门的实例化，也就是我们今天要说的工厂类---以传入的参数(struing operation)来判断 该执行②中的哪个方法，也就是说实例化什么样的。。。 

class OperationFactory
    {
        public static Operation CreateOperate(string operation)
        {

            Operation oper = null;
            switch (operation)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    } 

//托三个textbox以及combox，button

 private void button1_Click(object sender, EventArgs e)
        {
            Operation oper = OperationFactory.CreateOperate(comboBox1.Text);
            oper.NumberA = Convert.ToDouble(textBox1.Text);
            oper.NumberB = Convert.ToDouble(textBox2.Text);

            double result = oper.GetResult();
            textBox3.Text = result.ToString();
        } 

这样使用一个工厂类，只需要把参数传进去就可以实现具体的实例化，产生合适的对象，通过多态返回父类的方式实现结果。

 

工厂方法模式

 

定义一个用于创建对象的接口，让子雷决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类[DP]。

代码：

 /// <summary>
    /// 运算类
    /// </summary>
    class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

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

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }

        /// <summary>
        /// 得到运算结果
        /// </summary>
        /// <returns></returns>
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

    /// <summary>
    /// 加法类
    /// </summary>
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    /// <summary>
    /// 减法类
    /// </summary>
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    /// <summary>
    /// 乘法类
    /// </summary>
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    /// <summary>
    /// 除法类
    /// </summary>
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0。");
            result = NumberA / NumberB;
            return result;
        }
    }

    /// <summary>
    /// 工厂方法
    /// </summary>
    interface IFactory
    {
        Operation CreateOperation();
    }

    /// <summary>
    /// 专门负责生产“+”的工厂
    /// </summary>
    class AddFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }

    /// <summary>
    /// 专门负责生产“-”的工厂
    /// </summary>
    class SubFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }

    /// <summary>
    /// 专门负责生产“*”的工厂
    /// </summary>
    class MulFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationMul();
        }
    }

    /// <summary>
    /// 专门负责生产“/”的工厂
    /// </summary>
    class DivFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationDiv();
        }
    }

客户端：

static void Main(string[] args)
        {
            IFactory operFactory = new AddFactory();
            Operation oper = operFactory.CreateOperation();
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result=oper.GetResult();

            Console.WriteLine(result);

            Console.Read();
        }

 

简单工厂模式和工厂方法模式区别

这个工厂类与分支耦合，那么我就对它下手，根据依赖倒转原则，我们把工厂类仇隙那个出一个借口，这个借口只有一个方法，就好似创建抽象产品的工作方法。然后，所有的要生产具体类的工厂，就去实现这个借口，这样，一个简单工厂模式的工厂类，变成了一个工厂抽象借口和多个具体生成对象的工厂，于是我们要增加‘求 M数的N次方'的功能时，就不需要更改原有的工厂类了，只需要增加次功能的运算类和相应的工厂类就可以了。---这样整个工厂和产品体系其实都没有修改的变化，而只是扩展的变化，这就完全符合了开放—封闭原则的精神。