Strategy

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

    //策略类，定义所有支持的算法的公共接口
    public abstract class Strategy
    {
        //算法方法。
        public abstract void AlgorithmInterface();
    }

    //封装了具体的方法或行为，继承于Strategy
    public class ConcreteStrategyA : Strategy
    {
        public override void AlgorithmInterface()
        {
            //算法A实现方法
            Console.WriteLine("算法A的实现");
        }
    }

    //封装了具体的方法或行为，继承于Strategy
    class ConcreteStrategyB:Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法B的实现");
        }
    }

    //封装了具体的方法或行为，继承于Strategy
    class ConcreteStrategyC : Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法C的实现");
        }
    }

    //上下文
    class Context
    {
        Strategy straetgy;
        public Context(Strategy straetgy)//初始化时，传入具体的策略对象
        {
            this.straetgy = straetgy;
        }
        //上下文接口
        public void ContextInterface() { //根据其具体的策略对象，调用其算法的方法
            straetgy.AlgorithmInterface();
        }
    }

        static void Main(string[] args)
        {
            Context context;
            context = new Context(new ConcreteStrategyA());//由于实例化不同的策略，所以最终在调用context.ContextInterface()时，所获得的结果也是不相同的
            context.ContextInterface();

            context = new Context(new ConcreteStrategyB());//由于实例化不同的策略，所以最终在调用context.ContextInterface()时，所获得的结果也是不相同的
            context.ContextInterface();

            context = new Context(new ConcreteStrategyC());//由于实例化不同的策略，所以最终在调用context.ContextInterface()时，所获得的结果也是不相同的
            context.ContextInterface();

            Console.Read();
        }