设计模式——策略模式

慢慢的做记录，做最强大的自己

看了大话设计模式之后感触很深，发现自己还有很多学习的东西，设计软件并不是一两句代码把功能写完了就行，需要思考的内容有很多

代码来源参考大话设计模式这本书，这里在博客里记录一下，不可能每次都去翻书，但是在博客里面是非常好找的。

       

        面向对象的编程，要尽量避免重复创建出类，做数据处理的时候最容易出现这个问题，比如做一个商城系统，商城里面针对同一件商品可能有不同的折扣，这是存在的，比如我的用户对象不同。

那么问题来了，我总不可能每次都针对商品去判断用户角色是什么然后给出不同的折扣，对同一个用户来说，不同的商品还有不同的折扣，写if语句来判断这时候就显得耗时耗力了，而且代码也并不好维护；

同样的，用简单工厂模式会存在一个问题，当我要新增一个折扣时，那么我必然要去修改工厂里的东西，这种情况下，用工厂模式肯定是不行的，这时候我们就需要用到策略模式。

       像打折这一类的情况分几种，我有直接的折扣，也有满多少返现多少，那么我怎么统一这种方法，然后让一个策略类定义这些折扣类，下面看下详细的代码：

首先，创建一个折扣的类：

 abstract class CashSuper
    {
        public abstract double acceptCash(double money);

    }

    //正常收费子类
    class CashNormal : CashSuper
    {
        public override double acceptCash(double money)
        {
            return money;
        }
    }

    //打折收费子类
    class CashRebate : CashSuper
    {
        private double moneyRebate = 1d;

        //打折收费率，初始化时，必须要输入折扣率，如八折就是0.8
        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 moneyCodition, string moneyReturn)
        {
            this.moneyCondition = double.Parse(moneyCodition);
            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 CashContext
    {
        private CashSuper cs;
        public CashContext(CashSuper csuper)
        {
            this.cs = csuper;
        }

        public double GetResult(double money)
        {
            return cs.acceptCash(money);
        }
    }

在交互端的代码里面我们就可以通过实例化不同的策略来实现我们的折扣方法了，这样我们就避免了在简单工厂类里面反复添加条件及相应的返回对象

具体的看客户端里面的策略实例化

 private void button1_Click(object sender, EventArgs e)
        {
            //CashSuper csuper = CashFactory.createCashAccept(comboBox1.SelectedItem.ToString());
            CashContext cs = null;
            switch (comboBox1.SelectedItem.ToString())
            {
                case "正常收费":
                    cs = new CashContext(new CashNormal());
                    break;
                case "满300返100":
                    cs = new CashContext(new CashReturn("300","100"));
                    break;
                case "打八折":
                    cs = new CashContext(new CashRebate("0.8"));
                    break;


            }

            double TotalPrices = 0d;
            TotalPrices = cs.GetResult(Convert.ToDouble(textBox1.Text) * Convert.ToDouble(textBox2.Text));
            Total = Total + TotalPrices;
            listBox1.Items.Add("单价：" + textBox1.Text + "数量：" + textBox2.Text + " " + comboBox1.SelectedItem + "合计:" + TotalPrices.ToString());
            label4.Text = Total.ToString();
        }

这里，我们可以看到三个实例化的策略

cs = new CashContext(new CashNormal());

cs = new CashContext(new CashReturn("300","100"));

cs = new CashContext(new CashRebate("0.8"));

如果不想把这个判断的逻辑放到交互端来处理，那么同样的道理，我们可以把实例化的过程转移到策略类中，然后再把参数给传递进去，就可以实现这个过程了。
这里也解释一下策略模式：策略模式相当于你定义了一系列的计算的方法或者是处理方法，从概念上，可能这类方法处理的东西很相似，但是实现的过程不同，
他可以以相同的方式来调用所有的算法，减少了各种算法类与使用算法类之间的耦合，哪怕我修改了其中的一个处理方法，也不会影响到其他的方法，对结果也不会
造成太大的影响，对使用者来说，我只需要得到结果就可以了，而跟整个过程就无关了。

下面看一下结果吧

可能编程的代码规范不是很规范，匆忙之间就随便写了一下，但是实际做项目的时候还是得注意的，下次继续记录其他的设计模式，对代码优化能起到很大的作用，
特别是反射，依赖注入这些，后续都会一一记录 下来