概述

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。策略模式使得算法可以独立于使用它的客户端而变化。通过使用策略模式，可以在运行时选择不同的算法，从而提高系统的灵活性和可维护性。

结构

策略模式包含以下几个角色：

1. 策略（Strategy）：定义所有支持的算法的公共接口。
2. 具体策略（ConcreteStrategy）：实现策略接口的具体算法。
3. 上下文（Context）：维护一个策略对象的引用，并在需要时调用策略对象的方法。

示例代码

假设我们有一个应用程序需要对一组数字进行排序，可以选择不同的排序算法（如冒泡排序和快速排序）。
代码地址

策略接口

public interface ISortStrategy
{
    void Sort(List<int> list);
}

具体策略

public class BubbleSortStrategy : ISortStrategy
{
    public void Sort(List<int> list)
    {
        Console.WriteLine("Using Bubble Sort");
        for (int i = 0; i < list.Count - 1; i++)
        {
            for (int j = 0; j < list.Count - i - 1; j++)
            {
                if (list[j] > list[j + 1])
                {
                    (list[j], list[j + 1]) = (list[j + 1], list[j]);
                }
            }
        }
    }
}

public class QuickSortStrategy : ISortStrategy
{
    public void Sort(List<int> list)
    {
        Console.WriteLine("Using Quick Sort");
        QuickSort(list, 0, list.Count - 1);
    }

    private static void QuickSort(IList<int> list, int left, int right)
    {
        while (true)
        {
            if (left >= right)
            { 
                return;
            }

            int pivot = Partition(list, left, right);

            QuickSort(list, left, pivot - 1);

            left = pivot + 1;
        }
    }

    private static int Partition(IList<int> list, int left, int right)
    {
        int pivot = list[right];
        int i = left - 1;

        for (int j = left; j < right; j++)
        {
            if (list[j] >= pivot)
            {
                continue;
            }

            i++;

            (list[i], list[j]) = (list[j], list[i]);
        }

        (list[i + 1], list[right]) = (list[right], list[i + 1]);

        return i + 1;
    }
}

上下文

public class SortContext
{
    private ISortStrategy _sortStrategy;

    public void SetSortStrategy(ISortStrategy sortStrategy)
    {
        _sortStrategy = sortStrategy;
    }

    public void Sort(List<int> list)
    {
        _sortStrategy.Sort(list);
    }
}

客户端代码

class Program
{
    static void Main(string[] args)
    {
        List<int> list = new List<int> { 5, 2, 9, 1, 5, 6 };

        SortContext context = new SortContext();

        context.SetSortStrategy(new BubbleSortStrategy());
        context.Sort(list);
        Console.WriteLine(string.Join(", ", list));

        list = new List<int> { 5, 2, 9, 1, 5, 6 };

        context.SetSortStrategy(new QuickSortStrategy());
        context.Sort(list);
        Console.WriteLine(string.Join(", ", list));
    }
}

应用场景

策略模式适用于以下场景：

1. 需要使用多种算法：当一个系统需要在多种算法中选择一种时，可以使用策略模式。
2. 算法独立变化：当算法的实现需要独立于使用它的客户端变化时，可以使用策略模式。
3. 消除条件语句：当一个系统中包含大量的条件语句来选择合适的算法时，可以使用策略模式将这些条件语句替换为算法的封装。

优缺点

优点

• 算法可以独立变化：策略模式使得算法可以独立于使用它的客户端变化，提高了系统的灵活性和可维护性。
• 消除条件语句：策略模式通过将算法封装到独立的策略类中，消除了系统中的条件语句。

缺点

• 增加类的数量：策略模式引入了大量的策略类，可能会增加系统的复杂性。
• 客户端必须了解不同的策略：策略模式要求客户端了解不同的策略类，并自行选择合适的策略。