责任链模式

引言

责任链模式 是一种对象间通信的方式。
正如其名称所示，会构建一个处理程序链，并且链中的每个处理程序负责处理传递的请求或将其传递给链中的下一个处理程序。在过程的最后，请求将以默认或异常行为处理。
该模式通过使对象无需知道最终哪个处理程序将处理请求来帮助降低耦合度。

责任链模式的使用场景

您应该在以下情况下使用该模式

• 有多个对象可以处理请求。
• 您有一个场景，需要将请求传递给多个对象中的一个，而无需指定接收者。
• 您需要动态指定请求的处理程序。

UML 图

C# 示例

    #region Abstract Handler Class

    public abstract class Handler
    {
        #region Properties
        /// <summary>
        /// The request limit that the current handler can process
        /// </summary>
        public int RequestLimit { get; private set; }

        /// <summary>
        /// The next handler in the chain
        /// </summary>
        public Handler NextHandler { get; private set; }
        #endregion

        #region Methods
        public abstract void HandleRequest(int request);
        #endregion

        #region Ctor
        public Handler(Handler handler, int requestLimit)
        {
            NextHandler = handler;
            RequestLimit = requestLimit;
        }
        #endregion
    }

    #endregion

    #region Concrete Handlers

    public class Worker : Handler
    {
        #region Ctor
        /// <summary>
        /// Construct a new worker object with the given handler
        /// </summary>
        /// <param name="handler">The given handler</param>
        public Worker(Handler handler)
            : base(handler, 10000)
        {
        }
        #endregion

        #region Methods
        public override void HandleRequest(int request)
        {
            if (request < RequestLimit)
            {
                Console.WriteLine("{0} handled a {1} request", GetType().Name, request);
            }
            else
            {
                if (NextHandler != null)
                {
                    NextHandler.HandleRequest(request);
                }
            }
        }
        #endregion
    }

    public class Manager : Handler
    {
        #region Ctor
        /// <summary>
        /// Construct a new manager object with the given handler
        /// </summary>
        /// <param name="handler">The given handler</param>
        public Manager(Handler handler)
            : base(handler, 20000)
        {
        }
        #endregion

        #region Methods
        public override void HandleRequest(int request)
        {
            if (request < RequestLimit)
            {
                Console.WriteLine("{0} handled a {1} request", GetType().Name, request);
            }
            else
            {
                if (NextHandler != null)
                {
                    NextHandler.HandleRequest(request);
                }
            }
        }
        #endregion
    }

    public class SeniorManager : Handler
    {
        #region Ctor
        /// <summary>
        /// Construct a new senior manager object with the given handler
        /// </summary>
        /// <param name="handler">The given handler</param>
        public SeniorManager(Handler handler)
            : base(handler, 50000)
        {
        }
        #endregion

        #region Methods
        public override void HandleRequest(int request)
        {
            if (request < RequestLimit)
            {
                Console.WriteLine("{0} handled a {1} request", GetType().Name, request);
            }
            else
            {
                if (NextHandler != null)
                {
                    NextHandler.HandleRequest(request);
                }
            }
        }
        #endregion
    }

    #endregion

示例很简单。
我有三种类型的员工：员工、经理和高级经理。每种员工类型都可以处理低于其请求限制的请求。
每当到达大于请求限制的请求时，员工类型会将请求传递给链中的下一个处理程序，直到没有可以处理请求的人为止。

以下示例显示了示例类的用例

    class Program 
    { 
        static void Main(string[] args)
        {
            // Setup Chain of Responsibility
            SeniorManager seniorManager = new SeniorManager(null);
            Manager manager = new Manager(seniorManager);
            Worker worker = new Worker(manager);

            // Run requests along the chain
            worker.HandleRequest(5000);
            worker.HandleRequest(15000);
            worker.HandleRequest(35000);

            Console.WriteLine();

            manager.HandleRequest(5000);
            manager.HandleRequest(15000);
            manager.HandleRequest(35000);

            Console.WriteLine();

            seniorManager.HandleRequest(5000);
            seniorManager.HandleRequest(15000);
            seniorManager.HandleRequest(35000);

            // Wait for user
            Console.Read();
        }
    }

摘要

总而言之，责任链模式并不常用。即便如此，如果您想沿着一条对象链发送请求，而这些对象可能或可能不处理该请求，它仍然非常有用。