策略（Strategy）模式

/*
* 环境（Context）角色：持有一个Strategy类的引用。
* 抽象策略（Strategy）角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
* 具体策略（ConcreteStrategy）角色：包装了相关的算法或行为。
*/

    /// <summary>
    ///  策略（Strategy）模式
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
        
            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();

            Console.ReadLine();
        }
    }

   // 抽象策略（Strategy）角色
    public abstract class SortStrategy
    {
        abstract public void Sort(ArrayList list);
    }

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

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

    public class MergeSort : SortStrategy
    {
        public override void Sort(ArrayList list)
        {
            //list.MergeSort();
            Console.WriteLine("MergeSorted list ");
        }
    }
    public class SortedList
    {
        // Fields
        private ArrayList list = new ArrayList();
        private SortStrategy sortstrategy;

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

        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);
        }
    }

 可以看出 策略模式的定义 非常类似 简单工厂。

 同样是 实现一个基类  只是他们的  工厂 不一样

 在策略模式中  环境（Context）角色  是根据不同的子类 通过构造函数来实例化， 来判断实现那个 子类函数。

那么看看他们结合起来会有什么效果呢

 
 static void Main(string[] args)
        {  
            //结合 简单工厂
            SortedList sotreContent = new SortedList("1");
            ArrayList list=new ArrayList();
            list.Add("1");

            sotreContent.GetResult(list);

            Console.ReadLine();
        }

/// <summary>
 ///  环境（Context）角色 修改如下
 /// </summary>
public class SortedList
    {
        SortStrategy Strategy = null;
        public SortedList(string type)
        {
            switch (type)
            {
                case "1":
                    QuickSort quickSort = new QuickSort();
                    Strategy = quickSort;
                    break;
                case "2": 
                    break;

            }
        }

        public void GetResult(ArrayList list)
        {
            Strategy.Sort(list); 
        }
  
    }