功能

用户下机，进行金钱和时间的计算，需要进行多重判断

职责链设计模式

在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

用我的话说就是，有一个任务，分给一部分任务处理者，但是每个任务处理者都有属于自己的处理模块，但是如何进行任务分配呢？那就用到了职责链模式，通过逐级的判断，进行动态的任务分配，从而实现相应的效果!

涉及到的角色

• 抽象处理者(Handler)角色：定义出一个处理请求的接口。
• 具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。

优点

• 降低耦合
• 提高代码的复用性（以后还有需要算账的，直接调用就好了）
• 减少了代码量（你可以先不用设计模式理清思路，再用设计模式进行完善，之后你会发现设计模式的好处）

代码

    //抽象处理者
    public abstract class Manager
    {
        protected Manager superior;

        public void SetSuperior(Manager superior)
        {
            this.superior = superior;
        }
        //定义抽象方法
        public abstract OnLine  GetCash(OnLine online);
    }

    //具体事物处理者
     public class ManagerOne : Manager
    {
        public override OnLine  GetCash(OnLine online)
        {
            //消费时间小于准备+上机时间
            if (online .ConsumeTime <=(online .LeastTime +online .ReadyTime))
            {
                online.ConsumeTime = 0;
            }
            else
            {
                superior.GetCash(online);
            }
            return online;
        }
    }
    public class ManagerTwo : Manager
    {
        public override OnLine GetCash(OnLine online)
        {
            //消费时间大于准备+上机时间
            if (online.ConsumeTime > (online.LeastTime + online.ReadyTime))
            {
                int x;
                int y;
                x = online.ConsumeTime / online.IncreaseTime;
                y = online.ConsumeTime % online.IncreaseTime;
                if (online .type =="一般用户")
                {
                    if (y == 0)
                    {
                        online.ConsumeMoney = online.CasualUser * x;
                    }
                    else if (y > 0 && y < online.IncreaseTime)
                    {
                        online.ConsumeMoney = online.CasualUser * (x + 1);
                    }
                }
                else
                {
                    if (y == 0)
                    {
                        online.ConsumeMoney = online.RegularUser * x;
                    }
                    else if (y > 0 && y < online.IncreaseTime)
                    {
                        online.ConsumeMoney = online.RegularUser * (x + 1);
                    }
                }
            }
        }
    }

接口层代码

        //实例化事物处理者
        BLL.ZZL.ManagerOne zzl1 = new BLL.ZZL.ManagerOne();
        BLL.ZZL.ManagerTwo zzl2 = new BLL.ZZL.ManagerTwo();
        Entity.OnLine online = new Entity.OnLine();

        public Entity .OnLine Count(Entity . OnLine line)
        {
            //进行动态的任务分配
            zzl1.SetSuperior (zzl2);
            online = zzl1.GetCash(line);
            return online;
        }

在U层，我们需要做的就是实例化外观层，通过数据库调取出下机所需的数据，付给实体，进行处理，在这里就不给大家展示了！