设计模式之简单工厂模式

　　本程序分为三个部分：业务逻辑，页面逻辑，生产对象的工厂

一、业务逻辑：

　　1. Operation类

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

namespace SimpleFactory.Caculation_bll
{
    /// <summary>
    /// 所有具体策略类的父类
    /// </summary>
    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;
        }
    }
}

　　2. AddOperation类

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

namespace SimpleFactory.Caculation_bll
{
    /// <summary>
    /// 加法运算的具体实现类
    /// </summary>
    class AddOperation:Operation
    {
        /// <summary>
        /// 加法运算的具体实现
        /// </summary>
        /// <returns>加法运算结果</returns>
        public override double GetResult()
        {
            return NumberA + NumberB;
        }
    }
}

 　　3. SubOperation类

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

namespace SimpleFactory.Caculation_bll
{
    /// <summary>
    /// 减法运算的具体实现类
    /// </summary>
    class SubOperation:Operation
    {
        /// <summary>
        /// 减法运算的具体实现
        /// </summary>
        /// <returns>减法运算结果</returns>
        public override double GetResult()
        {
            return NumberA - NumberB;
        }
    }
}

　　4. MulOperation类

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

namespace SimpleFactory.Caculation_bll
{
    /// <summary>
    /// 乘法运算的具体实现类
    /// </summary>
    class MulOperation:Operation
    {
        /// <summary>
        /// 乘法运算的具体实现
        /// </summary>
        /// <returns>乘法运算结果</returns>
        public override double GetResult()
        {
            return NumberA * NumberB;
        }
    }
}

　　5. DivOperation类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SimpleFactory.Caculation_ui;

namespace SimpleFactory.Caculation_bll
{
    /// <summary>
    /// 除法运算的具体实现类
    /// </summary>
    class DivOperation : Operation
    {
        /// <summary>
        /// 除法运算的具体实现
        /// </summary>
        /// <returns>除法运算结果</returns>
        public override double GetResult()
        {
            //排除除数为0的情况
            if (NumberB==0)
            {
                return 0;
            }
            
            return NumberA / NumberB;
        }
    }
}

二、页面逻辑

　　1. AchieveDouble类

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

namespace SimpleFactory.Caculation_ui
{
    /// <summary>
    /// 获取参与运算的数字
    /// </summary>
    public class AchieveDouble
    {
        //用于计获取了多少个数字
        private static int count = 0;

        /// <summary>
        /// 获取参与运算的数字
        /// </summary>
        /// <returns>参与运算的数字</returns>
        public static double GetFromConsoleAchieveDouble()
        {
            double number;
            Console.WriteLine("请输入第{0}个数字：",count+1);
            do
            {
                double temp; //中间变量
                try
                {
                    temp = Convert.ToDouble(Console.ReadLine());
                }
                catch (Exception)
                {
                    Console.WriteLine("请刚刚输入有误，请重新输入第{0}个数字：",count+1);
                    continue;
                }

                number = temp;
                break;

            } while (true);
            count++;
            return number;
        }
    }
}

 　　2. AchieveOperator类

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

namespace SimpleFactory.Caculation_ui
{
    /// <summary>
    /// 获取运算符
    /// </summary>
    class AchieveOperator
    {
        public static string GetFromConsoleOperator()
        {
            string oper;
            Console.WriteLine("请输入运算字符：");
            do
            {
                string temp = Console.ReadLine();
                if (temp != "+" && temp != "-" && temp != "*" && temp != "/")
                {
                    Console.WriteLine("你刚刚输入有误，请重新输入运算字符：");
                    continue;
                }

                oper = temp;
            } while (true);
            return oper;
        }
    }
}

　　3. Caculation类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SimpleFactory.Caculation_bll;
using SimpleFactory.Caculation_factory;

namespace SimpleFactory.Caculation_ui
{
    class Caculation
    {
        static void Main(string[] args)
        {
            double numberA = AchieveDouble.GetFromConsoleAchieveDouble(); //获取第一个数字
            double numberB = AchieveDouble.GetFromConsoleAchieveDouble(); //获取第二个数字
            string oper = AchieveOperator.GetFromConsoleOperator(); //获取运算符

            Operation operation = Factory.GetInstance(oper);
            operation.NumberA = numberA;
            operation.NumberB = numberB;
            double result = operation.GetResult();

            Console.WriteLine("{0} {1} {2} = {3}",numberA,oper,numberB,result);
        }
    }
}

三、生成对象的工厂

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SimpleFactory.Caculation_bll;

namespace SimpleFactory.Caculation_factory
{
    /// <summary>
    /// 生成对象的工厂
    /// </summary>
    public class Factory
    {
        /// <summary>
        /// 生成对象的工厂
        /// </summary>
        /// <param name="oper">传输的运算符号</param>
        /// <returns>参与运算的对象</returns>
        public static Operation GetInstance(string oper)
        {
            Operation operation = null;
            switch (oper)
            {   
                case "+":
                    operation = new AddOperation(); //实例加法对象
                    break;
                case "-":
                    operation = new SubOperation(); //实例减法对象
                    break;
                case "*":
                    operation = new MulOperation(); //实例乘法对象
                    break;
                case "/":
                    operation = new DivOperation(); //实例除法对象
                    break;
            }
            return operation;
        }
    }
}