C#重构之职责链模式的使用

前言

  之前我们一起学习了设计模式，那设计模式具体应该如何应用呢？现在我们来一起看一下职责链模式在重构中的应用吧。

内容

  1.什么是职责链模式？

  职责链模式是使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

  2.在机房中的应用

  下机算钱的问题：小于准备上机时间→小于最少上机时间→正常收费；当然还有其他的地方也可以使用，主要是看大家的理解，这里就不再赘述。

  3.相关代码实现

  针对分层的设计理念，B层是业务逻辑层，所以该模式主要是在B层写代码进行判断。

  1）新建职责链的类：

public abstract class ChainMoney
    {
        protected ChainMoney successor;

        //设置继任者
        public void SetSuccessor(ChainMoney successor)
        {
            this.successor = successor;
        }

        //处理请求的抽象方法
        public abstract void CollectMoney(Entity.UserInfo cardno, Entity.BasicData basic);

    }

  2）准备上机时间的类，当上机时间小于BasicData里相应字段的值时，则有权处理，否则转移到下一位：

public class CollectMoneyPre : ChainMoney
    {
        //准备时间内收钱        

        public override void CollectMoney(UserInfo cardno, BasicData basic)
        {
            //上机时间小于准备时间，不收钱
            if (Convert.ToInt32(cardno.ConsumeTime) <= Convert.ToDouble(basic.PrePareTime))
            {
                cardno.Consume = 0;
                cardno.Cash = Convert.ToInt32(cardno.Cash) - Convert.ToInt32(cardno.Consume);
            }
            else
            {
                successor.CollectMoney(cardno, basic);
            }
        }
    }

  3）至少上机时间的类，当上机时间大于准备时间小于至少上机时间时，则有权处理，否则转移到下一位：

public class CollectMoneyLeast:ChainMoney
    {
        //大于准备时间，小于递增单位上机时间，按照1.2倍价钱收费
        public override void CollectMoney(UserInfo cardno, BasicData basic)
        {
            //上机时间大于准备时间，按照单价开始收费
            if (Convert.ToInt32(cardno.ConsumeTime) > Convert.ToDouble(basic.PrePareTime) && Convert.ToInt32(cardno.ConsumeTime) < Convert.ToDouble(basic.LeastTime))
            {
                cardno.Consume = 0;
                cardno.Cash = Convert.ToInt32(cardno.Cash);
            }
            else
            {
                successor.CollectMoney(cardno, basic);
            }
        }
    }

  4）正常收费的类，大于至少上机时间时，有权处理，否则转移到下一位：

//非单位递增时间收钱
    public class CollectMoneyNormal :ChainMoney
    {
        public override void CollectMoney(UserInfo cardno, BasicData basic)
        {
            //上机大于单位时间，按照单价开始收费
            if (Convert.ToInt32(cardno.ConsumeTime) >= Convert.ToInt32(basic.LeastTime))
            {
                double Money = (Convert.ToDouble(cardno.ConsumeTime) / Convert.ToDouble(basic.UnitTime)) * Convert.ToDouble(basic.Rate);

                #region 避免Consume与Cash出现负值
                if (Money >= 0)
                {
                    cardno.Consume = Money;
                }
                else
                {
                    cardno.Consume = cardno.Cash;
                }

                if ((cardno.Cash - cardno.Consume) >= 0)
                {
                    cardno.Cash = (cardno.Cash - cardno.Consume);
                }
                else
                {
                    cardno.Cash = 0;
                }
                #endregion
            }
            else
            {
                successor.CollectMoney(cardno, basic);
            }
        }
    }

  在外观层中设置职责链的上下家。

    public class StudentConsumeFacade
    {
        public void Consume(Entity.UserInfo cardno, Entity.BasicData basic)
        {
            BLL.ChainMoney PerConsume = new BLL.CollectMoneyPre();
            BLL.ChainMoney LeastConsume = new BLL.CollectMoneyLeast();
            BLL.ChainMoney NormalConsume = new BLL.CollectMoneyNormal();

            //设置职责链的上下家
            PerConsume.SetSuccessor(LeastConsume);
            LeastConsume.SetSuccessor(NormalConsume);

            //职责链的首家开始提交请求
            PerConsume.CollectMoney(cardno, basic);
        }

    }

  在U层中进行调用。

	Facade.StudentConsumeFacade facade = new Facade.StudentConsumeFacade();
    facade.Consume(CardNo, basic);

总结

  职责链模式中的每一个链都不知道它的下一个链是谁，只是知道它处理不了转移到下一位，至此，就是成功的运用了设计模式，当然，可能有的地方还不是很合理，欢迎指出。