38、面向对象设计模式之策略模式（Strategy)

算法与对象的耦合：

　　对象可能经常需要使用多种不同的算法，但如果变化频繁，会将类型变得脆弱...

动机（Motivation)

　　在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担。

　　如何在运行时根据需要透明地更改对象的算法？将算法与对象本身解耦，从而避免上述问题？

意图（Intent）

　　定义系列算法，把他们一个个封装起来，并且使他们可相互替换。该模式使得算法独立于使用它的客户而变化。——《设计模式》GoF

下面的例子是对象中有三种算法：

using System;
using System.Drawing;
using System.Security.Authentication.ExtendedProtection;

namespace 策略模式
{
  public  enum CartType
    {
        A,
        B,
        C
    }
    public class Cart
    {

        /*
         * 两个变化点
         * 1、枚举类型
         * 2、ProcessA，ProcessB...也是变化点
         */
        public void SomeMethod(CartType cartType)
        {
            if(cartType == CartType.A)
            {
                ProcessA();
            }else if(cartType == CartType.B)
            {
                ProcessB();
            }else if(cartType == CartType.C)
            {
                ProcessC();
            }
        }

        protected virtual void ProcessA()
        {

        }
        protected virtual void ProcessB()
        {

        }
        protected virtual void ProcessC()
        {

        }
    }
}

上面的例子有两个变化点一个是枚举的增加，一个是算法的更改，而且三个算法一次只用了一种，为了消除这两个变化点我们利用策略模式将封装算法，动态调用算法。

using System;
using System.Drawing;
using System.Security.Authentication.ExtendedProtection;

namespace 策略模式
{
    public interface IProcessStrategy//表达了一种算法抽象
    {
        public void Process();
    }
    
    public class ProcessStrategyA : IProcessStrategy //具体的算法
    {
        public void Process()
        {

        }
    }
    public class ProcessStrategyB : IProcessStrategy //具体的算法
    {
        public void Process()
        {

        }
    }
    public class ProcessStrategyC : IProcessStrategy //具体的算法
    {
        public void Process()
        {

        }
    }
    public class Cart2
    {

        IProcessStrategy processStrategy;//对象组合(间接)

        public Cart2(IProcessStrategy processStrategy)
        {
            this.processStrategy = processStrategy; ;
        }
        public void Somemethod()
        {
            processStrategy.Process();
        }
    }
 
    public class App
    {
        static void Main(string[] args)
        {
            Cart2 cart = new Cart2(new ProcessStrategyC());//
            cart.Somemethod();
        }
    }
}

结构（Structure)

 

 Strategy（策略模式）的几个要点

　　Strategy及其子类为组件提供了一系列可重用的算法，从而可以使得类型在运行时方便地根据需要在各个算法之间进行切换。所谓封装算法，支持算法的变化。

　　Strategy模式提供了用条件判断语句以外的另一种选择，消除条件判断语句，就是在解耦合。含有许多条件判断语句的代码通常都需要Stategy

　　与State类似，如果Strategy对象没有实例变量，那么各个上下文可以共享同一个Strategy对象，从而节省对象开销。