策略模式

例子：
有一天学校里面要请一些实习或者外聘讲师，他们都是讲一次拿一次钱，可是他们每个讲师的报酬却不一样，有的老师讲一节课200+超市卡，有的老师200会 打折一部份捐献给希望工程
分析：
我们可以看出，目前这个都是给讲师报酬，只是不同讲师报酬的计算方式不一样，我们可以算法不同去封装对象，于是我们可以用策略模式,策略模式结构图：



分析代码：

    public  abstract class TeacherWages
    {
        public abstract double GetWages(double money);
    }

    //正常给的
    public class WagesA : TeacherWages
    {
        public override double GetWages(double money)
        {
            return money;
        }
    }

    //折扣的报酬
    public class WagesB : TeacherWages
    {
        private double moneyRebate = 1;
        public WagesB(double _moneyRebate)
        {
            this.moneyRebate = _moneyRebate;
        }

        public override double GetWages(double money)
        {
            return money*moneyRebate;
        }
    }

    //多给100元超市购物卡
    public class WagesC : TeacherWages
    {
        public double moneyCondition = 0;

        public WagesC(double _moneyCondition)
        {
            this.moneyCondition = _moneyCondition;
        }

        public override double GetWages(double money)
        {
            return money + moneyCondition;
        }
    }
此时我们已经将我们的算法都封装起来了，现在我们实现我们的收费策略：
  //收费策略
    public class WareContext
    {
        private TeacherWages teacherware;

        public WareContext(TeacherWages _teacherware)
        {
            teacherware = _teacherware;
        }

        public double GetWare(double money)
        {
            return teacherware.GetWages(money);
        }
    }
客户端调用：
  WareContext _context;
            string _type = "";
            switch (_type)
            {
                case "A":
                    _context=new WareContext(new WagesA());
                    break;
                case "B":
                    _context=new WareContext(new WagesB("0.8"));
                    break;
                      case "C":
                    _context=new WareContext(new WagesC(100));
                    break;
                default:
                    _context = null;
                   break;
            }
            _context.GetWare(200);
我们不想将创建对象放在客户端，我想把判断从客户端移走：
 public class WaresContext
    {
        private TeacherWages teacherware;

        public WaresContext(string _type)
        {
            switch (_type)
            {
                case "A":
                    teacherware = new WagesA();
                    break;
                case "B":
                    teacherware = new WagesB(0.8);
                    break;
                case "C":
                    teacherware = new WagesC(100);
                    break;
                default:
                    teacherware = null;
                    break;
            }
        }

        public double GetWare(double money)
        {
            return teacherware.GetWages(money);
        }
    }
客户端调用：
WaresContext context = new WaresContext("A");
            context.GetWare(200);
这样简单工厂与策略模式结合方式让我们客户端与算法彻底隔离。
定义：
策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下 发生变化。
策略模式是对算法的包装，是把使用算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个 抽象策略类的子类。用一句话来说，就是："准备一组算法，并将每一个算法封装起来，使得它们可以互换。"