C#面向对象设计模式纵横谈 学习笔记20 Chain of Responsibility职责链模式（行为型模式）

动机：
在软件构建过程中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，如果显示指定，将必不可少的带来请求发送者与接受者的紧耦合。必须是请求的发送者不需要指定具体的接受者，让请求的接受者自己在运行时决定来处理请求，从而使两者解藕。

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

1. public abstract class BaseHandler
2.     {
3.         public BaseHandler(BaseHandler next)
4.         {
5.             this.next = next;
6.         }
7.         
8.         public virtual void HandleRequest(Request request)
9.         {
10.             if(next != null)
11.             {
12.                 this.next.HandleRequest(request);
13.             }
14.         }
15.         public abstract bool CanHandleRequest();
16.        
17.         
18.         private BaseHandler next;
19.         
20.         public BaseHandler Next
21.         {
22.             get
23.             {
24.                 return this.next;
25.             }
26.             set
27.             {
28.                 this.next = value;
29.             }
30.         }
31.     }
32.     
33.     public class AHandler : BaseHandler
34.     {
35.         public AHandler(BaseHandler next) : base(next)
36.         {
37.         }
38.         
39.         public override void HandleRequest(Request request)
40.         {
41.             if(this.CanHandleRequest())
42.             {
43.                 //处理
44.             }
45.             else
46.             {
47.                 base.HandleRequest(request);
48.             }
49.         }
51.         public override bool CanHandleRequest()
52.         {
53.             return false;
54.         }
55.     }
56.     
57.     public class BHandler : BaseHandler
58.     {
59.         public BHandler(BaseHandler next) : base(next)
60.         {
61.         }
62.         
63.         public override void HandleRequest(Request request)
64.         {
65.             if(this.CanHandleRequest())
66.             {
67.                 //处理
68.             }
69.             else
70.             {
71.                 base.HandleRequest(request);
72.             }
73.         }
76.         public override bool CanHandleRequest()
77.         {
78.             return true;
79.         }
80.     }
81.     
82.     public class CHandler : BaseHandler
83.     {
84.         public CHandler(BaseHandler next) : base(next)
85.         {
86.         }
87.         
88.         public override void HandleRequest(Request request)
89.         {
90.             if(this.CanHandleRequest())
91.             {
92.                 //处理
93.             }
94.             else
95.             {
96.                 base.HandleRequest(request);
97.             }
98.         }
100.         public override bool CanHandleRequest()
101.         {
102.             return true;
103.         }
104.     }
105.     
106.     public class Request
107.     {
108.     }
109.     
110.     public class Sender
111.     {
112.         public void Process(BaseHandler handler)
113.         {
114.             Request request = new Request();
115.             
116.             
117.             
118.             handler.HandleRequest(request);
119.             
120.             //ArrayList list = new ArrayList();
121.             //list.Add(new AHandler());
122.             //list.Add(new BHandler());
123.             //list.Add(new CHandler());
124.             
125.             //foreach(BaseHandler handler in list)
126.             //{
127.             //    if(handler.CanHandleRequest())
128.             //    {
129.             //        handler.HandleRequest(request);
130.             //    }
131.             //}
132.         }
133.     }
134.     
135.     class Program
136.     {
137.         static void Main(string[] args)
138.         {
139.             Sender sender = new Sender();
140.             BaseHandler handler1 = new AHandler(null);
141.             BaseHandler handler2 = new BHandler(handler1);
142.             BaseHandler handler3 = new CHandler(handler2);
143.             
144.             sender.Process(handler3);
145.         }
146.     }

可以看到上面的代码，我们抽象出来BaseHandler类，作为处理类的基类，类里有一个虚方法HandleRequest，实现为将请求交个下一个Handler去处理，还有一个纯虚方法CanHandleRequest，用来判断是否当前Handler能否处理请求。next作为一个引用（指针）用来保存下一个处理器的地址。我们设计的思路就是构造一个像链表的处理器链，通过next指针连接起来。那么继承BaseHandler的A、B、C三个handler重写了CanHandleRequest和HandleRequest方法，CanHandleRequest方法用来判断当前Handler能否处理消息，HandleRequest方法首先判断当前Handler能否处理，如果能处理就自己处理，如果不能处理就交给下一个Handler处理。在Main函数里，我们实例化三个Handler,并且将他们链接起来。

要点：

Chain of Responsibility模式的应用场合在于一个请求可能有多个接受者，但是最后真正的接受者只有一个，只有这个时候请求发送者与接受者的耦合才可能出现变化脆弱的症状，职责链的目的就是将两者解藕，从而更好的应对变化。
应用了Chain of Resposibility模式后，对象的职责分派将更具有灵活性，我们可以在运行时动态添加/修改请求的处理职责，就是说我们可以动态的给职责链里插入Handler
如果请求传递到职责链的末尾仍得不到处理，应该有一个合理的缺省机制，这也是每一个接受对象的责任，而不是发出请求的对象的责任。
我们可以将职责链看作一个由很多小Handler组成的大Handler，他可以随时添加小的Handler，可以有默认处理的Handler，并且可以根据各种不同的条件来将消息给不同的小Handler处理。
但在windows消息循环中，没有用到职责链模式，因为消息循环需要快速的响应，并且，消息循环的消息种类太多，如果消息种类组成的职责链会相当的庞大，那么整个消息循环的机制会非常缓慢