Strategy 策略（行为型模式）--学习笔记

      问题：算法与对象的耦合 对象可能经常需要使用多种不同的算法，但是如果变化频繁，会将类型变得脆弱…
下面的代码在应对这种变化时将修改原来的代码，我们的原则是 要扩展不要修改

enum CartType
{
    A,
    B,
    C,
}

class Cart
{
    public Point[] GetAlignment(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()
    {
    
    }
}

动机（Motivation）：
在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一个性能负担。
解决思路：在运行时根据需要透明地更改对象的算法，将算法与对象本身解耦，从而避免上述问题。

public interface IProcessStrategy //表达算法抽象
{
    void Process(); //算法抽象
}

public class ProcessStrategyA:IProcessStrategy
{
    void IProcessStrategy.Process()
    {
    //
    }
}

public class ProcessStrategyB:IProcessStrategy
{
    void IProcessStrategy.Process()
    {
    //
    }
}

public class ProcessStrategyC:IProcessStrategy
{
    void IProcessStrategy.Process()
    {
    //
    }
}


class Cart
{
    IProcessStrategy  processStrategy; //对象组合
    public Cart(IProcessStrategy processStrategy)
    {
        this.processStrategy = processStrategy ;        
    }
    public void Somemethod1()
    {
        //
        processStrategy.Process();
    }

    public void Somemethod2()
    {
        //
        processStrategy.Process();
    }
    public void Somemethod3()
    {
        //
        processStrategy.Process();
    }
}


public class app
{
    public static void Main()
    {
        Cart cart = new Cart(new ProcessStrategyC());//动态可配置的算法。
    }
}

//接口更能表达抽象的含义，委托只要求方法的签名一致即可。

结构：

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