设计模式 职责连模式(Chain of Responsibility)

意图

　　使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

适用性

　　1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

　　2.你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

　　3.可处理一个请求的对象集合应被动态指定。 

结构图　　

Code

  1 // Chain Of Responsibility
  2 
  3 /* Notes:
  4  * The client sends a request and it will be operated on by one of a number 
  5  * of potential receivers, in a chain. The client does not know (and does 
  6  * not need to know) which receiver handles the request. The receivers are
  7  * in a chain, and the request is passed from one to the next, until one 
  8  * receiver actually performs the request. 
  9  */
 10  
 11 namespace ChainOfResponsibility_DesignPattern
 12 {
 13     using System;
 14 
 15     abstract class Handler 
 16     {
 17         protected Handler successorHandler;
 18         abstract public void HandleRequest(Request request);        
 19         public void SetSuccessor(Handler sucessor)
 20         {
 21             successorHandler = sucessor;
 22         }
 23     }
 24 
 25     class ConcreteHandler1 : Handler
 26     {
 27         override public void HandleRequest(Request request)
 28         {
 29             // determine if we can handle the request
 30             if (request.RequestType == 1) // some complex decision making!
 31             {
 32                 // request handling code goes here
 33                 Console.WriteLine("request handled in ConcreteHandler1");
 34             }
 35             else 
 36             {
 37                 // not handled here - pass on to next in the chain
 38                 if (successorHandler != null)
 39                     successorHandler.HandleRequest(request);
 40             }
 41         }
 42     }
 43 
 44     class ConcreteHandler2 : Handler
 45     {
 46         override public void HandleRequest(Request request)
 47         {
 48             // determine if we can handle the request
 49             if (request.RequestType == 2) // some complex decision making!
 50             {
 51                 // request handling code goes here
 52                 Console.WriteLine("request handled in ConcreteHandler2");
 53             }
 54             else 
 55             {
 56                 // not handled here - pass on to next in the chain
 57                 if (successorHandler != null)
 58                     successorHandler.HandleRequest(request);
 59             }
 60         }
 61     }
 62 
 63     class ConcreteHandler3 : Handler
 64     {
 65         override public void HandleRequest(Request request)
 66         {
 67             // determine if we can handle the request
 68             if (request.RequestType == 3) // some complex decision making!
 69             {
 70                 // request handling code goes here
 71                 Console.WriteLine("request handled in ConcreteHandler3");
 72             }
 73             else 
 74             {
 75                 // not handled here - pass on to next in the chain
 76                 if (successorHandler != null)
 77                     successorHandler.HandleRequest(request);
 78             }        
 79         }
 80     }
 81 
 82     class Request 
 83     {
 84         private int iRequestType;
 85         private string strRequestParameters;
 86 
 87         public Request(int requestType, string requestParameters)
 88         {
 89             iRequestType = requestType;    
 90             strRequestParameters = requestParameters;
 91         }
 92 
 93         public int RequestType 
 94         {
 95             get 
 96             {
 97                 return iRequestType;
 98             }
 99             set 
100             {
101                 iRequestType = value;
102             }
103         }
104     }
105 
106     /// <summary>
107 ///    Summary description for Client.
108 /// </summary>
109     public class Client
110     {
111         public static int Main(string[] args)
112         {
113             // Set up chain (usually one need to be done once)
114             Handler firstHandler = new ConcreteHandler1();
115             Handler secondHandler = new ConcreteHandler2();
116             Handler thirdHandler = new ConcreteHandler3();
117             firstHandler.SetSuccessor(secondHandler);
118             secondHandler.SetSuccessor(thirdHandler);
119 
120             // After setting up the chain of responsibility, we can
121 // now generate requests and pass then off to the 
122 // chain to be handled
123 
124 // generate and fire request
125             Request newRequest = new Request(2,"This are the request parameters");
126             firstHandler.HandleRequest(newRequest);
127             
128             return 0;
129         }
130     }
131 }