【设计模式】简单工厂模式

简单工厂模式（Simple Factory Pattern）

   属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethodPattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

我的理解

   简单工厂模式是将代码工厂化，每个工厂生产不同的产品，然后根据人们需要（抽象产品），将不同产品自由整合在一起生成一个新产品（具体产品）。

   简单工厂模式的角色分为三种：工厂角色、抽象产品角色和具体产品角色。

   工厂（Creator）角色就是按照人们的需要进行设计，创建出所需对象，是简单工厂模式的核心，负责创建所有类的内部逻辑，工厂类必须能被外界调用。

   抽象（Product）产品角色：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。

   具体产品（Concrete Product）角色：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

例如：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 简单工厂模式
{
    //设计一个输入两个数和运算符号，得到结果
        /// <summary>
        /// 客户端代码（用户操作代码
        /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.WriteLine();
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 工厂类
    /// </summary>
    public class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationAdd();
                    break;
                case "-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper = new OperationMul();
                    break;
                case "/":
                    oper = new OperationDiv();
                    break;
            }
            return oper;
        }
    }

    /// <summary>
    /// 运算类
    /// </summary>
    public 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 ; }
        }

        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;
        }
    }
}

优缺点：

       优点工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

       缺点由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；这些缺点在工厂方法模式中得到了一定的克服。

使用场景：

        工厂类负责创建的对象比较少；

        客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

        由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。