Design Pattern - Strategy（C ）

Definition

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

When To Use

The strategy design pattern is used to encapsulate changes and allows you to easily swap in and out alternative implementations, even at runtime. This makes it a great tool for benchmarking algorithms, responding to volatile requirements and quickly trying out new ideas.

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#

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

namespace CSharpLearning
{
    using System;

    /// <summary>
    /// Startup class for Structural Strategy Design Pattern.
    /// </summary>
    public class MainApp
    {
        /// <summary>
        /// Entry point into console application.
        /// </summary>
        public static void Main()
        {
            Context context;

            // Three contexts following different strategies.
            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyC());
            context.ContextInterface();

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

    /// <summary>
    /// The 'Strategy' abstract class.
    /// </summary>
    public abstract class Strategy
    {
        /// <summary>
        /// The algorithm interface.
        /// </summary>
        public abstract void AlgorithmInterface();
    }

    /// <summary>
    /// A 'ConcreteStrategy' class.
    /// </summary>
    public class ConcreteStrategyA : Strategy
    {
        /// <summary>
        /// The algorithm interface.
        /// </summary>
        public override void AlgorithmInterface()
        {
            Console.WriteLine("Called ConcreteStrategyA.AlgorithmInterface()");
        }
    }

    /// <summary>
    /// A 'ConcreteStrategy' class.
    /// </summary>
    public class ConcreteStrategyB : Strategy
    {
        /// <summary>
        /// The algorithm interface.
        /// </summary>
        public override void AlgorithmInterface()
        {
            Console.WriteLine("Called ConcreteStrategyB.AlgorithmInterface()");
        }
    }

    /// <summary>
    /// A 'ConcreteStrategy' class.
    /// </summary>
    public class ConcreteStrategyC : Strategy
    {
        /// <summary>
        /// The algorithm interface.
        /// </summary>
        public override void AlgorithmInterface()
        {
            Console.WriteLine("Called ConcreteStrategyC.AlgorithmInterface()");
        }
    }

    /// <summary>
    /// The 'Context' class.
    /// </summary>
    public class Context
    {
        /// <summary>
        /// The strategy.
        /// </summary>
        private Strategy strategy;

        /// <summary>
        /// Initializes a new instance of the <see cref="Context"/> class.
        /// </summary>
        /// <param name="strategy">
        /// The strategy.
        /// </param>
        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }

        /// <summary>
        /// The context interface.
        /// </summary>
        public void ContextInterface()
        {
            this.strategy.AlgorithmInterface();
        }
    }
}

// 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

namespace CSharpLearning
{
    using System;
    using System.Collections.Generic;

    /// <summary>
    /// Startup class for Real-World Strategy Design Pattern.
    /// </summary>
    public class MainApp
    {
        /// <summary>
        /// Entry point into console application.
        /// </summary>
        public static void Main()
        {
            // Context 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.ReadKey();
        }
    }

    /// <summary>
    /// The 'Strategy' abstract class.
    /// </summary>
    public abstract class SortStrategy
    {
        /// <summary>
        /// The sort.
        /// </summary>
        /// <param name="list">
        /// The list.
        /// </param>
        public abstract void Sort(List<string> list);
    }

    /// <summary>
    /// A 'ConcreteStrategy' class.
    /// </summary>
    public class QuickSort : SortStrategy
    {
        /// <summary>
        /// The sort.
        /// </summary>
        /// <param name="list">
        /// The list.
        /// </param>
        public override void Sort(List<string> list)
        {
            list.Sort(); // Default is QuickSort.
            Console.WriteLine("QuickSorted list:");
        }
    }

    /// <summary>
    /// A 'ConcreteStrategy' class.
    /// </summary>
    public class ShellSort : SortStrategy
    {
        /// <summary>
        /// The sort.
        /// </summary>
        /// <param name="list">
        /// The list.
        /// </param>
        public override void Sort(List<string> list)
        {
            // list.ShellSort(); not-implemented.
            Console.WriteLine("ShellSorted list:");
        }
    }

    /// <summary>
    /// A 'ConcreteStrategy' class.
    /// </summary>
    public class MergeSort : SortStrategy
    {
        /// <summary>
        /// The sort.
        /// </summary>
        /// <param name="list">
        /// The list.
        /// </param>
        public override void Sort(List<string> list)
        {
            // list.MergeSort(); not-implemented.
            Console.WriteLine("MergeSorted list:");
        }
    }

    /// <summary>
    /// The 'Context' class.
    /// </summary>
    public class SortedList
    {
        /// <summary>
        /// The list.
        /// </summary>
        private List<string> list = new List<string>();

        /// <summary>
        /// The sort strategy.
        /// </summary>
        private SortStrategy sortStrategy;

        /// <summary>
        /// The set sort strategy.
        /// </summary>
        /// <param name="sortStrategy">
        /// The sort strategy.
        /// </param>
        public void SetSortStrategy(SortStrategy sortStrategy)
        {
            this.sortStrategy = sortStrategy;
        }

        /// <summary>
        /// The add.
        /// </summary>
        /// <param name="name">
        /// The name.
        /// </param>
        public void Add(string name)
        {
            this.list.Add(name);
        }

        /// <summary>
        /// The sort.
        /// </summary>
        public void Sort()
        {
            this.sortStrategy.Sort(this.list);

            // Iterate over list and display results.
            foreach (string name in this.list)
            {
                Console.WriteLine(" " + name);
            }

            Console.WriteLine();
        }
    }
}

// Output:
/*
QuickSorted list:
Anna
Jimmy
Samual
Sandra
Vivek

ShellSorted list:
Anna
Jimmy
Samual
Sandra
Vivek

MergeSorted list:
Anna
Jimmy
Samual
Sandra
Vivek
*/

再分享一下我老师大神的人工智能教程吧。零基础！通俗易懂！风趣幽默！希望你也加入到我们人工智能的队伍中来！http://www.captainbed.net