Stratege Pattern浅谈

策略模式 : 定义了算法族，分别封装起来，让它们之间可以互相替换， 此模式让算法的变化独立于使用算法的客户。

设计原则：
1.找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
2.针对接口编程，而不是针对实现编程。
3.多用组合,少用继承。

1.定义行为接口：

    /// <summary>
    /// 飞行接口
    /// </summary>
    public interface IFly
    {
        /// <summary>
        /// 飞行
        /// </summary>
        void Fly();
    }

    /// <summary>
    /// "叫"接口
    /// </summary>
    public interface IQuack
    {
        /// <summary>
        /// "叫"方法
        /// </summary>
        void Quack();
    }

2.实现接口的行为：

   a.飞行行为的实现:

    /// <summary>
    /// 不能飞
    /// </summary>
    public class FlyNoWay : IFly
    {
        #region IFly Members

        /// <summary>
        /// 不能飞
        /// </summary>
        public void Fly()
        {
            Console.WriteLine("不能飞行");
        }

        #endregion
    }

    /// <summary>
    /// 用翅膀飞行
    /// </summary>
    public class FlyWithWings : IFly
    {
        #region IFly Members

        /// <summary>
        /// 用翅膀飞行
        /// </summary>
        public void Fly()
        {
            Console.WriteLine("用翅膀飞行");
        }

        #endregion
    }

    

   b.“叫”行为的实现：

    /// <summary>
    /// 什么都不叫
    /// </summary>
    public class MuteQuack : IQuack
    {
        #region IQuack Members

        /// <summary>
        /// 什么都不叫
        /// </summary>
        public void Quack()
        {
            Console.WriteLine("什么都不叫");
        }

        #endregion
    }

    /// <summary>
    /// 呱呱叫
    /// </summary>
    public class Quack : IQuack
    {
        #region IQuack Members

        /// <summary>
        /// 呱呱叫
        /// </summary>
        void IQuack.Quack()
        {
            Console.WriteLine("呱呱叫");
        }

        #endregion
    }

    /// <summary>
    /// 吱吱叫
    /// </summary>
    public class Squeak : IQuack
    {
        #region IQuack Members

        /// <summary>
        /// 吱吱叫
        /// </summary>
        public void Quack()
        {
            Console.WriteLine("吱吱叫");
        }

        #endregion
    }

3.Duck父类：

    /// <summary>
    /// 鸭子超类
    /// </summary>
    public abstract class Duck
    {

        public IFly ifly;
        public IQuack iquack;

        /// <summary>
        /// 构造函数
        /// </summary>
        public Duck()
        {

        }

        /// <summary>
        /// 委托执行飞行
        /// </summary>
        public void PerformFly()
        {
            ifly.Fly();
        }

        /// <summary>
        /// 委托执行叫
        /// </summary>
        public void PerformQuack()
        {
            iquack.Quack();
        }

        /// <summary>
        /// 游水
        /// </summary>
        public void Swim()
        {
            Console.Write("这是执行Duck类的游水方法");
        }

        /// <summary>
        /// 颜色显示
        /// </summary>
        public abstract void Display();


        /// <summary>
        /// 
        /// </summary>
        /// <param name="iFly"></param>
        public void SetIFly(IFly iFly)
        {
            ifly = iFly;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="iQuack"></param>
        public void SetIQuack(IQuack iQuack)
        {
            iquack = iQuack;
        }

    }

4.继承Duck父类的子类：

    /// <summary>
    /// 绿头鸭
    /// </summary>
    public class MallardDuck : Duck
    {
        public MallardDuck()
        {
            ifly = new FlyWithWings();
            iquack = new Quack();
        }

        /// <summary>
        /// 
        /// </summary>
        public override void Display()
        {
            Console.WriteLine("绿头鸭");
        }
    }

5.测试：

    class Program
    {
        static void Main(string[] args)
        {
            Duck mallard = new MallardDuck();
            mallard.PerformFly();
            mallard.SetIFly(new FlyNoWay());
            mallard.PerformFly();
            Console.ReadLine();
        }
    }

Strategy： 策略接口，用来约束一系列具体的策略算法。Context使用这个接口来调用具体的策略实现定义的算法。

ConcreteStrategy： 具体的策略实现，也就是具体的算法实现。

Context： 上下文，负责和具体的策略类交互，通常上下文会持有一个真正的策略实现，上下文还可以让具体的策略类来获取上下文的数据，甚至让具体的策略类来回调上下文的方法。