策略模式

应用场景

一个商场收银软件，营业员根据客户所购买的商品的单价和数量，向客户收费

用两个文本框来输入单价和数量，一个确定按钮来算出每种商品的费用，用个列表框来记录商品的清单，一个标签来记录总计，一个重置按钮来重新开始。

  1.  double total = 0.0d;
  2.  private void btn0k_Click(object sender, EventArgs e)
  3.  {
  4.      double totalPrices = Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text);
  5.      total = total + totalPrices;
  6.      IbxList.Items.Add("单价：" +txtPrice.Text + "数量：" ＋ txtNum.Text + "合计："+ totalPrices.ToString());
  7.      IblResult.Text = total.ToString();
  8.  }

比如遇到节假日 增加打折

  1.  double total = 0.0d;
  3.  private void Form_Load(object sender, EventArgs e)
  4.  {
  5.      cbxType.Items.AddRange(new object[] {"正常收费","打八折","打五折"});
  6.      cbxType.SlectedIndex = 0;
  7.  }
  9.  private void btn0k_Click(object sender, EventArgs e)
  10.  {
  11.  double totalPrices = 0.0d;
  12.  switch(cbxType.Selectedindex)
  13.  {
  14.      case 0:
  15.               totalPrices = Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text);
  16.      case 1:
  17.               totalPrices = Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text)*0.8;
  18.      case 2:
  19.               totalPrices = Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text)*0.5;
  20.  }
  21.     total = total + totalPrices;
  22.      IbxList.Items.Add("单价：" +txtPrice.Text + "数量：" ＋ txtNum.Text + "合计："+ totalPrices.ToString());
  23.      IblResult.Text = total.ToString();
  24.  }

简单工厂实现

面对对象的编程，并不是类越多越好，类的划分是为了封装，但是分装的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。打一折和打九折只是形式的不同，抽象分析出来，所有的打折算法都是一样的，所以打折算法应该是一个类。

  1. //现金收费抽象类
  2. abstract class CashSuper
  3. {
  4.     public abstract double acceptCash(double money);
  5. }
  7. //正常收费子类
  8. class CashNormal: CashSuper
  9. {
  10.     public override double acceptCash(double money)
  11.     {
  12.         return money;
  13.     }
  14. }
  16. //打折收费子类
  17. class CashRebate: CashSuper
  18. {
  19.     private double moneyRebate = 1d;
  20.     public Cash Rebebate(string moneyRebate)
  21.     {
  22.         this.moneyRebate = double.Parse(moneyRebate);
  23.     }
  24.     publci override double acceptCash(double money)
  25.     {
  26.         return money * moneyRebate;
  27.     }
  28. }
  30. //返利收费子类
  31. class cashReturn: CashSuper
  32. {
  33.     private double moneyCondition = 0.0d;
  34.     private double moneyreturn = 0.0d;
  35.     public CashReturn(string moneyCondition, string moneyReturn)
  36.     {
  37.         this.moneyCondition = double.Parse(moneyCondtion);
  38.         this.moneyReturn = double.Parse(moneyReturn);
  39.     }
  41.     public override double acceptCash(double money)
  42.     {
  43.         double result = money;
  44.         if(money >= moneyCondition)
  45.         {
  46.             result = money - Math.Floor(money / moneyCondition) * moneyReturn;
  47.         }
  48.             return result;
  49.     }
  51. }
  53. //现金收费工厂类
  54. class CashFactory
  55. {
  56.     public static CashSuper createCashAccept(string type)
  57.     {
  58.         CashSuper cs = null;
  59.         switch (type)
  60.         {
  61.             case:"正常收费":
  62.                 cs = new CashNormal();
  63.                 break;
  64.             case:"满300返100":
  65.                 CashReturn cr1 = new CashReturn("300","100");
  66.                 cs = cr1;
  67.                 break;
  68.             case:"打8折":
  69.                 CashRebate cr2 = new CashRebate("0,8");
  70.                 cs = cr2;
  71.                 break;
  72.         }
  73.         return cs;
  74.     }
  75. }
  77. //客户端程序主要部分
  78. double total = 0.0d;
  79. private void btn0k_clik(object sneder, EventArgs e)
  80. {
  81.     cashSuper csuper = CashFactory.createCashAccept(cbxType.SelectedItem.ToString());
  82.     double totalPrices = 0d;
  83.     totalPrices = csuper.acceptCash(Convert.ToDouble(txtPrice.txt)*Convert.ToDouble(txtNum.Text));
  84.     total = total + totalPrices;
  85.     IbxList.Items.Add("单价：" +txtPrice.Text + "数量：" ＋ txtNum.Text + "合计："+ totalPrices.ToString());
  86.      IblResult.Text = total.ToString();
  88. }

简单工厂模式虽然能解决这个问题，但是这个模式知识解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场是可能经常性地更改打折额度和返利额度，每次维护或扩展收费方式都要改动这个工厂，以致代码需重新编译部署，这真的是很糟糕的处理方式，所以用它不是做好的办法，。面对算法的时常变动应该有更好的办法。

策略模式

策略模式定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

  1. //CashContext类    
  2. class CashContext
  3. {
  4.     private CashSuper cs;
  5.     public CashContext(CashSuper csuper)
  6.     {
  7.         this.cs = csuper;
  8.     }
  10.     public double GetResult(double money)
  11.     {
  12.         return cs.accptCash(money);
  13.     }
  15. }
  17. //客户端主要代码
  18. double total = 0.0d;
  19. private void btn0k_Click(object sender, EventArgs e)
  20. {
  21.     CashContext cc = null;
  22.     switch (cbxType.selectedItem.ToString())
  23.     {
  24.         case: "正常收费":
  25.             cc = new CashContext(new CashNormal());
  26.             break;
  27.         case: "满300返100":
  28.             cc = new CashContext(new CashReturn ("300","100"));
  29.             break;
  30.         case: "打8折":
  31.             cc = new CashContext(new CashRebate("0.8"));
  32.             break;
  33.     }
  34.     double totalPrices = 0d;
  35.     totalPrices = cc.GetResult(convert.ToDouble(txtPrice.Text)*convert.ToDouble(txtNum.Text));
  36.     total = total + totalPrices;
  37.     IbxList.Items.Add("单价：" +txtPrice.Text + "数量：" ＋ txtNum.Text + "合计："+ totalPrices.ToString());
  38.      IblResult.Text = total.ToString();
  40. }

虽然策略模式写出来了，但是不应该让客户端去判断用哪一个算法。

策略与简单工厂结合

  1. class CashContext
  2. {
  3.     CashSuper cs  = null;
  5.     public CashContext(String type)
  6.     {
  7.         switch(type)
  8.         {
  9.             case "正常收费":
  10.                 CashNormal cs0 = new CashNormal();
  11.                 cs = cs0;
  12.                 break;
  13.             case "满300返100":
  14.                 CashReturn cr1 = new CashReturn("300","100");
  15.                 cs = cr1;
  16.                 break;
  17.             case "打8折"：
  18.                 CashReturn cr2 = new CashRebate("0.8");
  19.                 cs = cr2;
  20.                 break;
  21.         }
  22.         public double GetResult(double money)
  23.         {
  24.             return cs.acceptCash(money);
  25.         }
  26.     }
  27. }
  29. //客户端代码
  30. double total = 0.0d;
  31. private void btn0k_Click(object sender, EvnetArgs e)
  32. {
  33.     CashContext csuper = new CashContext(cbxType.slectedItem.ToString());
  34.     double totalPrices = 0d;
  35.     totalPrices = csuper.GetResult(Convert.ToDouble(txtPrice.Text)*Convert.ToDouble(txtNum.Text));
  36.     total = total + totalPrices;
  37.     IbxList.Items.Add("单价：" +txtPrice.Text + "数量：" ＋ txtNum.Text + "合计："+ totalPrices.ToString());
  38.      IblResult.Text = total.ToString();    
  39. }
  41. //简单工厂模式的用法
  42. CashSuper csuper = CashFactory.CreateCashAccept(cbxType.SelectedItem.ToString());
  43. =csuper.GetResult;
  45. //策略模式与简单工厂结合的用法
  46. CashContext csuper = new (CashContext(cbxType.SelectedItem.ToString()));
  47. =csuper.GetResult;

简单工厂模式让客户端认识两个类， CashSuper和CashFactory,而策略模式与简单工厂结合的用法，客户端只需要认识一个类CashContext就可以了。耦合更加降低。

策略模式解析

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相通的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少各种算法类和使用算法类之间的耦合。
策略模式就是用来封装算法的，但是实践中，我们发现可以用它来分装几乎任何类型的规则，只要在分析过程中听到需要在不同的时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。