• 简介
  使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
• 职责链的好处：
  • 当客户提交一个请求时，请求是沿链传递直至有一个 ConcreteHandler 对象负责处理它。
  • 链中的对象自己并不知道链的结果。结果是职责链可简化对象的相互连接，它们仅仅需要保持一个指向后继者的引用，而不需要保持它所有的后选接受者的引用。降低了耦合性。
  • 可以随时增加或者修改处理一个请求的结构，增强了给对象指派职责的灵活性。
• 弊端：
  • 一个请求可能到最后都没有被处理，需要考虑周全。
• 实现

abstract class Handler
{
    protected Handler successer;
    public void SetSuccessor(Handler successor){
        this.successor = successor;
    }
    public abstract void HandleRequest(int request);
}
/*
    具体处理类，处理它所负责的请求，可访问它的继承者而，如果可处理该请求，
    就处理之，否则就讲该请求转发给它的后继者。
*/
class ConcreteHandler1:Handler
{
    public override void HandleRequest(int request){
        if(request >=0&&request<10){
            Console.WriteLine("{0}处理请求{1}",this.GetType().Name,request);
        }else if(successor != null){
            successor.HandleRequest(request);
        }       
    }
}
class ConcreteHandler2 : Handler
{
    public override void HandleRequest(int request){
        if(request>=10 &&request <20){
            Console.WriteLine("{0}处理请求{1}",this.GetType().Name,request);
        }
        else if(successor !=null){
            successor.HandleRequest(request);
        }
    }
}
class ConcreteHandler3 : Handler
{
    public override void HandleRequest(int request){
        if(request>=20 &&request <30){
            Console.WriteLine("{0}处理请求{1}",this.GetType().Name,request);
        }
        else if(successor !=null){
            successor.HandleRequest(request);
        }
    }
}
static void Main(strings[] args){
        /*
          创建了三个处理者对象
          h1是第一个处理者
          h2被h1设置为下一个处理者
          h3被 h2设置为下一个处理者
          当请求符合哪个对象的处理条件，就会被当前对象处理。
        */
    Handler h1 = new ConcreteHandler1();
    Handler h2 = new ConcreteHandler2();
    Handler h3 = new ConcreteHandler3();
    h1.SetSuccessor(h2);
    h2.SetSuccessor(h3);
    int requests[] = {2,5,14,22,18,3,27,20};
    foreach(int request in requests)
    {
        h1.HandleRequest(request);
    }
}