当前位置：首页 > article >正文

C# 责任链模式全面讲解：设计思想与实际应用

article 2025/3/30 0:56:42

引言

在软件设计中，经常会遇到这样一种情形：一个请求需要经过多个处理对象的处理，而这些处理对象往往是可扩展的，并且不一定每个请求都需要所有的处理者。此时，责任链模式（Chain of Responsibility Pattern） 就能够提供一种灵活的解决方案。

责任链模式是一种行为型设计模式，它通过将请求沿着一条链传递的方式，让多个处理对象有机会处理请求，直到有一个对象能够处理该请求为止。这样就避免了请求的发送者与具体处理对象之间的紧密耦合。

本文将详细介绍责任链模式的原理、结构、实现以及适用场景。

1. 责任链模式的定义

责任链模式定义了一个请求的处理链，每个处理者都可以决定是否处理这个请求。如果当前处理者不能处理这个请求，它会将请求转发给链中的下一个处理者，直到有一个处理者能够处理该请求为止。通过这种方式，客户端不需要知道具体的处理者是谁，也不需要与具体的处理者进行交互。

责任链模式的基本组成

责任链模式通常包含以下几个角色：

Handler（处理者）：声明一个处理请求的接口，并持有指向下一个处理者的引用。它接收请求并决定是否处理，若不能处理，则将请求传递给链中的下一个处理者。
ConcreteHandler（具体处理者）：具体的处理者类，负责处理请求。每个具体处理者可以决定是否处理请求，如果无法处理，就将请求传递给下一个处理者。
Client（客户端）：发送请求的对象，客户端通过调用链上的处理者来处理请求，而不需要知道请求是由哪一个具体的处理者处理的。

责任链模式的结构图

           +------------------+
           |      Client      |
           +------------------+
                    |
                    |
           +------------------+  
           |     Handler      | <----+
           +------------------+      |
                    |               |
                    |               |
           +------------------+      |
           | ConcreteHandlerA |      |
           +------------------+      |
                    |               |
                    |               |
           +------------------+      |
           | ConcreteHandlerB |      |
           +------------------+      |
                    |               |
                    |               |
           +------------------+      |
           | ConcreteHandlerC |      |
           +------------------+      |

如图所示，客户端发出的请求通过责任链中的每个处理者依次传递，直到有处理者能够处理该请求为止。

2. 责任链模式的实现

责任链模式的核心思想是将请求传递给链中的处理者，而每个处理者只负责处理自己能够处理的部分。如果处理者不能处理，就将请求传递给下一个处理者。

下面是一个 C# 中实现责任链模式的例子。

示例代码

using System;

// 抽象处理者类
public abstract class Handler
{
    protected Handler _nextHandler;

    // 设置下一个处理者
    public void SetNext(Handler nextHandler)
    {
        _nextHandler = nextHandler;
    }

    // 处理请求的方法
    public abstract void HandleRequest(int request);
}

// 具体处理者A
public class ConcreteHandlerA : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 0 && request < 10)
        {
            Console.WriteLine("ConcreteHandlerA 处理请求: " + request);
        }
        else if (_nextHandler != null)
        {
            _nextHandler.HandleRequest(request);
        }
    }
}

// 具体处理者B
public class ConcreteHandlerB : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 10 && request < 20)
        {
            Console.WriteLine("ConcreteHandlerB 处理请求: " + request);
        }
        else if (_nextHandler != null)
        {
            _nextHandler.HandleRequest(request);
        }
    }
}

// 具体处理者C
public class ConcreteHandlerC : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 20)
        {
            Console.WriteLine("ConcreteHandlerC 处理请求: " + request);
        }
        else if (_nextHandler != null)
        {
            _nextHandler.HandleRequest(request);
        }
    }
}

// 客户端代码
class Program
{
    static void Main(string[] args)
    {
        // 创建处理者
        var handlerA = new ConcreteHandlerA();
        var handlerB = new ConcreteHandlerB();
        var handlerC = new ConcreteHandlerC();

        // 构建责任链
        handlerA.SetNext(handlerB);
        handlerB.SetNext(handlerC);

        // 客户端发出请求
        Console.WriteLine("发送请求: 5");
        handlerA.HandleRequest(5);  // ConcreteHandlerA 处理请求: 5

        Console.WriteLine("发送请求: 15");
        handlerA.HandleRequest(15); // ConcreteHandlerB 处理请求: 15

        Console.WriteLine("发送请求: 25");
        handlerA.HandleRequest(25); // ConcreteHandlerC 处理请求: 25
    }
}

代码解析

Handler 类：这是一个抽象类，声明了一个处理请求的方法 HandleRequest 和一个指向下一个处理者的引用 _nextHandler。SetNext 方法用来设置责任链中的下一个处理者。
ConcreteHandler 类：这是多个具体的处理者类，每个类负责处理不同范围的请求。例如，ConcreteHandlerA 只处理值在 [0, 10) 之间的请求，ConcreteHandlerB 处理值在 [10, 20) 之间的请求，ConcreteHandlerC 处理值大于等于 20 的请求。如果某个处理者不能处理该请求，它会将请求传递给下一个处理者。
客户端代码：客户端构建了责任链，并发送请求到链中的第一个处理者。如果第一个处理者不能处理请求，它会将请求传递给下一个处理者。

处理流程

请求值为 5 时，ConcreteHandlerA 会处理该请求。
请求值为 15 时，ConcreteHandlerA 无法处理该请求，将请求传递给 ConcreteHandlerB，后者处理了该请求。
请求值为 25 时，ConcreteHandlerA 和 ConcreteHandlerB 都无法处理，最终请求被 ConcreteHandlerC 处理。