策略模式之C#版本（原创翻译版本）_algorithminterface 翻译-优快云博客

博客涉及C#相关内容，包含UML类图以及参与者等信息，与信息技术领域的编程和设计相关。

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

Definition

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

UML class diagram

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.

Sample code in C#

download C# source code zip file

This structural code demonstrates the Strategy pattern which encapsulates functionality in the form of an object. This allows clients to dynamically change algorithmic strategies.

// Strategy pattern -- Structural example

using System;


// "Strategy"


abstract class Strategy

{
// Methods
abstract public void AlgorithmInterface();
}


// "ConcreteStrategyA"


class ConcreteStrategyA : Strategy

{
// Methods
override public void AlgorithmInterface()
{
Console.WriteLine(
"Called ConcreteStrategyA.AlgorithmInterface()");
}
}


// "ConcreteStrategyB"


class ConcreteStrategyB : Strategy

{
// Methods
override public void AlgorithmInterface()
{
Console.WriteLine(
"Called ConcreteStrategyB.AlgorithmInterface()");
}
}


// "ConcreteStrategyC"


class ConcreteStrategyC : Strategy

{
// Methods
override public void AlgorithmInterface()
{
Console.WriteLine(
"Called ConcreteStrategyC.AlgorithmInterface()");
}
}


// "Context"


class Context

{
// Fields
Strategy strategy;

// Constructors
public Context( Strategy strategy )
{
this.strategy = strategy;
}

// Methods
public void ContextInterface()
{
strategy.AlgorithmInterface();
}
}


/// <summary>

/// Client test
/// </summary>
public class Client
{
public static void Main( string[] args )
{
    // Three contexts following different strategies
    Context c = new Context( new ConcreteStrategyA() );
    c.ContextInterface();


    Context d = new Context( new ConcreteStrategyB() );

d.ContextInterface();


    Context e = new Context( new ConcreteStrategyC() );

e.ContextInterface();
}
}

Output

Called ConcreteStrategyA.AlgorithmInterface()
Called ConcreteStrategyB.AlgorithmInterface()
Called ConcreteStrategyC.AlgorithmInterface()

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;


// "Strategy"


abstract class SortStrategy

{
// Methods
abstract public void Sort( ArrayList list );
}


// "ConcreteStrategy"


class QuickSort : SortStrategy

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


// "ConcreteStrategy"


class ShellSort : SortStrategy

{
// Methods
public override void Sort(ArrayList list )
{
//list.ShellSort();
Console.WriteLine("ShellSorted list ");
}
}


// "ConcreteStrategy"


class MergeSort : SortStrategy

{
// Methods
public override void Sort( ArrayList list )
{
//list.MergeSort();
Console.WriteLine("MergeSorted list ");
}
}


// "Context"


class SortedList

{
// Fields
private ArrayList list = new ArrayList();
private SortStrategy sortstrategy;

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

// Methods
public void Sort()
{
sortstrategy.Sort( list );
}


  public void Add( string name )

{
list.Add( name );
}


  public void Display()

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


/// <summary>

/// StrategyApp test
/// </summary>
public class StrategyApp
{
public static void Main( string[] args )
{
    // Two contexts following different strategies
    SortedList studentRecords = new SortedList( );
    studentRecords.Add( "Samual" );
    studentRecords.Add( "Jimmy" );
    studentRecords.Add( "Sandra" );
    studentRecords.Add( "Anna" );
    studentRecords.Add( "Vivek" );


    studentRecords.SetSortStrategy( new QuickSort() );

studentRecords.Sort();
studentRecords.Display();
}
}

Output

QuickSorted list
 Anna
 Jimmy
 Samual
 Sandra
 Vivek