设计模式之简单工厂模式

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

一、业务逻辑：

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