行为型设计模式之职责链模式(Chain of Responsibility)

结构
意图	使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
适用性	有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 可处理一个请求的对象集合应被动态指定。

using System;

    abstract class Handler 
    {
        protected Handler successorHandler;
        abstract public void HandleRequest(Request request);        
        public void SetSuccessor(Handler sucessor)
        {
            successorHandler = sucessor;
        }
    }

    class ConcreteHandler1 : Handler
    {
        override public void HandleRequest(Request request)
        {
            // determine if we can handle the request
            if (request.RequestType == 1) // some complex decision making!
            {
                // request handling code goes here
                Console.WriteLine("request handled in ConcreteHandler1");
            }
            else 
            {
                // not handled here - pass on to next in the chain
                if (successorHandler != null)
                    successorHandler.HandleRequest(request);
            }
        }
    }

    class ConcreteHandler2 : Handler
    {
        override public void HandleRequest(Request request)
        {
            // determine if we can handle the request
            if (request.RequestType == 2) // some complex decision making!
            {
                // request handling code goes here
                Console.WriteLine("request handled in ConcreteHandler2");
            }
            else 
            {
                // not handled here - pass on to next in the chain
                if (successorHandler != null)
                    successorHandler.HandleRequest(request);
            }
        }
    }

    class ConcreteHandler3 : Handler
    {
        override public void HandleRequest(Request request)
        {
            // determine if we can handle the request
            if (request.RequestType == 3) // some complex decision making!
            {
                // request handling code goes here
                Console.WriteLine("request handled in ConcreteHandler3");
            }
            else 
            {
                // not handled here - pass on to next in the chain
                if (successorHandler != null)
                    successorHandler.HandleRequest(request);
            }        
        }
    }

    class Request 
    {
        private int iRequestType;
        private string strRequestParameters;

        public Request(int requestType, string requestParameters)
        {
            iRequestType = requestType;    
            strRequestParameters = requestParameters;
        }

        public int RequestType 
        {
            get 
            {
                return iRequestType;
            }
            set 
            {
                iRequestType = value;
            }
        }
    }

    /// <summary>
    ///    Summary description for Client.
    /// </summary>
    public class Client
    {
        public static int Main(string[] args)
        {
            // Set up chain (usually one need to be done once)
            Handler firstHandler = new ConcreteHandler1();
            Handler secondHandler = new ConcreteHandler2();
            Handler thirdHandler = new ConcreteHandler3();
            firstHandler.SetSuccessor(secondHandler);
            secondHandler.SetSuccessor(thirdHandler);

            // After setting up the chain of responsibility, we can
            // now generate requests and pass then off to the 
            // chain to be handled

            // generate and fire request
            Request newRequest = new Request(2,"This are the request parameters");
            firstHandler.HandleRequest(newRequest);
            
            return 0;
        }
    }