定义

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

使用场景

1. 典型的就是公司业务办理，如果业务不能办理就交由上级办理
2. JS 中的事件冒泡
3. 红楼梦中的"击鼓传花"

关键点在于一件事，多个对象都能处理，但是处理存在优先级

代码实现

//接收者抽象类
abstract class Handler
{
     protected Handler successor; //下个接收对象

     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 <= 10)
          {
                Console.Write("ConcreteHandler1 处理了请求");
          }
          else if(successor != null)
          {
               successor.HandleRequest(request);
          }
    }
}

class ConcreteHandler2 : Handler
{
    public override void HandleRequest(int request)
    {
          if(request > 10 && request <= 20)
          {
                Console.Write("ConcreteHandler2 处理了请求");
          }
          else if(successor != null)
          {
               successor.HandleRequest(request);
          }
    }
}

class ConcreteHandler3 : Handler
{
    public override void HandleRequest(int request)
    {
          if(request > 20 && request <= 30)     //可能接收请求
          {
                Console.Write("ConcreteHandler3 处理了请求");
          }
          else if(successor != null)
          {
               successor.HandleRequest(request);
          }
    }
}


void Main()
{
     Handler h1 = new Handler();
     Handler h2 = new Handler();
     Handler h3 = new Handler();

    //设置职责链 
    h1.SetSuccessor(h2);
    h2.SetSuccessor(h3);
    
    int request = 15;
    
    h1.HandleRequest(request);

}

优点与缺点

1. 降低耦合度，它将请求发送者 和 接收者（逻辑上没有相互关联，只有调用顺序由客户掌控） 解耦
2. 简化对象，对象不需要知道链的结构
3. 增强了指派职责的灵活性，链中成员调用顺序由客户掌控
4. 增加新的请求处理类也方便
5. 请求不能保证一定被接收，指派接收者链顺序要特别注意
6. 调试不方便，除错不方便，也可能造成循环调用