策略模式

         策略模式：它定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户；

         接着上面可乐的话题说下去吧，现在小乙开了个冷饮店，可以选择三种可乐，在最初阶段，他不熟悉经常来得客户的口味，所以每次客户来都得先说需要什么可乐，小乙然后将可乐送出，下面看看这个过程的实现代码：

	/// <summary>
    /// 可乐基类
    /// </summary>
    public class Cola
    {
        public virtual string KeLe()
        {
            return "I'm KeLe";
        }
    }

    /// <summary>
    /// 可乐工厂类
    /// </summary>
    public static class ColaFactroy
    {
        public static Cola GetCola(string custem)
        {
            switch (custem)
            {
                case "A":
                    return new BaiShi();
                case "B":
                    return new KeKou();
                default:
                    return new FeiChang();
            }
        }
    }

    /// <summary>
    /// 可口可乐
    /// </summary>
    public class KeKou : Cola
    {
        public override string KeLe()
        {
            return "I'm KeKouKeLe";
        }
    }

    /// <summary>
    /// 可口可乐
    /// </summary>
    public class BaiShi : Cola
    {
        public override string KeLe()
        {
            return "I'm BaiShiKeLe";
        }
    }

    /// <summary>
    /// 非常可乐
    /// </summary>
    public class FeiChang : Cola
    {
        public override string KeLe()
        {
            return "I'm FeiChangKeLe";
        }
    }
小乙卖可乐的实现如下：
1.	A顾客前来买可乐：
Cola cola = ColaFactroy.GetCola("A");
cola.KeLe();
2.	B顾客前来买可乐：
Cola cola = ColaFactroy.GetCola("B");
cola.KeLe();

         通过上面的代码可以看到，其实上面就是一个简单的工厂模式，小乙让用户直接对可乐工厂输入自己的爱好，可乐工厂将可乐做好后送出来；过了一阵子，顾客不高兴了，为什么？每次来买可都是对着可乐工厂说话，没看到老板小乙，顾客当然不高兴了，小乙想：通过什么样的策略来满足客户的需求呢？

         实际最好的情况应该是：小乙看到A或B客户走过来，通过对A和B的习惯分别制定不同的销售策略，满足客户的需求，看看下面的代码：

	
    /// <summary>
    /// 可乐基类
    /// </summary>
    public class Cola
    {
        public virtual string KeLe()
        {
            return "I'm KeLe";
        }
    }
	
/// <summary>
    /// 老板小乙
    /// </summary>
    public class XiaoYi
    {
        private Cola _cola;
        public XiaoYi(Cola cola)
        {
            this._cola = cola;
        }

        public String GetCola()
        {
            return _cola.KeLe();
        }
    }

    /// <summary>
    /// 可口可乐
    /// </summary>
    public class KeKou : Cola
    {
        public override string KeLe()
        {
            return "I'm KeKouKeLe";
        }
    }

    /// <summary>
    /// 可口可乐
    /// </summary>
    public class BaiShi : Cola
    {
        public override string KeLe()
        {
            return "I'm BaiShiKeLe";
        }
    }

    /// <summary>
    /// 非常可乐
    /// </summary>
    public class FeiChang : Cola
    {
        public override string KeLe()
        {
            return "I'm FeiChangKeLe";
        }
}

现在客户走过来之后，拿到可乐的代码应该是像下面这样的：

1.  小乙看到A客户走过来，因为熟悉A喜欢那种可乐，所以小乙马上开始准备：

XiaoYi xiaoyi = new XiaoYi(new BaiShi());

    this.label1.Text = xiaoyi.GetCola();

 

通过对简单工厂模式和策略模式的比较，我们可以看到：简单工厂模式是通过类的多态性，通过工厂直接返回子类，在客户端访问子类的属性或方法；

策略模式是通过对子类的封装，在客户端进行子类的实例化后作为参数传入策略类，对策略类进行实例化，由策略类返回客户端需要的计算结果；