设计模式——工厂模式

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

　　工厂模式和简单工厂模式同属于工厂类型的模式，都是以一个工厂生产对象为目标，降低耦合。要说区别，就是在创建产品对象的时候的方式不同。简单工厂模式工厂里面还是存在一些耦合的，当需要创建新的产品时，还是需要去修改这个工厂类的。而工厂模式由子类去创建产品，不需要改工厂，只需添加一个工厂，再一次的降低的耦合性。相应的，也带来了代码量的增加。

　　下面还是以计算器为例子，展示下工厂模式的应用。

1.Operation类，于简单工厂无异，还是作为一个具体实现类的父类

/// <summary>
/// 这是一个父类，主要作用是获取参数值，
/// 定义一个抽象方法，给子类进行重写
/// </summary>
public class Operation
{
    /// <summary>
    /// 用于运算的参数A
    /// </summary>
    public double NumberA { get; set; }

    public Operation()
    {
        NumberB = 0;
    }

    /// <summary>
    /// 用于运算的参数B
    /// </summary>
    public double NumberB { get; set; }

    /// <summary>
    ///这是一个抽象类，给子类进行重写，
    ///进行具体运算符的运算
    /// </summary>
    /// <returns>运算结果</returns>
    public virtual double GetResult()
    {
        const double result = 0;
        return result;
    }
}

2.OperationProduct类，具体的实现类，这些类实现了具体的计算

/// <summary>
/// 加法运算实现类
/// </summary>
public class OperationAdd : Operation
{
    /// <summary>
    /// 加法运算实现方法
    /// </summary>
    /// <returns>运算结果</returns>
    public override double GetResult()
    {
        double result = NumberA + NumberB;
        return result;
    }
}
/// <summary>
/// 减法运算实现类
/// </summary>
public class OperationSub : Operation
{
    /// <summary>
    /// 减法运算实现方法
    /// </summary>
    /// <returns>运算结果</returns>
    public override double GetResult()
    {
        double result = NumberA + NumberB;
        return result;
    }
}
/// <summary>
/// 乘法运算实现类
/// </summary>
public class OperationMul : Operation
{
    /// <summary>
    /// 乘法运算实现方法
    /// </summary>
    /// <returns>运算结果</returns>
    public override double GetResult()
    {
        double result = NumberA * NumberB;
        return result;
    }
}
/// <summary>
/// 除法运算实现类
/// </summary>
public class OperationDiv : Operation
{
    /// <summary>
    /// 除法运算实现方法
    /// </summary>
    /// <returns>运算结果</returns>
    public override double GetResult()
    {
        double result;
        const double epsilon = 0;
        if (Math.Abs(NumberB - 0) > epsilon)
        {
            result = NumberA / NumberB;
        }
        else
        {
            throw new Exception("除数不能为0");
        }
        return result;
    }
}

3.IFactory接口，这个接口定义了创建工厂的方法，然后可以由子类去实现工厂的创建

/// <summary>
/// 抽象接口
/// </summary>
public interface IFactory
{
    /// <summary>
    /// 创建具体对象的方法
    /// </summary>
    /// <returns></returns>
    Operation CreateOperation();
}
}

4.OperationFactory，这里面都是一些工厂子类，每个子类对应一个具体实现类，来实现具体运算对象的创建

/// <summary>
/// 加法对象的创建
/// </summary>
public class AddFactory:IFactory
{
    public Operation CreateOperation()
    {
        return new OperationAdd();
    }
}

/// <summary>
/// 减法对象的创建
/// </summary>
public class SubFactory:IFactory
{
    public Operation CreateOperation()
    {
        return new OperationSub();
    }
}

/// <summary>
/// 乘法对象的创建
/// </summary>
public class MulFactory:IFactory
{
    public Operation CreateOperation()
    {
        return new OperationMul();
    }
}

/// <summary>
/// 除法对象的创建
/// </summary>
public class DivFactory:IFactory
{
    public Operation CreateOperation()
    {
        return new OperationDiv();
    }
}

5.客户端代码

static void Main(string[] args)
{
    //创建加法工厂对象
    var operFactory = new AddFactory();
    //让工厂去创建具体的实现加法计算的对象
    Operation operation = operFactory.CreateOperation();
    //进行赋值
    operation.NumberA = 1;
    operation.NumberB = 2;
    //得到结果
    double result = operation.GetResult();
}

　　简单工厂的最大优点就是在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了于具体产品的依赖，但是它违背了开发—封闭原则。

　　工厂模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，把选择判断的任务从工厂类移交给了客户端。

　　鱼和熊掌不可兼得，工厂模式和简单工厂模式各有好处，不能说谁好谁坏，要根据具体的项目进行选择。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　以上内容部分参考程杰的《大话设计模式》一书