《大话设计模式》学习笔记--策略模式

问题描述:实现一个商场收银软件，根据购买商品单价和数量，计算总价，应考虑商场有时会举行活动，如打折或者满减。

采用简单工厂模式的实现

//现金收费抽象类
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;
    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;
                break;
            case "打8折":
                CashRebate cr2 = new CashRebate("0.8");
                cs = cr2;
                break;
        }
        return cs;
    }
}

//客户端程序部分主要代码
double total = 0.0d;
private void btnOk_Click(object sender, EventArgs e)
{
    CashSuper csuper = CashFactory.createCashAccept(cbxType.selectedItem.ToString());
    double totalPrices = 0d;
    totalPrices = csuper.acceptCash(Convert.ToDouble(txtPrice.Text))
                  * Convert.ToDouble(txtNum.Text);
    total = total + totalPrices;
    lbxList.Items.Add("单价: " + txtPrice.Text + "数量：" + txtNum.Text + " "
                     + cbxType.SelectedItem + "合计：" + totalPrices.ToString());
    lblResult.Text = total.ToString();
}

简单工厂模式虽然解决了这个问题，但是这个模式仅是解决了对象的创建问题。而且利用此种方式，工厂本身包括了所有的收费方式，商场如果经常性更改活动策略，就要对于这个工厂进行维护扩展，代码需要重新编译部署，这其实并不合理。
这里就要提到另一种设计模式，策略模式：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

策略模式的基本代码

//Strategy类，定义所有支持的算法的公共接口
abstract class Strategy
{
    public abstract void AlgorithmInterface();
}

//ConcreteStrategy，封装了具体的算法或行为，继承于Strategy
class ConcreteStrategyA : Strategy
{
    public override void AlgorithmInterface()
    {
        Console.WriteLine("算法A实现");
    }
}

class ConcreteStrategyB : Strategy
{
    public override void AlgorithmInterface()
    {
        Console.WriteLine("算法B实现");
    }
}

class ConcreteStrategyC : Strategy
{
    public override void AlgorithmInterface()
    {
        Console.WriteLine("算法C实现");
    }
}

//Context，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用
class Context
{
    Strategy strategy;
    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }

    public void ContextInterface()
    {
        strategy.AlgorithmInterface();
    }
}

//客户端代码
static void Main(string[] args)
{
    Context context;

    context = new Context(new ConcreteStrategyA());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyB());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyC());
    context.ContextInterface();

    Console.Read();
}

上述给出了策略模式基本代码格式，利用策略模式对于之前的实现进行改写。之前写的CashSuper、CashNormal、CashRebate、CashReturn都不用修改，只需要添加CashContext类，并且对于客户端程序进行修改。

采用策略模式的实现

//CashContext类
class CashContext
{
    private CashSuper cs;

    public CashContext(CashSuper csuper)
    {
        this.cs = csuper;
    }

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

//客户端部分主要代码
double total = 0.0d;
private void btnOk_Click(object sender, EventArgs e)
{
    CashContext cc = null;
    switch (cbxType.SelectedItem.ToString())
    {
        case "正常收费":
            cc = new CashContext(new CashNormal());
            break;
        case "满300返100":
            cc = new CashContext(new CashReturn("300","100"));
            break;
        case "打8折":
            cc = new CashContext(new CashRebate(0.8));
            break;
    }

    double totalPrices = 0d;
    totalPrices = cc.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
  
    total = total + totalPrices;
    lbxList.Items.Add("单价: " + txtPrice.Text + "数量：" + txtNum.Text + " "
                     + cbxType.SelectedItem + "合计：" + totalPrices.ToString());
    lblResult.Text = total.ToString();
}

这样一来，就利用策略模式实现了收银软件的功能，但是，判断过程存在于客户端之中。这里可以使用简单工程和策略模式结合的方式改进。

策略模式与简单工厂模式结合实现

//改写后的CashContext
class CashContext
{
    CashSuper cs = null;

    public CashContext(string type)
    {
        switch (type)
        {
            case "正常收费":
                CashNormal cs0 = new CashNormal();
                cs = cs0;
                break;
            case "满300返100":
                CashReturn cr1 = new CashReturn("300", "100");
                cs = cr1;
                break;
            case "打8折":
                CashRebate cr2 = new CashRebate("0.8");
                cs = cr2;
                break;
        }
    }

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

//客户端代码
private void btnOk_Click(object sender, EventArgs e)
{
    CashContext csuper = new CashContext(cbxType.SelectedItem.ToString());
    double totalPrices = 0d;
    totalPrices = csuper.GetResult(Convert.ToDouble(txtPrice.Text))
                  * Convert.ToDouble(txtNum.Text);
    totalPrices = total + totalPrices;
    lbxList.Items.Add("单价: " + txtPrice.Text + "数量：" + txtNum.Text + " "
                     + cbxType.SelectedItem + "合计：" + totalPrices.ToString());
    lblResult.Text = total.ToString();
}

以上实现结合了简单工厂模式与策略模式，使得客户端只需利用CashContext类即可，耦合度得到了进一步降低。
总而言之，策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。策略模式的另一个优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口进行单独测试。

参考书籍:《大话设计模式》