策略模式(Strategy Pattern)

算法与对象的耦合：
    对象可能经常需要使用多种不同的算法，但是如果变化频繁，会将类型变得脆弱...
           
动机：
    在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码对象中，将会使对象变得异常复杂;而且有时候支持不使用的算法也是一个性能负担。
    如何在运行时根据需要透明地更改对象的算法？将算法与对象本身解耦，从而避免上述问题？
意图：
    定义一系统的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
                                                                     --------《设计模式》GOF
      
适用性：
    1.许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。
    2.需要使用一个算法的不同变体。例如，你可能会定义一些反映不同的空间/时间权衡的算法。当这些变体实现为一个算法的类层次时[H087]，可以使用策略模式。   
    3.算法使用客户不应该知道数据。可使用策略模式以避免暴露复杂的，与算法相关的数据结构。
    4.一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。
代码实现：
   

1   enum SortType
2     {
3         QuickSort,
4         ShellSort,
5         MergeSort,
6     }

 1     class Sort
 2     {
 3         public void SortList(SortType s)
 4         {
 5             if (s == SortType.QuickSort)
 6             {
 7                 ProcessA();
 8             }
 9             else if (s == SortType.ShellSort)
10             {
11                 ProcessB();
12             }
13             else if (s == SortType.MergeSort)
14             {
15                 ProcessC();
16             }
17             Console.WriteLine();
18         }
19 
20         protected void ProcessA()
21         {
22             Console.WriteLine("QuickSort List");
23         }
24         protected void ProcessB()
25         {
26             Console.WriteLine("ShellSort List");
27         }
28         protected void ProcessC()
29         {
30             Console.WriteLine("MergeSort List");
31         }
32     }

客户端调用：

 1     class Test
 2     {
 3            public static void Main()
 4            {
 5                Sort sort = new Sort();
 6                sort.SortList(SortType.QuickSort);
 7                sort.SortList(SortType.ShellSort);
 8                sort.SortList(SortType.MergeSort);
 9            }
10     }

    由此可见，由于客户端新增调用方式的选择，就会修改SortType及Sort里的判断语句。在类Sort中会增加if语句的判断，用敏捷软件开发的语言说，你应该闻到了代码的臭味道了，也就是设计模式中说的存在了变化的地方。
   重构以上代码，增加一层中间层来处理变化。类结构如下：
                

1    //Stategy  表达抽象算法
2    abstract  class SortStrategy
3     {
4        public abstract void Sort(ArrayList list);
5     }

 1    //ConcreteStrategy
 2     class ShellSort :SortStrategy
 3     {
 4         public override void Sort(System.Collections.ArrayList list)
 5         {
 6                  list.Sort(); //no-implement
 7                 Console.WriteLine("ShellSorted List");
 8             
 9         }
10     }

1   //ConcreteStrategy
2     class MergeSort :SortStrategy
3     {
4         public override void Sort(System.Collections.ArrayList list)
5         {
6             list.Sort(); //no-implement
7             Console.WriteLine("MergeSort List ");
8         }
9     }

1    //ConcreteStrategy
2     class QuickSort :SortStrategy
3     {
4         public override void Sort(System.Collections.ArrayList list)
5         {
6             list.Sort(); //Default is Quicksort
7             Console.WriteLine("QuickSorted List");
8         }
9     }

 1     //Context
 2     class SortdList
 3     {
 4         private ArrayList list = new ArrayList();
 5         private SortStrategy sortstrategy;  //对象组合
 6         public void SetSortStrategy(SortStrategy sortstrategy)
 7         {
 8             this.sortstrategy = sortstrategy;
 9         }
10         public void Add(string name)
11         {
12             list.Add(name);
13         }
14         public void Sort()
15         {
16             sortstrategy.Sort(list);
17             //Display results 
18             foreach (string name in list)
19             {
20                 Console.WriteLine(" " + name);
21             }
22             Console.WriteLine();
23         }
24     }

客户端代码如下：

 1    class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             //Two contexts following different strategies 
 6             SortdList studentRecords = new SortdList();
 7 
 8             studentRecords.Add("Satu");
 9             studentRecords.Add("Jim");
10             studentRecords.Add("Palo");
11             studentRecords.Add("Terry");
12             studentRecords.Add("Annaro");
13 
14             studentRecords.SetSortStrategy(new QuickSort());
15             studentRecords.Sort();
16 
17             studentRecords.SetSortStrategy(new ShellSort());
18             studentRecords.Sort();
19 
20             studentRecords.SetSortStrategy(new MergeSort());
21             studentRecords.Sort();
22 
23             Console.Read();
24         }
25     }

由此可见，更好地满足开放封闭原则。
Strategy模式的几个要点：
    1.Strategy及其子类为组件提供了一系列可重用的算法，从而可以使得类型在运行时方便地根据需要在各个算法之间进行切换。所谓封装算法，支持算法的变化。
    2.Strategy模式提供了用条件判断语句以外的另一种选择，消除条件判断语句，就是在解耦合。含有许多条件判断语句的代码通常都需要Strategy模式。
    3.与State类似，如果Strategy对象没有实例变量，那么各个上下文可以共享同一个Strategy对象，从而节省对象开销。