C#设计模式三(简单工厂模式)

C#设计模式之简单工厂类

一、引言

如果将类比作是产品的话，那么new一个对象就是生产出一个产品。
现在有若干个类需要我们进行选择性的生产，那么这时就会引出一个概念叫做工厂。

何为工厂？
工厂就是能够生产出各种产品的地方，生产需求根据客户的要求生产。在程序中简单的来说就是，可以指定一个工厂new出一个指定的类来。其他没有选择到的类不用new，以防资源泄露。整个new的过程全部在工厂内部完成，客户无需干涉。

二、简单工厂应用的场景

简单工厂非常合适应用在同一个数据，不同的操作上。例如计算器。
如果想要对两个数进行加/减/乘/除运算时。因为两个数都是一样的，而方法可以选择不同的。这类情况下，没必要将加减乘除四个类全部创建实例，可以通过工厂来选择新建需要的那个，然后进行相关计算。

三、简单工厂模式实例

//操作基本规范，此为父类以可看做是标准规范的接口

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

//加减乘除等具体计算类，他们全部继承自Operation。符合一定规范

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

class OperationSqr : Operation  //平方
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberB * NumberB;
        return result;
    }
}

class OperationSqrt : Operation  //平方根
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB < 0)
            throw new Exception("负数不能开平方根。");
        result = Math.Sqrt(NumberB);
        return result;
    }
}

class OperationReverse : Operation //相反数
{
    public override double GetResult()
    {
        double result = 0;
        result = -NumberB;
        return result;
    }
}

//运算工厂，主要是选择性的新建某个指定的类

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;
                }
            case "sqr":
                {
                    oper = new OperationSqr();
                    break;
                }
            case "sqrt":
                {
                    oper = new OperationSqrt();
                    break;
                }
            case "+/-":
                {
                    oper = new OperationReverse();
                    break;
                }
        }

        return oper;
    }
}

//客户端

//简单工厂的核心在于通过工厂来选择需要新建那一个类。从而根据选择的类来进行相关操作
//而工厂中的类又都是符合一定标准规范，即他们都是派生自同一个父类，所以具有统一个接口

class Program
{
    static void Main(string[] args)
    {
        try
        {
            Console.Write("请输入数字A：");
            string strNumberA = Console.ReadLine();
            Console.Write("请选择运算符号(+、-、*、/)：");
            string strOperate = Console.ReadLine();
            Console.Write("请输入数字B：");
            string strNumberB = Console.ReadLine();
            string strResult = "";

            Operation oper;
            oper = OperationFactory.createOperate(strOperate); //通过运算工厂来选择需要新建那个类来作为当前需要的类
            oper.NumberA = Convert.ToDouble(strNumberA);       //将选好的类的数值A赋值
            oper.NumberB = Convert.ToDouble(strNumberB);       //将选好的类的数值B赋值
            strResult = oper.GetResult().ToString();           //访问选好类中的方法返回操作结果

            Console.WriteLine("结果是：" + strResult);

            Console.ReadLine();
        }
        catch (Exception ex)
        {
            Console.WriteLine("您的输入有错：" + ex.Message);
        }
    }
}

四、总结

简单运算工厂就是选择性的创建某个指定的类的对象，其他没用到的对象不创建。

这样做，实际上将一个类的新建放在了工厂内部完成，客户端使用中不需要干涉具体的实现类。只需要和工厂打交道即可。

相关关系图如下：