行为型模式--策略模式

策略模式

策略模式是一种行为设计模式，它允许在运行时选择算法的行为。该模式定义了一系列算法，将每

个算法封装在独立的类中，并使它们可以互相替换。通过将算法从上下文中分离出来，策略模式使

得算法可以独立于客户端而变化。

组成模块

1、上下文（Context）：它包含一个对策略对象的引用，并且可以根据需要调用策略对象的算法。

上下文可以接受客户端传入的不同策略对象，并在运行时根据选择的策略执行相应的算法。

2、抽象策略类（Strategy）：它是一个接口或抽象类，定义了一系列算法的公共接口。

3、具体策略类（ConcreteStrategy）：它是策略接口的具体实现。每个具体策略类实现了策略接

口定义的算法

Demo

1、上下文

//工资上下文
public class Salary
{
    private ICalculateSalary _calculateSalary;
    public Salary(ICalculateSalary calculateSalary)
    {
        _calculateSalary = calculateSalary;
    }
    
    //执行不同策略
    public void ShowSalary(double basicSalary)
    {
        _calculateSalary.CalculateSalary(basicSalary);
    }
}

2、定义抽象策略类

//计算工资抽象类
public interface ICalculateSalary
{
    void CalculateSalary(double salary);
}

3、具体实现

//普通员工
public class OrdinaryWorker : ICalculateSalary
{
    public void CalculateSalary(double salary)
    {
        Console.WriteLine($"普通职工工资构成：基本工资:{salary},提成百分比:5%,最后工资:{salary + salary * 0.05 }");
    }
}

//产品经理
public class ProductManager : ICalculateSalary
{
    public void CalculateSalary(double salary)
    {
        Console.WriteLine($"产品经理工资构成：基本工资:{salary},提成百分比:15%,最后工资:{salary + salary * 0.15 }");
    }
}

//总经理
public class GeneralManager : ICalculateSalary
{
    public void CalculateSalary(double salary)
    {
        Console.WriteLine($"总经理工资构成：基本工资:{salary},提成百分比:45%,最后工资:{salary + salary * 0.45 }");
    }
}

4、客户端调用

//在实际工作中，可以动态判断员工所在的职位，从而选择不同策略
Salary salary = new Salary(new OrdinaryWorker());
salary.ShowSalary(10000);

优点

1、灵活性和可扩展性：可以轻松地添加新的算法或修改现有的算法，而无需修改客户端代码。

2、符合开闭原则：对扩展开放、对修改关闭。可以通过添加新的策略类来扩展系统功能，而无需

修改原有代码。

缺点

1、客户端必须知道所有的策略类：客户端需要了解所有可用的策略，并选择合适的策略来使用，

可能会增加客户端的复杂性。

2、增加了类的数量：每个策略都需要一个单独的类，可能会导致类的数量增加，使代码变得复

杂。

适用场景

1、需要动态切换算法：比如在支付场景中，用户可以自行选择支付方式。

2、避免使用条件语句：当在代码中出现大量的条件语句，每个条件语句执行不同的操作时，可以

考虑使用策略模式。策略模式将每个条件分支封装在独立的策略类中，使得代码更清晰、易于维

护。

实际运用

在.NET内置的Log日志中，就运用了类似策略模式，在记录日志中可以自行选择日志的级别。

在.NET5以上的版本中，有很高的扩展性，可以自定义日志级别。下面是简陋版的Log日志。

//Log上下文
public class LoggerContext
{
    private readonly ILoggerStrategy _loggerStrategy;

    public LoggerContext(LogLevel logLevel)
    {
        switch (logLevel)
        {
            case LogLevel.Debug:
                _loggerStrategy = new DebugLogger();
                break;
            case LogLevel.Info:
                _loggerStrategy = new InfoLogger();
                break;
            case LogLevel.Error:
                _loggerStrategy = new ErrorLogger();
                break;
            default:
                throw new ArgumentException("Invalid log level.");
        }
    }

    public void Log(string message)
    {
        _loggerStrategy.Log(message);
    }
}

public enum LogLevel
{
    Debug,
    Info,
    Error
}


//记录日志接口
public interface ILoggerStrategy
{
    void Log(string message);
}

//具体实现
public class DebugLogger : ILoggerStrategy
{
    public void Log(string message)
    {
        Console.WriteLine($"控制台输出 {message}");
    }
}

public class InfoLogger : ILoggerStrategy
{
    public void Log(string message)
    {
        Console.WriteLine($"记录txt文件 {message}");
    }
}

public class ErrorLogger : ILoggerStrategy
{
    public void Log(string message)
    {
        Console.WriteLine($"记录数据库 {message}");
    }
}

//调用
LoggerContext loggerContext = new LoggerContext(LogLevel.Debug);
loggerContext.Log("This is a debug message.");

总结

策略模式中说的算法，并不局限于数学或计算机科学中的算法。在策略模式中，“算法”可以是任何

一种行为、策略或规则，只要它们可以在运行时动态地选择和应用。

希望大家不被字面意思困扰。