职责链模式

定义：使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。

将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

类型：行为类模式

类图：

  /// <summary>
    /// 模拟if else 判定条件
    /// </summary>
    class Level
    {
        private int _level = 0;
        public Level(int level)
        {
            this._level = level;
        }

        /// <summary>
        /// 判定当前条件层级是否高于给定的条件
        /// </summary>
        /// <param name="level"></param>
        /// <returns></returns>
        public bool above(Level level)
        {
            if (this._level >= level._level)
            {
                return true;
            }
            return false;
        }
    }

    /// <summary>
    /// 职责链里面的任务节点
    /// </summary>
    class Request
    {
        private Level _level;
        public Request(Level level)
        {
            this._level = level;
        }

        public Level getLevel()
        {
            return _level;
        }
    }

    class Response
    {
        public string Message=null;
    }

    /// <summary>
    /// 抽象的处理类
    /// </summary>
    abstract class Handler
    {
        private Handler _nextHandler;

        public  Response HandleRequest(Request request)
        {
            Response response = null;

            if (this.GetHandlerLevel().above(request.getLevel())) //当前的处理器级别高于给定的任务的级别
            {
                response = this.Response(request);
            }
            else
            {
                if (this._nextHandler != null) //低于当前的条件判定级别，寻找下一级的处理器
                {
                    this._nextHandler.HandleRequest(request);
                }
                else
                {
                    //没有合适的处理器
                }
            }
            return response;
        }

        public void SetNextHandler(Handler handler)
        {
            this._nextHandler = handler;
        }

        protected abstract Level GetHandlerLevel();

        public abstract Response Response(Request request);
    }

    /// <summary>
    /// 处理器的具体实现
    /// </summary>
    class ConcreteHandler1 : Handler
    {
        protected override Level GetHandlerLevel()
        {
            return new Level(1);
        }

        public override Response Response(Request request)
        {
            //请求由处理器1进行处理
            return null;
        }
    }

    /// <summary>
    /// 处理器的具体实现
    /// </summary>
    class ConcreteHandler2 : Handler
    {
        protected override Level GetHandlerLevel()
        {
            return new Level(3);
        }

        public override Response Response(Request request)
        {
            //请求由处理器2进行处理
            return null;
        }
    }

    /// <summary>
    /// 处理器的具体实现
    /// </summary>
    class ConcreteHandler3 : Handler
    {
        protected override Level GetHandlerLevel()
        {
            return new Level(5);
        }

        public override Response Response(Request request)
        {
            //请求由处理器3进行处理
            return null;
        }
    }

    public class Client
    {
        public static void Main()
        {
            Handler handler1 = new ConcreteHandler1();
            Handler handler2 = new ConcreteHandler2();
            Handler handler3 = new ConcreteHandler3();

            handler1.SetNextHandler(handler2);
            handler2.SetNextHandler(handler3);

            Response response = handler1.HandleRequest(new Request(new Level(4)));
        }
    }