设计模式实例-策略模式

using System;
namespace Ahoo.Demo.DesignPatterns.Patterns.Strategy
{
    /*###### 策略模式 #######
     * 定义算法家族，分别封装起来，让他们之间可以互相替换
     * 此模式使算法的变化不会影响到Client
     * 
     * 策略模式是一种定义一系列算法的方法，所有这些方法完成的都是相同的工作
     * 只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合！
     * 
     * 简化了单元测试，每个算法都有自己的类，可以通过自己的接口单独测试！
     */
    /// <summary>
    /// 抽象算法类
    /// 为Context定义了一系列可重用的算法/行为，集成有助于汲取出这些算法中的公共部分！
    /// </summary>
    abstract class Strategy
    {
        public abstract void AlgorithmInterface();
    }
    /// <summary>
    /// 具体算法A
    /// </summary>
    public class ConcreteStrategyA : Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法A实现！");
        }
    }
    /// <summary>
    /// 具体算法B
    /// </summary>
    public class ConcreteStrategyB : Strategy
    {
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法B实现！");
        }
    }
    /// <summary>
    /// 策略上下文
    /// </summary>
    public class Context
    {
        Strategy Strategy;
        public Context(Strategy strategy)
        {
            Strategy = strategy;
        }
        public Context(string type)
        {
            switch (type)
            { 
                case "A":
                    Strategy = new ConcreteStrategyA();
                    break;
                case "B":
                    Strategy = new ConcreteStrategyB();
                    break;
                default:
                    throw new ArgumentException("参数type有误！");
            }
        }
        /// <summary>
        /// 上下文接口
        /// </summary>
        public void Excute()
        {
            Strategy.AlgorithmInterface();
        }
    }
    public class Client
    {
        public static void Excute()
        {
            Context context = new Context(new ConcreteStrategyA());
            context.Excute();
            context = new Context(new ConcreteStrategyB());
            context.Excute();
        }
    }
}