C#实现策略模式

下面是关于" C#实现策略模式" 的详细讲解：

策略模式

策略模式是一种行为设计模式，它使您能够定义一系列算法，将它们封装在各自的类中，然后使它们可以相互替换。策略使算法独立于使用它的客户端，因此可以单独更改。

实现步骤

根据策略模式的思路，我们可以把一个算法分成两个部分，一部分是公共接口，用于申明所有算法的行为，另一部分是具体实现策略。具体实现算法的部分统一实现一个公共接口。

1. 定义接口

我们先定义一个接口，用于实现所有算法的公共行为：

public interface ITaxCalculator
{
    decimal Calculate(decimal salary);
}

2. 实现策略

实现对应算法的类，实现上面的接口：

public class USATaxCalculator : ITaxCalculator
{
    public decimal Calculate(decimal salary)
    {
        return salary * 0.3m;
    }
}

public class ChinaTaxCalculator : ITaxCalculator
{
    public decimal Calculate(decimal salary)
    {
        return salary * 0.1m;
    }
}

3. 使用策略

使用时，我们可以根据不同的具体算法，实例化对应的策略，并使用其公共行为：

public class Program
{
    static void Main(string[] args)
    {
        var salary = 5000m;
        ITaxCalculator calculator = new ChinaTaxCalculator();
        var tax = calculator.Calculate(salary);
        Console.WriteLine($"The tax in China is {tax}.");

        calculator = new USATaxCalculator();
        tax = calculator.Calculate(salary);
        Console.WriteLine($"The tax in USA is {tax}.");
    }
}

运行上面的程序，输出：

The tax in China is 500.
The tax in USA  is 1500.

示例1

对于计算器程序，针对不同的计算方式，可以采用策略模式，比如上面我们实现的美国和中国的TaxCalculator，我们可以在计算器程序中提供不同的策略，让用户自行选择不同的计算税率方法。

如果代码采用策略模式，遵循“开放-封闭” 原则，支持添加新的策略而无需影响现有代码，保证了代码的可维护性。

示例2

考虑一个依赖一些实现了一个抽象评估器的工作流。现在需要在不同的评估器之间切换。可以通过使用策略模式来完成此操作：

public class Workflow
{
    private readonly IEvaluator _evaluator;

    public Workflow(IEvaluator evaluator)
    {
        _evaluator = evaluator;
    }

    public void Process()
    {
        Console.WriteLine("Start processing...");
        var result = _evaluator.Evaluate();
        Console.WriteLine($"Result = {result}");
        Console.WriteLine("Finish processing.");
    }
}

public interface IEvaluator
{
    int Evaluate();
}

public class AddEvaluator : IEvaluator
{
    private readonly int _x;
    private readonly int _y;

    public AddEvaluator(int x, int y)
    {
        _x = x;
        _y = y;
    }

    public int Evaluate()
    {
        Console.WriteLine($"Calculating {_x} + {_y}");
        return _x + _y;
    }
}

public class MultiplyEvaluator : IEvaluator
{
    private readonly int _x;
    private readonly int _y;

    public MultiplyEvaluator(int x, int y)
    {
        _x = x;
        _y = y;
    }

    public int Evaluate()
    {
        Console.WriteLine($"Calculating {_x} * {_y}");
        return _x * _y;
    }
}

现在，可以像这样调用“Workflow”类：

var add = new AddEvaluator(1, 2);
var multiply = new MultiplyEvaluator(3, 4);

var workflow = new Workflow(add);
workflow.Process();

workflow = new Workflow(multiply);
workflow.Process();

运行结果如下：

Start processing...
Calculating 1 + 2
Result = 3
Finish processing.
Start processing...
Calculating 3 * 4
Result = 12
Finish processing.

这样，我们就通过策略模式实现了一系列算法，并将它们封装在各自的类中，使它们可以相互替换，同时也使算法独立于使用它的客户端，因此可以方便地添加，修改和维护不同的算法。