设计模式（二）： 策略模式

概要：

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

当有一组算法完成的都是相同的工作，只是实现不同，以相同的方式调用所有的算法。在这种情况下可以使用策略模式，可减少各类算法类与使用算法类之间的耦合。

问题初探：

这边就以简单的数字加减举例。

static class Calculate
{
    private static string Add = "+";
    private static string Subtract = "-";

    public static double Calac(double a, double b, string symbol)
    {
        double result = 0.0;
        if (symbol == Add)
        {
            result = a + b;
        } else if (symbol == Subtract)
        {
            result = a - b;
        }

        return result;
    }
}

 

这样写的化，在后期代码扩展*或者/的时候，就需要添加新的if 判断，代码臃肿且扩展性低。

如果使用策略模式，将各类运算归结到不同的策略中，会有很强的扩展性。那下面看下该模式。

模式讲解：

策略模式结构图：

组成：

1.抽象策略角色（Straetegy）: 这是一个抽象类，通常情况下使用接口或抽像类去实现。

2.具体策略角色（ConcreteStrategyA....）: 包装了具体的算法和行为。也就是实现 抽象策略角色 接口的实现类。

3.环境角色（Context）： 持有一个抽象角色的引用，给客户端调用。

结构图的实现：

Strategy 类，定义所有支持的算法和公共接口：

abstract class Strategy
{
    // 算法方法
    public abstract void Algorithmlnterface();
}

ConcreteStrategy，封装了具体的算法或行为，继承于Strategy.

// 具体算法A
class ConcreteStrategyA : Strategy
{
    public override void Algorithmlnterface()
    {
        Console.WriteLine("算法A 的实现");
    }
}

// 具体算法B
class ConcreteStrategyB : Strategy
{
    public override void Algorithmlnterface()
    {
        Console.WriteLine("算法B 的实现");
    }
}

// 具体算法 C
class ConcreteStrategyC : Strategy
{
    public override void Algorithmlnterface()
    {
        Console.WriteLine("算法C 的实现");
    }
}

 Context，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用。

// 上下文
class Context
{
    Strategy strategy;
    // 初始化时，传入具体的策略对象
    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }
    // 上下文
    public void ContextInterface()
    {
        // 根据具体的策略对象，调用其算法的方法
        strategy.Algorithmlnterface();
    }
}

客户端代码

static void Main(string[] args)
{
    Context context;

    // 由于实例化不同的策略，所以最终在调用 context.ContextInterface(); 时，所获得的结果就不尽相同
    context = new Context(new ConcreteStrategyA());
    context.ContextInterface();

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

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

 问题改进：

 了解了策略模式，那改写一下上面的加减算法吧。

// 定义抽象类接口
public interface ICalculator
{
    double Calc(double a, double b);
}

// 加减的实现
public class Add : ICalculator
{
    public double Calc(double a, double b)
    {
        return a + b;
    }
}

public class Sub : ICalculator
{
    public double Calc(double a, double b)
    {
        return a - b;
    }
}

// 上下文
public class ClcContext
{
    private ICalculator mcalculator;

    public ClcContext(ICalculator calculator)
    {
        this.mcalculator = calculator;
    }

    public double Clc(double a, double b)
    {
        return mcalculator.Calc(a, b);
    }
}

 

客户端这样调用就可以了

static void Main(string[] args)
{
    // 客户端调用
    ICalculator icalculator = new Add();
    ClcContext context = new ClcContext(icalculator);
    double result = context.Clc(1,2);
}

 

如果后期在加乘法的扩展就会方便很多，添加类继承即可。

特点：

• 抽象类中可以定义一系列可供重复使用的算法或行为，继承有助于取出这些算法中的公共功能。
• 简化了单元测试，每个算法有自己的类，可以通过自己的接口单独测试。
• 当不同的行为堆砌在一个类中，就需要使用条件语句来选择合适的方法，当使用策略模式时，可消除条件判断。
• 策略模式就是用来封装算法，但在实现中，几乎可以用他封装任何类型的规则，只要在分析过程中需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化。

策略模式还可以于 简单过程模式 结合，使代码的耦合度更加降低。