商场促销-策略模式（和简单工厂模式很像的哇） C#

还是那几句话：

学无止境，精益求精

十年河东，十年河西，莫欺少年穷

学历代表你的过去，能力代表你的现在，学习代表你的将来

废话不多说，直接进入正题：

首先按照大话设计模式的解释，在这里也总结下策略模式的概念：它定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户！

具体的实现代码为：

namespace SJMS
{
    /// <summary>
    /// 抽象算法类
    /// </summary>
    public abstract class Strategy
    {
        /// <summary>
        /// 抽象算法
        /// </summary>
        public abstract void AlgorithmInterface();
    }

    /// <summary>
    /// 具体算法A
    /// </summary>
    public class ConcreteStrategyA : Strategy
    {
        /// <summary>
        /// 算法A的具体实现方法
        /// </summary>
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法A的具体方法");
        }
    }

    /// <summary>
    /// 具体算法B
    /// </summary>
    public class ConcreteStrategyB : Strategy
    {
        /// <summary>
        /// 算法B的具体实现方法
        /// </summary>
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法B的具体方法");
        }
    }

    /// <summary>
    /// 抽象算法C
    /// </summary>
    public class ConcreteStrategyC : Strategy
    {
        /// <summary>
        /// 算法C的具体实现方法
        /// </summary>
        public override void AlgorithmInterface()
        {
            Console.WriteLine("算法C的具体方法");
        }
    }

    public class Context
    {
        private Strategy _strategy;
        /// <summary>
        /// 用于维护抽象算法类对象
        /// </summary>
        public Context(Strategy strategy)
        {
            this._strategy = strategy;
        }

        /// <summary>
        /// 根据维护的不同对象，调用对应的算法
        /// </summary>
        public void ContextInterface()
        {
            _strategy.AlgorithmInterface();
        }
    }
}

输出端调用代码为：

        static void Main(string[] args)
        {
            Context context;

            //由Context维护得到算法A的对象，并由算法A的对象执行算法A
            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();
            //由Context维护得到算法B的对象，并由算法A的对象执行算法B
            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();
            //由Context维护得到算法C的对象，并由算法A的对象执行算法C
            context = new Context(new ConcreteStrategyC());
            context.ContextInterface();
        }

策略模式的类图为：

看到上述代码和类图，现在的你是不是一头雾水？

既然一头雾水，那么我们就静下心来分析下代码的实现

1、Strategy.cs 主要的功能是：抽象算法类，被各个具体的算法类继承，抽象方法被重写成各个具体的算法！

2、ConcreteStrategyA.cs、ConcreteStrategyB.cs、ConcreteStrategyC.cs、ConcreteStrategyD.cs.......等用于实现具体的算法

针对第二点，在这里举个例子：某一个商场促销，搞了很多活动，例如：年初一所有商品打一折，年初二所有商品打二折，....年初九所有商品打九折！元宵节针对所有商品推出消费满500减200的活动，清明节针对所有商品推出消费满800立减300的活动！六一儿童节推出消费N元送N积分的活动！国庆节，中秋节推出消费N元送N积分并优惠N/3元的活动等等等

在这里，一些列打折的活动可以看作算法A。消费满N元送M元的活动可看作算法B。消费N元送N积分的活动可以看作算法C。消费N元送N积分并且优惠N/3 元的活动可看作算法D。等等吧！总之商场可以推出N中不同算法的活动！

3、Context.cs 主要的功能是根据客户端不同的调用：context = new Context(new ConcreteStrategyA());  context.ContextInterface(); 来创建对应的对象并根据创建的对象，确定执行哪个算法。

针对第三点中加粗的文字：来创建对应的对象并根据创建的对象，确定执行哪个算法。上一节中我们讨论了简单工厂模式，我们知道简单工厂模式中的工厂就是负责生产不同的对象！因此，在这方面（生产对象），策略模式和简单工厂模式非常相似！

那么，在实际的代码中，我们怎么来构造策略模式呢？

在此，按照上述商场促销活动的例子，我们先用简单工厂模式实现，如下：

#region 简单工厂模式实现
    /// <summary>
    /// 简单工厂模式实现
    /// </summary>
    public class CashFactory
    {
        public static CaseSuper GetResult(string type)
        {
            CaseSuper Model = null;
            switch (type)
            {
                case "原价出售": Model = new CaseNormal(); break;
                case "打八折": Model = new CaseRebate("0.8"); break;
                case "满五百返两百": Model = new CaseRerurn("", ""); break;
            }
            return Model;
        }
    }

    /// <summary>
    /// 抽象类
    /// </summary>
    public abstract class CaseSuper
    {
        /// <summary>
        /// 原价
        /// </summary>
        /// <param name="money">返回原价：不打折</param>
        /// <returns></returns>
        public abstract double acceptCash(double Money);
    }

    /// <summary>
    /// 正常收费
    /// </summary>
    public class CaseNormal : CaseSuper
    {
        public override double acceptCash(double Money)
        {
            return Money;
        }
    }

    /// <summary>
    /// 打折收费
    /// </summary>
    public class CaseRebate : CaseSuper
    {
        private double rebate = 1d;
        public CaseRebate(string Rebate)
        {
            rebate = Convert.ToDouble(Rebate);
        }
        public override double acceptCash(double Money)
        {
            return Money * rebate;
        }
    }

    public class CaseRerurn : CaseSuper
    {
        private double moneyContion = 0d;
        private double returnMoney =0d;

        public CaseRerurn(string MoneyContion,string ReturnMoney)
        {
            returnMoney = Convert.ToDouble(ReturnMoney);
            moneyContion = Convert.ToDouble(MoneyContion);
        }
        public override double acceptCash(double Money)
        {
            if (Money >= moneyContion)
            {
                return Money - returnMoney;
            }
            else
            {
                return Money;
            }
        }
    }
   #endregion 

输出端调用如下：

        static void Main(string[] args)
        {
            CaseSuper M = CashFactory.GetResult("原价出售");
            Console.WriteLine("原价返回：" + M.acceptCash());
            //
            CaseSuper M2 = CashFactory.GetResult("打八折");
            Console.WriteLine("打八折：" + M2.acceptCash());
            //
            CaseSuper M3 = CashFactory.GetResult("满五百返两百");
            Console.WriteLine("满五百返两百：" + M3.acceptCash());
            Console.ReadKey();
        }

上述便是我们利用简单工程模式实现的代码，不过，在这里，我们会发现上述代码的我们对策略模式的讨论几乎一样，至少少了个 Context.cs 类。

在此，我们按照上述的思路构建 Context.cs 类，如下：

    #region 策略模式
    public class CashContexts
    {
        private CaseSuper _caseSuper;
        /// <summary>
        /// 用于维护抽象算法类对象
        /// </summary>
        public CashContexts(CaseSuper caseSuper)
        {
            this._caseSuper = caseSuper;
        }

        /// <summary>
        /// 根据维护的不同对象，调用对应的算法
        /// </summary>
        public double acceptCash(double Money)
        {
           return _caseSuper.acceptCash(Money);
        }
    }
    #endregion

输出端调用代码为：

        static void Main(string[] args)
        {
            //策略模式
            string types = Console.ReadLine();
            CaseSuper M = null;
            switch (types)
            {
                case "打八折": M = new CaseRebate("0.8"); break;
                case "打五折": M = new CaseRebate("0.5"); break;
                case "满五百返两百": M =  new CaseRerurn("", ""); break;
            }
            CashContexts context = new CashContexts(M);
            double Money = context.acceptCash();
            Console.WriteLine(types + "：" + Money);
            Console.ReadKey();
        }

上述代码，输出端的代码 Switch 是没必要存在的，因为多个输出端调用会造成代码的重复，结合工厂模式，我们把 Context.cs 类衍生出如下类：

即：简单工厂模式与策略模式相结合

    public class CashContext
    {
        private CaseSuper cs;
        public CashContext(string type)
        {
            switch (type)
            {
                case "原价出售": cs = new CaseNormal(); break;
                case "打八折": cs = new CaseRebate("0.8"); break;
                case "满五百返两百": cs = new CaseRerurn("", ""); break;
            }
        }
        //
        public double acceptCash(double Money)
        {
            return cs.acceptCash(Money);
        }
    }

OK，上述便是策略模式，我在看来策略模式和简单工厂模式非常相似。一个是创建对象的工厂，一个是具体执行哪个算法的策略。

简单工厂模式与策略模式的区别在于：

相似点

在模式结构上，两者很相似；

差异

• 用途不一样 
  工厂是创建型模式,它的作用就是创建对象； 
  策略是行为型模式,它的作用是让一个对象在许多行为中选择一种行为;

• 关注点不一样 
  一个关注对象创建 
  一个关注行为的封装

• 解决不同的问题 
  工厂模式是创建型的设计模式，它接受指令，创建出符合要求的实例；它主要解决的是资源的统一分发，将对象的创建完全独立出来，让对象的创建和具体的使用客户无关。主要应用在多数据库选择，类库文件加载等。 
  策略模式是为了解决的是策略的切换与扩展，更简洁的说是定义策略族，分别封装起来，让他们之间可以相互替换，策略模式让策略的变化独立于使用策略的客户。

• 工厂相当于黑盒子，策略相当于白盒子；

举例说明

• 工厂模式 
  有一天你决定去吃培根披萨，首先得选择店铺，A店和B店都有培根披萨； 
  你点了A店的培根披萨，过了二十分钟，你的披萨就来了就可以吃到了。但这个披萨是怎么做的，到底面粉放了多少，培根放了多少，佐料放了多少，有多少道工序，你是不需要管的，你需要的是一个美味培根披萨。

• 策略模式 
  在披萨店，你要一个培根披萨，老板说有标准的pizza，也可以自己去做。原料有培根、面粉、佐料。工序有1、2、3工序，你自己去做吧。然后你就需要自己去做，到底放多少培根，放多少面粉，放多少佐料，这都你自己来决定，工序1、2、3，你是怎么实现的，都你自己决定。最后你得到了披萨。

• 当然，大家可自行查阅资料、

@陈卧龙的博客