C#职责链模式实例详解

什么是职责链模式

职责链模式是一种行为型设计模式，它允许您将请求沿着处理链进行传递，直到它被处理为止。职责链模式由以下角色组成：

• 抽象处理程序：定义用于处理请求的通用接口，并保存指向其后继者的引用。
• 具体处理程序：处理它所能处理的请求，可以访问其后继者，并向后继者委派无法处理的请求。
• 客户端：将请求发送到处理程序以处理它。

具体的职责链模式的实现可以根据实际需求的不同而变化，但模式的结构通常是相似的。

C#职责链模式实现攻略

在C#中，可以通过以下步骤实现职责链模式：

1. 创建抽象处理程序的接口，并定义处理请求的方法和保存后继者的引用的属性。

public interface IHandler
{
IHandler Successor { get; set; }
string HandleRequest(double request);
}

1. 创建具体处理程序的类，并实现抽象处理程序接口，处理它所能处理的请求，并向后继者委派无法处理的请求。在实现中，可以根据实际需求的不同，对处理逻辑进行修改。

```
public class ConcreteHandler1 : IHandler
{
public IHandler Successor { get; set; }

   public string HandleRequest(double request)
   {
       if (request < 0.5)
       {
           return "ConcreteHandler1 handled the request.";
       }
       else
       {
           return Successor.HandleRequest(request);
       }
   }

}
```

1. 在客户端代码中，创建具体处理程序的链，并将请求发送到处理程序以处理它。

```
var handler1 = new ConcreteHandler1();
var handler2 = new ConcreteHandler2();

handler1.Successor = handler2;

Console.WriteLine(handler1.HandleRequest(0.2));
```

实例1：经典面向对象设计问题

以下是一个经典的面向对象设计问题，可以用职责链模式来解决它。

假设有一个发票处理系统，根据发票的金额，需要选择不同的处理方式。对于发票金额小于100元的发票，由普通处理器进行处理；对于100元到1000元之间的发票，由中级处理器进行处理；对于大于1000元的发票，由高级处理器进行处理。

按照职责链模式的设计思路，可以创建一个IHandler接口作为抽象处理程序，然后创建具体处理程序来处理不同金额区间的发票，并将它们链接成处理程序链。

以下是实现的代码：

// 抽象处理程序接口
public interface IHandler
{
    IHandler Successor { get; set; }
    string HandleRequest(double request);
}

// 具体处理程序：处理1000元以上的发票
public class ExpertHandler : IHandler
{
    public IHandler Successor { get; set; }

    public string HandleRequest(double request)
    {
        if (request > 1000)
        {
            return "ExpertHandler handled the request.";
        }
        else
        {
            return Successor.HandleRequest(request);
        }
    }
}

// 具体处理程序：处理100元到1000元的发票
public class SeniorHandler : IHandler
{
    public IHandler Successor { get; set; }

    public string HandleRequest(double request)
    {
        if (request >= 100 && request <= 1000)
        {
            return "SeniorHandler handled the request.";
        }
        else
        {
            return Successor.HandleRequest(request);
        }
    }
}

// 具体处理程序：处理小于100元的发票
public class JuniorHandler : IHandler
{
    public IHandler Successor { get; set; }

    public string HandleRequest(double request)
    {
        if (request < 100)
        {
            return "JuniorHandler handled the request.";
        }
        else
        {
            return Successor.HandleRequest(request);
        }
    }
}

客户端代码可以这样写：

var junior = new JuniorHandler();
var senior = new SeniorHandler();
var expert = new ExpertHandler();

junior.Successor = senior;
senior.Successor = expert;

Console.WriteLine(junior.HandleRequest(50));       // JuniorHandler handled the request.
Console.WriteLine(junior.HandleRequest(500));      // SeniorHandler handled the request.
Console.WriteLine(junior.HandleRequest(5000));     // ExpertHandler handled the request.

实例2：请求静态文件

以下是另一个示例：使用职责链模式来请求静态文件。这个例子很简单，但足以说明职责链模式的优势。

实现的代码如下：

// 抽象处理程序接口
public interface IRequestHandler
{
    IRequestHandler Successor { get; set; }
    string HandleRequest(string request);
}

// 具体处理程序：请求css文件
public class CssRequestHandler : IRequestHandler
{
    public IRequestHandler Successor { get; set; }

    public string HandleRequest(string request)
    {
        if (request.EndsWith(".css", StringComparison.OrdinalIgnoreCase))
        {
            return "Handling css request";
        }
        else
        {
            return Successor.HandleRequest(request);
        }
    }
}

// 具体处理程序：请求js文件
public class JsRequestHandler : IRequestHandler
{
    public IRequestHandler Successor { get; set; }

    public string HandleRequest(string request)
    {
        if (request.EndsWith(".js", StringComparison.OrdinalIgnoreCase))
        {
            return "Handling js request";
        }
        else
        {
            return Successor.HandleRequest(request);
        }
    }
}

// 具体处理程序：请求html文件
public class HtmlRequestHandler : IRequestHandler
{
    public IRequestHandler Successor { get; set; }

    public string HandleRequest(string request)
    {
        if (request.EndsWith(".html", StringComparison.OrdinalIgnoreCase))
        {
            return "Handling html request";
        }
        else
        {
            return Successor.HandleRequest(request);
        }
    }
}

客户端代码可以这样写：

var cssHandler = new CssRequestHandler();
var jsHandler = new JsRequestHandler();
var htmlHandler = new HtmlRequestHandler();

cssHandler.Successor = jsHandler;
jsHandler.Successor = htmlHandler;

Console.WriteLine(cssHandler.HandleRequest("style.css"));            // Handling css request
Console.WriteLine(cssHandler.HandleRequest("script.js"));            // Handling js request
Console.WriteLine(cssHandler.HandleRequest("index.html"));           // Handling html request
Console.WriteLine(cssHandler.HandleRequest("page.aspx"));            // Unhandled request

总结

职责链模式是一种强大的设计模式，它允许您将请求沿着处理链进行传递，直到它被处理为止，从而使您的代码更加灵活和可扩展。在C#中，职责链模式的实现通常包括抽象处理程序接口、具体处理程序类和客户端代码。