【设计模式】策略模式

策略模式（Strategy Pattern）

概念：

· 定义一系列算法，将它们封装起来，并使它们可以相互替换，使得算法的变化独立于客户端；

UML结构：

复制代码

        ┌─────────────────┐
        │    Strategy     │  ← 抽象策略接口
        │ + Algorithm()   │
        └─────────────────┘
                 ▲
                 │
   ┌─────────────┼───────────────┐
   │             │               │
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ ConcreteStrategyA │ ConcreteStrategyB │ ConcreteStrategyC │  ← 具体策略
│ + Algorithm()    │ + Algorithm()    │ + Algorithm()    │
└─────────────┘ └─────────────┘ └─────────────┘
                 ▲
                 │
        ┌─────────────────┐
        │    Context      │  ← 上下文
        │ - strategy: Strategy │
        │ + SetStrategy()      │
        │ + ExecuteAlgorithm() │
        └─────────────────┘

代码示例：

cs 复制代码

/// <summary>
/// 抽象策略
/// </summary>
public abstract class StrategyBase
{
    public abstract void Algorithm();
}

/// <summary>
/// 具体策略A
/// </summary>
public class ConcreteStrategyA : StrategyBase
{
    public override void Algorithm()
    {
        Console.WriteLine("执行策略A的算法");
    }
}

/// <summary>
/// 具体策略B
/// </summary>
public class ConcreteStrategyB : StrategyBase
{
    public override float Algorithm()
    {
        Console.WriteLine("执行策略B的算法");
    }
}

/// <summary>
/// 具体策略C
/// </summary>
public class ConcreteStrategyC : StrategyBase
{
    public override void Algorithm()
    {
        Console.WriteLine("执行策略C的算法");
    }
}

/// <summary>
/// 上下文
/// </summary>
public class Context
{
    public StrategyBase _currentStrategy; // 当前策略

    public Context(StrategyBase strategy)
    {
        this._currentStrategy = strategy;
    }

    public void SetStrategy(StrategyBase strategy)
    {
        this._currentStrategy = strategy;
    }

    public void ExecuteStrategy()
    {
        this._currentStrategy.Algorithm();
    }
}

/// <summary>
/// 客户端
/// </summary>
public class Client
{
    public static void Main()
    {
        StrategyBase concreteStrategyA = new ConcreteStrategyA();
        StrategyBase concreteStrategyB = new ConcreteStrategyB();
        StrategyBase concreteStrategyC = new ConcreteStrategyC();

        Context context = new Context(concreteStrategyA);
        context.ExecuteStrategy();

        context.SetStrategy(concreteStrategyB);
        context.ExecuteStrategy();

        context.SetStrategy(concreteStrategyC);
        context.ExecuteStrategy();
    }
}

特点：
优点：

· 算法可以独立于上下文变化，符合开闭原则；

· 可以避免出现大量的if/else语句，提高代码的可维护性；

· 策列之间可以相互切换，灵活性更高；

· 增加新的策略时无需修改上下文，扩展性好；
缺点：

· 类的层次增加，导致系统的复杂度随之增加；

· 客户端必须知道策略类有哪些，在运行时还需要配置策略；

· 若策略的变化频繁，可能会导致管理的复杂度提高；

适用场景：

· 系统有多种算法需要进行相互切换；

· 需要避免上下文写大量的if/else语句；

· 算法需要独立封装并对外进行扩展开放；

举例场景：

· 电商折扣策略；

· 支付方式策略；

· 排序算法策略；