设计模式之——策略模式

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

纯概念不太好理解，让我们来看一个需求：

现在需要制造一批不同种类的交通工具(包括汽车、摩托车、自行车……),假设所有的交通工具只有两个部分构成：引擎(热力和人力)和轮子(大小等)，可以如下实现方法，抽象出交通工具Transport类：

    public abstract class Transport
    {
        /// <summary>
        /// 引擎
        /// </summary>
        /// <returns></returns>
        public abstract string Engine();

        /// <summary>
        /// 轮子
        /// </summary>
        /// <returns></returns>
        public abstract string Wheel();
    }

制造汽车(假设所有的汽车都是一样的，贴上不同的标签就是不同的牌子)、摩托车、自行车类如下所示：(简化了Engine和Wheel的制造方法)

 1     public class Car:Transport
 2     {
 3         /// <summary>
 4         /// 热动力引擎
 5         /// </summary>
 6         /// <returns></returns>
 7         public override string Engine()
 8         {
 9             return "Engine For Heat";
10         }
11 
12         /// <summary>
13         /// 特制轮子
14         /// </summary>
15         /// <returns></returns>
16         public override string Wheel()
17         {
18             return "Special wheel";
19         }
20     }

    public class Motorcycle:Transport
    {
        /// <summary>
        /// 热动力引擎
        /// </summary>
        /// <returns></returns>
        public override string Engine()
        {
            return "Engine For Heat";
        }

        /// <summary>
        /// 一般轮子
        /// </summary>
        /// <returns></returns>
        public override string Wheel()
        {
            return "General wheel";
        }
    }

    public class Bicycle:Transport
    {
        /// <summary>
        /// 人力引擎
        /// </summary>
        /// <returns></returns>
        public override string Engine()
        {
            return "Engine For People";
        }

        /// <summary>
        /// 一般轮子
        /// </summary>
        /// <returns></returns>
        public override string Wheel()
        {
            return "General wheel";
        }
    }

摩托车(MotorCycle)介于Car和Bicycle之间，引擎和Car一样，Wheel和Bicycle一样，这样实现虽然解决了问题。但是有两个弊端：

一、出现比较多的重复代码，无法达到重用。而且随着需求变化，出现三轮车(Engine、Wheel和Bicycle一样)、卡车(Engine、Wheel和Car一样)……重复的部分会越来越多。

二、某一天，相关部门研究发现依靠热力的Engine排放了严重污染大气的尾气，需要用新研制的环保型Engine替换，就得要遍地寻找使用了原先落后技术制造的Engine，逐个更改……这无疑是个噩梦……

是时候让策略模式出场了，首先定义Wheel和Engine的抽象接口，然后将Wheel和Engine分别实现不同的制造方法，再改变下Transport抽象类：

IWheel和IEngine的定义：

    public interface IWheel
    {
        string CreatWheel();
    }


    public interface IEngine
    {
        string CreatEngine();
    }

Engine和Wheel分别分开实现各自的系列算法：

    public class HeatEngine:IEngine
    {
        public string CreatEngine()
        {
            return "Engine From Heat";
        }
    }



    public class HuManEngine:IEngine
    {
        public string CreatEngine()
        {
            return "Engine From People";
        }
    }

    public class SpecialWheel:IWheel
    {
        public string CreatWheel()
        {
            return "Special Wheel";
        }
    }


    public class GeneralWheel:IWheel
    {
        public string CreatWheel()
        {
            return "General Wheel";
        }
    }

修改下Transport抽象类：

    public abstract class Transport
    {
        public IEngine _engine;
        public IWheel _wheel;

        public void SetEngine(IEngine engine)
        {
            this._engine = engine;
        }

        public void SetWheel(IWheel wheel)
        {
            this._wheel = wheel;
        }

        /// <summary>
        /// 制造引擎
        /// </summary>
        /// <returns></returns>
        public string Engine()
        {
            return this._engine.CreatEngine();
        }

        /// <summary>
        /// 制造轮子
        /// </summary>
        /// <returns></returns>
        public string Wheel()
        {
            return this._wheel.CreatWheel();
        }

        /// <summary>
        /// 车外形
        /// </summary>
        /// <returns></returns>
        public abstract string Display();
    }

Car、MotorCycle、Bicycle继承Transport：(因为都类似，只例举其一)

    public class Bicycle : Transport
    {
        public override string Display()
        {
            return "With Blue Color";
        }
    }

上述类和接口关系如下：

如图所示，可以动态扩展不同的Wheel和Engine。例如新增加了电动车，使用ElectricEngine和GeneralWheel，只需要新增一个ElectricEngine继承自IEngine如下：

    public class ElectricEngine:IEngine
    {
        public string CreatEngine()
        {
            return "Engine From Electric";
        }
    }

然后客户端引用IEngine的dll,不需要额外改动任何地方即可动态更改：

        static void Main(string[] args)
        {
            Transport ts = new Car();
            ts.SetEngine(new HeatEngine());
            ts.SetWheel(new SpecialWheel());
            Console.WriteLine("====================================");
            Console.WriteLine(ts.Engine() + " " + ts.Wheel() + " " + ts.Display());
            Console.WriteLine("====================================");
            Console.WriteLine("Electric Engine :");
            ts.SetEngine(new ElecricEngine());
            ts.SetWheel(new GeneralWheel());
            Console.WriteLine(ts.Engine() + " " + ts.Wheel() + " " + ts.Display());            

            Console.ReadKey();
        }

 程序运行结果如下图所示：

=====================================================

欢迎大家指正~