C# 策略模式

前言：

  这是我学习的第二个模式，感觉学了模式编程越来越有趣了！

策略模式：

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

策略模式的结构图：

              

策略模式通过定义一个Context类，通过这个类进行具体的算法替换，使得具体的算法依赖Context的接口，通过它来决定具体使用哪个算法。

namespace 策略模式
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }


        abstract class CashSuper   //定义CashSuper抽象类，设置抽象方法 acceptCash
        {
            public abstract double acceptCash(double money);
        }
        class CashContext   //定义策略类CashContext
        {
            private CashSuper cs;
            public CashSuper(CashSuper csuper) 
            {
                this.cs = csuper;
            }

            public double GetResult(double money)
            {
                return cs.acceptCash(money);//生成相应的类
            }
        }
        class CashNormal : CashSuper   //原价类
        {
            public override double acceptCash(double money)
            {
                return money;
            }
        }
        class CashRebate : CashSuper   // 打折类
        {
            public double moneyRebate = 1d;
            public CashRebate(string moneyRebate)
            {
                this.moneyRebate = double.Parse(moneyRebate);
            }
            public override double acceptCash(double money)
            {
                return money * moneyRebate;
            }
        }
        class CashReturn : CashSuper  //返现金类
        {
            private double moneyCondition = 0.0d;
            private double moneyReturn = 0.0d;
            public CashReturn(string moneyCondition, String moneyReturn)
            {
                this.moneyCondition = double.Parse(moneyCondition);
                this.moneyReturn = double.Parse(moneyReturn);
            }
            public override double acceptCash(double money)
            {
                double result = money;
                if (money>=moneyCondition)
                    result = money - Math.Floor(money / moneyCondition) * moneyReturn;


                    return result;
            }

            class CashFactory
            {
                public static CashSuper createCashAccept(string type)
                {
                    CashSuper cs = null;
                    switch (type)
                    {
                        case "正常收费":
                            cs = new CashNormal();
                            break;
                        case "满300-100":
                            //CashReturn cr1 = new CashReturn("300", "100");
                            //cs = cr1;
                            cs= new CashReturn("300", "100");
                            break;
                        case"打八折":
                            //CashRebate cr2=new CashRebate("0.8");j
                            //cs = cr2;
                            cs = new CashRebate("0.8");
                            break;
                    }
                    return cs;
                }
            }
        }
        private void button_Click(object sender, RoutedEventArgs e)
        {
            CashContext cc = null;
            switch (comboBox.SelectedItem.ToString())
            {
                case "正常收费":
                    cc = new CashContext(new CashNormal());
                    break;
                case "满三百，返一百":
                    cc = new CashContext(new CashReturn("300", "100"));
                    break;
                case "打八折":
                    cc = new CashContext(new CashRebate("0.8"));
                    break;
            }
            double total = 0.0d;
            double totalPrices = cc.GetResult (Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
            total = total + totalPrices;
            lbxList.Items.Add("单价" + txtPrice.Text + "数量" + txtNum.Text + "合计" + totalPrices.ToString());
            result.Content= total.ToString();
        }
    }
}

我们通过写相应的算法：打折，原价，满减 这三个子类，同时在创建一个抽象策略CashSuper，然后在客户端进行判断需要哪个算法通过CashContext 这个类进行实际算法的转换就行了。

应用场景：

  1.针对同一类型问题的多种处理方式，仅仅是具体行为有差别时； 
  2.需要安全地封装多种同一类型的操作时； 
  3.出现同一抽象类有多个子类，而又需要来选择具体子类时。

总结：

    策略模式方便我们管理相关的算法和减少选择判断语句，但是如果策略过多那我们需要写的算法也就很客观，并且前提是我们可以正确的使用我们的策略，总的来说策略模式还是更有利于我们开发