责任链模式

责任链模式是一种行为设计模式，它允许多个对象处理请求，而无需指定处理请求的具体处理者。请求沿着链传递，直到有一个对象处理它为止。这种模式允许将请求的发送者和接收者解耦，并使多个对象都有机会处理请求。

以下是一个简单的责任链模式的示例代码：

using System;

// 抽象处理者
abstract class Handler
{
    protected Handler successor;

    public void SetSuccessor(Handler successor)
    {
        this.successor = successor;
    }

    public abstract void HandleRequest(int request);
}

// 具体处理者A
class ConcreteHandlerA : Handler
{
    public override void HandleRequest(int request)
    {
        if (request < 10)
        {
            Console.WriteLine("Request " + request + " handled by ConcreteHandlerA");
        }
        else if (successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

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

class Program
{
    static void Main()
    {
        // 创建具体处理者A和B
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        // 建立处理者链
        handlerA.SetSuccessor(handlerB);

        // 发送请求并在链上处理
        handlerA.HandleRequest(5);
        handlerA.HandleRequest(12);
        handlerA.HandleRequest(25);
    }
}

在上面的代码中，我们定义了一个抽象处理者 Handler 类，其中包含一个指向下一个处理者的引用 successor，并且有一个抽象方法 HandleRequest 用于处理请求。然后我们创建了两个具体处理者类 ConcreteHandlerA 和 ConcreteHandlerB，它们分别实现了处理请求的具体逻辑。

在 Main() 方法中，我们首先创建了具体处理者A和B，并将它们建立成了处理者链，即 A 处理不了的请求会传递给 B 处理。然后我们发送了几个请求，并通过责任链模式来处理这些请求。

责任链模式可以根据具体场景动态地组织处理者之间的关系，在系统中灵活地处理请求，且降低了发送者和接收者之间的耦合度。

扩展：避免死循环问题需要在末端加上终止条件

// 具体处理者C
class ConcreteHandlerC : Handler
{
    public override void HandleRequest(int request)
    {
        if (successor != null)
        {
            successor.HandleRequest(request);
        }
        else
        {
            Console.WriteLine("End of the chain - Request " + request + " cannot be handled");
        }
    }
}

class Program
{
    static void Main()
    {
        // 创建具体处理者A、B和C
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        // 建立处理者链
        handlerA.SetSuccessor(handlerB);
        handlerB.SetSuccessor(handlerC);

        // 发送请求并在链上处理
        handlerA.HandleRequest(5); // Request 5 handled by ConcreteHandlerA
        handlerA.HandleRequest(12); // Request 12 handled by ConcreteHandlerB
        handlerA.HandleRequest(25); // End of the chain - Request 25 cannot be handled
    }
}

在这个修改后的示例代码中，我们添加了一个新的具体处理者 ConcreteHandlerC，它并不实际处理请求，只是打印出一个结束消息。在处理者链的末端，我们让最后一个处理者 handlerC 不再调用后续的处理者，而是直接输出结束消息，表明请求无法被处理。当将超出所有处理者能力范围的请求发送到处理者链时，在这种情况下，处理者链能够正确地终止并指示该请求无法被处理。

通过添加适当的终止条件，我们可以有效避免责任链模式中的死循环问题，保证系统的稳定性和正确性。