在对比两种模式之前，首先需要学习 开放-封闭原则。在以前学习的过程中，听说过很多次，编写程序要遵循开闭原则。
在做项目的过程中，因为需求的添加，经常会更新软件。更新软件，就要设计到修改代码了。在面向对象的程序设计中，经常会写类。如果因为添加需求，去修改已经完成的类。那么他是不符合开闭原则的。
添加需求，应该让代码去扩展，而不是去修改。通过抽象类和继承来实现开闭原则。
开闭原则：对于扩展是开放的，对于更改是封闭的。
使用开闭原则，可以给面向对象的程序设计带来巨大的好处，使得代码可维护、可扩展、可复用、灵活性好。
首先来看一下简单工厂模式：
实现的代码：
public class Operation //定义操作类
{
private double num1 = 0;
private double num2 = 0;
public double NumberA //第一个操作数
{
get { return num1; }
set { num1 = value;}
}
public double NumberB //第二个操作数
{
get { return num2; }
set { num2 = value; }
}
public virtual double GetResult() //返回执行结果
{
double result = 0;
return result;
}
}
public class OperationAdd : Operation //加法类，继承操作类
{
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}
public class OperationSub : Operation //减法类，继承操作类
{
public override double GetResult()
{
double result;
result = NumberA - NumberB;
return result;
}
}
public class OperationMul : Operation //乘法类，继承操作类
{
public override double GetResult()
{
double result;
result = NumberA * NumberB;
return result;
}
}
public class OperationDiv : Operation //除法类，继承操作类
{
public override double GetResult()
{
double result;
result = NumberA / 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;
}
return oper;
}
}
通过上面的例子，你会发现，在简单工厂模式中，如果要增加需求，必须修改的类有OperationFactory，每次增加需求都需要修改工厂，这样是既对扩展开放，又对修改也开放了。这就就违背了 开-闭 原则。
在简单工厂里面，不需要管改用哪个类的实例，只需要把'+'给工厂，工厂自动就给出了相应的实力。客户端只需要去做运算就可以了。根据不同的实例去实现不同的运算，扩展需要修改工厂中的case语句。所以违背了开闭原则。
对于工厂模式，根据不同的实例，来对应不同的工厂。对修改进行封闭。如果需要扩展，只需要增加相应的工厂类即可。这样就不需要修改原有的工厂了。
在来看一下工厂模式：
实现的代码：
class Program
{
static void Main(string[] args)
{
}
}
public class Operation //定义操作类
{
private double num1 = 0;
private double num2 = 0;
public double NumberA //第一个操作数
{
get { return num1; }
set { num1 = value; }
}
public double NumberB //第二个操作数
{
get { return num2; }
set { num2 = value; }
}
public virtual double GetResult() //得到执行结果
{
double result = 0;
return result;
}
}
public class OperationAdd : Operation //加法类，继承操作类
{
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}
public class OperationSub : Operation //减法类，继承操作类
{
public override double GetResult()
{
double result;
result = NumberA - NumberB;
return result;
}
}
public class OperationMul : Operation //乘法类，继承操作类
{
public override double GetResult()
{
double result;
result = NumberA * NumberB;
return result;
}
}
public class OperationDiv : Operation //除法类，继承操作类
{
public override double GetResult()
{
double result;
result = NumberA / NumberB;
return result;
}
}
interface IFactory //建立一个工厂接口
{
Operation CreateOperation();
}
class AddFactory : IFactory //加法类工厂
{
public Operation CreateOperation()
{
return new OperationAdd();
}
}
class SubFactory : IFactory //减法类工厂
{
public Operation CreateOperation()
{
return new OperationSub();
}
}
class MulFactory : IFactory //乘法类工厂
{
public Operation CreateOperation()
{
return new OperationMul();
}
}
class DivFactory : IFactory //除法类工厂
{
public Operation Cr