行为型设计模式之职责链模式(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 == ) // 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 == ) // 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 == ) // 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(,"This are the request parameters");
             firstHandler.HandleRequest(newRequest);

             return ;
         }
     }

职责链模式