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

还是那几句话:

学无止境,精益求精

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

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

废话不多说,直接进入正题:

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

具体的实现代码为:

商场促销-策略模式(和简单工厂模式很像的哇) C#商场促销-策略模式(和简单工厂模式很像的哇) 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();
        }
    }
}
View Code

输出端调用代码为:

商场促销-策略模式(和简单工厂模式很像的哇) C#商场促销-策略模式(和简单工厂模式很像的哇) C#
        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();
        }
View Code

策略模式的类图为:

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

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

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

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(); 来创建对应的对象并根据创建的对象,确定执行哪个算法。

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

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

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

商场促销-策略模式(和简单工厂模式很像的哇) C#商场促销-策略模式(和简单工厂模式很像的哇) C#
#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("500", "200"); 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 
View Code

输出端调用如下:

商场促销-策略模式(和简单工厂模式很像的哇) C#商场促销-策略模式(和简单工厂模式很像的哇) C#
        static void Main(string[] args)
        {
            CaseSuper M = CashFactory.GetResult("原价出售");
            Console.WriteLine("原价返回:" + M.acceptCash(900));
            //
            CaseSuper M2 = CashFactory.GetResult("打八折");
            Console.WriteLine("打八折:" + M2.acceptCash(900));
            //
            CaseSuper M3 = CashFactory.GetResult("满五百返两百");
            Console.WriteLine("满五百返两百:" + M3.acceptCash(900));
            Console.ReadKey();
        }
View Code

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

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

商场促销-策略模式(和简单工厂模式很像的哇) C#商场促销-策略模式(和简单工厂模式很像的哇) C#
    #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
View Code

输出端调用代码为:

商场促销-策略模式(和简单工厂模式很像的哇) C#商场促销-策略模式(和简单工厂模式很像的哇) C#
        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("500", "200"); break;
            }
            CashContexts context = new CashContexts(M);
            double Money = context.acceptCash(900);
            Console.WriteLine(types + "" + Money);
            Console.ReadKey();
        }
View Code

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

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

商场促销-策略模式(和简单工厂模式很像的哇) C#商场促销-策略模式(和简单工厂模式很像的哇) C#
    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("500", "200"); break;
            }
        }
        //
        public double acceptCash(double Money)
        {
            return cs.acceptCash(Money);
        }
    }
View Code

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

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

相似点

在模式结构上,两者很相似;

差异

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

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

  • 工厂相当于黑盒子,策略相当于白盒子;

举例说明

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

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

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

@陈卧龙的博客

上一篇:MySQL8.0 - 新特性 - CTE(Common Table Expressions)


下一篇:h5 meta标签大全