【设计模式】之 Strategy 模式

Motivation

在软件的构建当中，某些对象使用的算法可能多种多样，并且需要经常改变，如果将这些算法都硬编码到对象中，将会使对象变得异常复杂，而且有时支持不使用的算法也是一种性能负担。
如何在运行的时候根据需要透明的更改对象的算法，将算法与对象本身解耦，从而避免这样的问题。

Intent

定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。该模式使得算法可独立于使用它的客户而变化。
策略模式相当于"可插入式（Pluggable）的算法"。允许客户端动态决定现在用什么算法。

Structure

把行为和环境分割开来。环境类负责维持和查询行为类，各种算法则在具体策略类（ConcreteStrategy）中提供，作为一个抽象策略类的子类。由于算法和环境独立开来，算法的增减、修改都不会影响环境和客户端。当出现新的算法出现时，只需要实现新的策略类，并在客户端登记即可。

环境（Context）角色：持有一个算法策略Strategy类的引用 和 contextInterface()方法，方法内调用算法策略接口。
可以在构造函数中或者写一个SetStrategy函数(如下实例)，给context类的Strategy成员赋值（即客户端决定实例化那个ConcreteStrategy，用哪种算法）
contextInterface()例如下面的 public void Sort(){  //调用算法策略接口 sortstrategy.Sort(list);//...}

抽象策略（Strategy）角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
declares an interface common to all supported algorithms. Context uses this interface to call the algorithm defined by a ConcreteStrategy

具体策略（ConcreteStrategy）角色：包装了相关的算法或行为。

strategy structure
namespace 策略模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Context context;

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

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

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

            Console.Read();
        }
    }

    //抽象算法类
    abstract class Strategy
    {
        //算法方法
        public abstract void AlgorithmInterface();
    }
    //具体算法A
    class ConcreteStrategyA : Strategy
    {
        //算法A实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法A实现");
        }
    }
    //具体算法B
    class ConcreteStrategyB : Strategy
    {
        //算法B实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法B实现");
        }
    }
    //具体算法C
    class ConcreteStrategyC : Strategy
    {
        //算法C实现方法
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法C实现");
        }
    }
    //上下文
    class Context
    {
        Strategy strategy;

        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }
        //上下文接口
        public void ContextInterface()
        {
            strategy.AlgorithmInterface();
        }
    }

}

 

实例
This sample 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  (SortStrategy)

ConcreteStrategy  (QuickSort, ShellSort, MergeSort)

implements the algorithm using the Strategy interface

Context  (SortedList)
1. is configured with a ConcreteStrategy object

2. maintains a reference to a Strategy object
3. may define an interface that lets Strategy access its data.

排序算法 策略模式
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();
    }
  }
}

 

.NET中的策略模式

ArrayList的排序
ArrayList.Sort() 对于自定义的特殊对象，非字符串序列，要传入实现了ICompare的对象作为参数

.NET中策略模式
class Program
    {
        static void Main(string[] args)
        {

            ArrayList points = new ArrayList();

            points.Add(new Point(12, 35));
            points.Add(new Point(32, 5));
            points.Add(new Point(2,6));

            points.Sort(new PointCompareByX());
            foreach (Point item in points)
            {
                Console.WriteLine(item.X.ToString() + " "+  item.Y.ToString());
            }

            points.Sort(new PointCompareByY());
            foreach (Point item in points)
            {
                Console.WriteLine(item.X.ToString() + " " + item.Y.ToString());
            }

            Console.Read();
        }
    }


//Point类
    public class Point
    {
        private int x, y;
        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }

        public int X
        {
            get
            {
                return this.x;
            }
        }

        public int Y
        {
            get
            {
                return this.y;
            }
        }
    }

//排序算法1，按X坐标排列点阵
    public class PointCompareByX : IComparer
    {

        #region IComparer Members
        
        int IComparer.Compare(object x, object y)
        {
            int a = 0, b = 0;
            a = ((Point)x).X;
            b = ((Point)y).X;

            return (a == b) ? 0 : ((a < b) ? -1 : 1);
        }

        #endregion
    }

//排序算法2，按Y坐标排列点阵
    public class PointCompareByY : IComparer
    {

        #region IComparer Members

        public int Compare(object x, object y)
        {
            int a = 0, b = 0;
            a = ((Point)x).Y;
            b = ((Point)y).Y;

            return (a == b) ? 0 : ((a < b) ? -1 : 1);
        }

        #endregion
    }

 

反射实现动态可配置算法（对《大话》例子的思考）

思考：简单工厂模式实现的商场收银系统有什么劣势呢？

根据用户在ComboBox的选择，用工厂创建相应的算法对象，然后使用。看起来很好的方案。

//利用简单工厂模式根据下拉选择框，生成相应的对象
CashSuper csuper = CashFactory.createCashAccept(cbxType.SelectedItem.ToString());
double totalPrices = 0d;
//通过多态，可以得到收取费用的结果
"实收" = csuper.acceptCash(“应收");

可以看出因为工厂模式是创建型的，所以一定要创建出算法对象，程序要持有这个对象，调用对象内的算法，才能实现功能。
我们知道，每个模式都是适用一定的场合的，在这个场合中，因为剧烈变化的是算法，试想，如果算法里包括了积分计算，因为积分政策的变化，所以我们需要改算法。因此就需要重新编译我们的工厂类，重新给客户部署。似乎有些不太方便。

而策略模式正是解决这种问题的，将算法一个个封装起来，并且使它们可以相互替换。
但是简单的策略模式，客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，简单策略模式只适用于客户端知道所有的算法或行为的情况。
而没有反射，因为你要Hardcode，就利用不了算法相互替换的功能。

技巧一：使用XML文件或者数据库将算法名称和comboBox绑定

算法配置XML文件
<?xml version="1.0" encoding="utf-8" ?>
<CashAcceptType>
    <type>
        <name>正常收费</name>
        <class>CashNormal</class>
        <para></para>
    </type>
    <type>
        <name>满300返100</name>
        <class>CashReturn</class>
        <para>300,100</para>
    </type>
    <type>
        <name>满200返50</name>
        <class>CashReturn</class>
        <para>200,50</para>
    </type>
    <type>
        <name>打8折</name>
        <class>CashRebate</class>
        <para>0.8</para>
    </type>
</CashAcceptType>

 

利用程序读取这个配置文件，实现和Combobox的绑定

读取XML内信息，将算法名称和ComboBox绑定
DataSet ds;//用于存放配置文件信息

         private void Form1_Load(object sender, EventArgs e)
        {
            //读配置文件
              ds = new DataSet();
            ds.ReadXml(Application.StartupPath + "\\CashAcceptType.xml");
            
            //将读取到的记录绑定到下拉列表框中
              foreach (DataRowView dr in ds.Tables[0].DefaultView)
            {
                cbxType.Items.Add(dr["name"].ToString());
            }
            cbxType.SelectedIndex = 0;
        }

 

技巧二： 反射实现动态创建

(基类)Assembly.Load("程序集名称").CreateInstance("名称空间.子类名称")

反射
          //策略模式 context对象
          CashContext cc = new CashContext();
           //根据用户的选项，查询用户选择项的相关行
            DataRow dr = ((DataRow[])ds.Tables[0].Select("name='" + cbxType.SelectedItem.ToString()+"'"))[0];
            //声明一个参数的对象数组
            object[] args =null;
            //若有参数，则将其分割成字符串数组，用于实例化时所用的参数
            if (dr["para"].ToString() != "")
                args = dr["para"].ToString().Split(',');
            //通过反射实例化出相应的算法对象
            cc.setBehavior((CashSuper)Assembly.Load("商场管理软件").CreateInstance("商场管理软件." + dr["class"].ToString(), false, BindingFlags.Default, null, args, null, null));
            
            double totalPrices = 0d;
            totalPrices = cc.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));