简单工厂模式和策略模式的区别

     看书上的介绍《大话设计模式》，这两很像，都是用一个专门的类来根据客户端的条件产生不同的类，实现不同的功能。两个有什么区别呢，怎么取舍呢，没有自己写过实际的运用，有点晕啊，只能侃侃，耍耍嘴皮子。

      从客户端来看，简单工厂需要至少需要两个类，一个是工厂类Factory，用来产生具体的功能类Function，一个是这个Function类，在这个Function类中定义可以被要被重写的方法。客户端使用的时候首先要使用Factory类根据客户端条件，产生具体的Function类，然后再使用Function类中的方法实现具体的功能；策略类，在客户端也要接触两个类，一个是想要的具体算法类Category，一个是上下文类Context，Context类的构造方法接受一个Category类型对象，然后调用这个对象的具体算法实现具体的功能，Context类和Factory有点类似，和简单工厂模式不同的是Context接受一个对象，用这个对象来实例化自己，然后来调用自己的方法，当然这个方法是用这个对象中的方法。而Factory类接受条件产生一个对象，具体使用这个对象的方法还是要调用这个对象中的方法，而不是Factory中的方法。就是说Factory只负责获得对象，Context要依靠一个具体的对象来实例化自己，并调用具体的功能方法。

     从类的结构来看Factory只要包含一个根据条件创建对象的方法CreateFunction(),Context类需要定义自己的构造函数，和一个实现具体功能的方法。

     简单工厂中包含了必要的逻辑判断，根据客户端选择条件动态实例化相关的类。策略模式中具体的策略类要在客户端判断，然后再上下文类中调用方法。

     简单工厂代码如下：

public class Factory
{
  public static Function CreateObject(string condition)
  {
    Function ft = null;
    switch condition:
    case conditionA:
    {
      ft = new FunctionA();
      break;
    }
    case conditionB:
    {
      ft = new FunctionB();
      break;
    }
    default:
    break;
  }
}
public calss Function
{
   public virtual void DoSomething()
   {
     .... ....
   }
}
public class FunctionA:Function
{
 public void override DoSomething()
 {
   .... ...
 }
}
public calss FuctionB:Function
{
  public void override DoSomething()
  {
    .... ....
  }
}
public static void main()
{
  string condition = "asdfasdf";
  Function fc = Factory.CreateObject(condition);
  fc.DoSomething(); 
}

策略模式代码如下：

public class Context
{
  private Strategy st;
  public Context(Strategy st)
  {
     this.st = st;
  }
  public void DoStragegyWork()
  {
     st.DoSomeWork();
  }
}
abstract class Strategy
{
  public abstract void DoSomeWork();
}
public class StrategyA:Strategy
{
  public override void DoSomeWork()
  { A... ... }
}
public class StrategyB:Strategy
{
  public override void DoSomeWork()
  { B... ... }
}
public static void main(string args[])
{
  StrategyB sb = new StrategyB();
  Context ct = new Context(sb);
  ct.DoStragegyWork(); 
}

可以让策略模式和简单工厂模式结合起来，让new Context(sb);这个构造方法接受一个条件变量，在方法体中根据这个变量产生具体的类来实例化。

 具体方法如下：

public class Context
{
  private Strategy st;
  public Context(string condition)
  {
     switch("conditionA")
     this.st = new StrategyA();
     break;
     switch("conditionB")
     this.st = new StrategyB();
     break;
     default:
     break;
  }
  public void DoStragegyWork()
  {
     st.DoSomeWork();
  }
}
abstract class Strategy
{
  public abstract void DoSomeWork();
}
public class StrategyA:Strategy
{
  public override void DoSomeWork()
  { A... ... }
}
public class StrategyB:Strategy
{
  public override void DoSomeWork()
  { B... ... }
}
public static void main(string args[])
{
  StrategyB sb = new StrategyB();
  Context ct = new Context(sb);
  ct.DoStragegyWork(); 
}

     哪位大侠可以举个在项目中的运用，贴点简单的代码看看，先谢谢了。我这些都是从书本里得来的。