设计模式

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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    enum Coupon
    {
        NoCoupon,
        Discount,
        ReturnM
    }
    
    #region

    abstract class CashSuper
    {
        public abstract double acceptCash(double money);
    }

    class CashNormal: CashSuper
    {
        public override double acceptCash(double money)
        {
            return money;
        }
    }

    class CashRebate: CashSuper
    {
        private double rebate = 1d;

        public CashRebate(double rebate)
        {
            this.rebate = rebate;
        }

        public override double acceptCash(double money)
        {
            return money * rebate;
        }
    }

    class CashReturn : CashSuper
    {
        private double moneyCondition = 0.0;
        private double moneyReturn = 0.0d;

        public CashReturn(double moneyCondition, double moneyReturn)
        {
            this.moneyCondition = moneyCondition;
            this.moneyReturn = moneyReturn;
        }

        public override double acceptCash(double money)
        {
            double result = money;

            if(money > moneyCondition)
            {
                result = money - Math.Floor(money/moneyCondition) * moneyReturn;
            }

            return result;
        }
    }

    #endregion

    #region Strategy Context

    // Factory Pattern and Strategy Pattern
    class CashContext
    {
        private CashSuper cs = null;

        public CashContext(Coupon cp)
        {
            switch(cp)
            {
                case Coupon.NoCoupon:
                    cs = new CashNormal();
                    break;
                case Coupon.Discount:
                    cs = new CashRebate(0.8);
                    break;
                case Coupon.ReturnM:
                    cs = new CashReturn(300, 100);
                    break;
            }
        }

        public double GetResult(double money)
        {
            return this.cs.acceptCash(money);
        }
    }

    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            CashContext cs = new CashContext(Coupon.Discount);
            double d1 = cs.GetResult(500);

            cs = new CashContext(Coupon.ReturnM);
            double d2 = cs.GetResult(700);

            Console.ReadLine();
        }
    }
}

以上实例中，在策略模式中使用了工厂模式，可见工厂模式并非只有建立一个工厂类的做法。

本示例中， 也可以用简单工厂模式去实现，不过它需要客户端认识两个类去完成；而使用策略模式，只需要认识一个Context类就可以了，耦合降低了。

策略模式封装了变化。模式策略就是用来封装算法的。但是在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的规则，就可以考虑使用策略模式处理这种变化的可能性。

在基本的策略模式中，选择所有具体实现的职责由客户端对象承担，并转给策略模式的Context对象，这本身并没有解除客户端选择判断的压力，而策略模式与简单工厂模式结合之后，选择具体的职责可以由Context来承担，这最大化的减轻了客户端的职责。