Strategy (***) (medium high)-优快云博客

本文介绍策略模式的应用，通过一个学生名单排序的例子展示了如何利用策略模式动态地改变算法。该模式通过定义一系列算法，并将每个算法封装起来，使它们可以互相替换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Strategy: Encapsulates an algorithm inside a class

Strategy模式和 Template模式要解决的问题是相同（类似）的，都是为了给业务逻辑（算

法）具体实现和抽象接口之间的解耦。Strategy模式将逻辑（算法）封装到一个类（Context）

里面，通过组合的方式将具体算法的实现在组合对象中实现，再通过委托的方式将抽象接口

的实现委托给组合对象实现。State模式也有类似的功能，他们之间的区别将在讨论中给出。

participants

The classes and/or objects participating in this pattern are:

Strategy (SortStrategy)
- declares an interface common to all supported algorithms. Context uses this interface to call the algorithm defined by a ConcreteStrategy
ConcreteStrategy (QuickSort, ShellSort, MergeSort)
- implements the algorithm using the Strategy interface
Context (SortedList)
- is configured with a ConcreteStrategy object
- maintains a reference to a Strategy object
- may define an interface that lets Strategy access its data.

This real-world code demonstrates the Strategy pattern which encapsulates sorting algorithms in the form of sorting objects. This allows clients to dynamically change sorting strategies including Quicksort, Shellsort, and Mergesort.

// Strategy pattern -- Real World example

using System;
using System.Collections;

namespace DoFactory.GangOfFour.Strategy.RealWorld
{

  // MainApp test application

  class MainApp
  {
    static void Main()
    {
      // Two contexts following different strategies
      SortedList studentRecords = new SortedList();

      studentRecords.Add("Samual");
      studentRecords.Add("Jimmy");
      studentRecords.Add("Sandra");
      studentRecords.Add("Vivek");
      studentRecords.Add("Anna");

      studentRecords.SetSortStrategy(new QuickSort());
      studentRecords.Sort();

      studentRecords.SetSortStrategy(new ShellSort());
      studentRecords.Sort();

      studentRecords.SetSortStrategy(new MergeSort());
      studentRecords.Sort();

      // Wait for user
      Console.Read();
    }
  }

  // "Strategy"

  abstract class SortStrategy
  {
    public abstract void Sort(ArrayList list);
  }

  // "ConcreteStrategy"

  class QuickSort : SortStrategy
  {
    public override void Sort(ArrayList list)
    {
      list.Sort(); // Default is Quicksort
      Console.WriteLine("QuickSorted list ");
    }
  }

  // "ConcreteStrategy"

  class ShellSort : SortStrategy
  {
    public override void Sort(ArrayList list)
    {
      //list.ShellSort(); not-implemented
      Console.WriteLine("ShellSorted list ");
    }
  }

  // "ConcreteStrategy"

  class MergeSort : SortStrategy
  {
    public override void Sort(ArrayList list)
    {
      //list.MergeSort(); not-implemented
      Console.WriteLine("MergeSorted list ");
    }
  }

  // "Context"

  class SortedList
  {
    private ArrayList list = new ArrayList();
    private SortStrategy sortstrategy;

    public void SetSortStrategy(SortStrategy sortstrategy)
    {
      this.sortstrategy = sortstrategy;
    }

    public void Add(string name)
    {
      list.Add(name);
    }

    public void Sort()
    {
      sortstrategy.Sort(list);

      // Display results
      foreach (string name in list)
      {
        Console.WriteLine(" " + name);
      }
      Console.WriteLine();
    }
  }
}

Output