C#设计模式之职责链模式示例详解

什么是职责链模式

职责链模式是一种行为型模式，它能够将一个请求沿着多个对象链状传递，直到有一个对象处理该请求为止。这样的设计模式可以避免请求发送者与接收者之间的耦合，使得多个对象都有可能接收请求并处理它。

职责链模式的结构

这种模式通常包含一个抽象的处理者类，多个具体的处理者类，每个处理者类都包括一个指向下一个处理者的引用，一般情况下，责任链中的处理者对象都包含相同类型的操作。

职责链模式的示例

下面，我们将使用一些实际的例子来展示职责链模式的用法。首先，我们考虑一个文件上传的场景。在这种情况下，我们只允许上传特定类型的文件，例如图片、文本、音频、视频等等。

public abstract class UploadHandler
{
    protected UploadHandler _nextHandler;

    public void SetNextHandler(UploadHandler handler)
    {
        this._nextHandler = handler;
    }

    public abstract bool Handle(string fileType);
}

我们定义了一个抽象的上传处理者类UploadHandler，其中包括一个指向下一个处理者的引用，还有一个抽象的Handle方法用于处理上传的文件。下面为我们实现具体的上传处理者类。

public class ImageUploadHandler : UploadHandler
{
    public override bool Handle(string fileType)
    {
        if(fileType == "jpg" || fileType == "png")
        {
            Console.WriteLine("处理了图片文件！");
            return true;
        }
        if(this._nextHandler != null)
        {
            return this._nextHandler.Handle(fileType);
        }
        Console.WriteLine("不支持的文件类型！");
        return false;
    }
}

public class TextUploadHandler : UploadHandler
{
    public override bool Handle(string fileType)
    {
        if(fileType == "txt" || fileType == "doc")
        {
            Console.WriteLine("处理了文本文件！");
            return true;
        }
        if(this._nextHandler != null)
        {
            return this._nextHandler.Handle(fileType);
        }
        Console.WriteLine("不支持的文件类型！");
        return false;
    }
}

public class AudioUploadHandler : UploadHandler
{
    public override bool Handle(string fileType)
    {
        if(fileType == "mp3" || fileType == "wav")
        {
            Console.WriteLine("处理了音频文件！");
            return true;
        }
        if(this._nextHandler != null)
        {
            return this._nextHandler.Handle(fileType);
        }
        Console.WriteLine("不支持的文件类型！");
        return false;
    }
}

public class VideoUploadHandler : UploadHandler
{
    public override bool Handle(string fileType)
    {
        if(fileType == "mp4" || fileType == "avi")
        {
            Console.WriteLine("处理了视频文件！");
            return true;
        }
        if(this._nextHandler != null)
        {
            return this._nextHandler.Handle(fileType);
        }
        Console.WriteLine("不支持的文件类型！");
        return false;
    }
}

我们实现了四个不同类型的上传处理者类，每个类都重写了Handle方法，用于检查文件类型并处理上传的文件。如果有下一个处理者，则向下传递，否则返回不支持的文件类型。

最后，我们将实现一个用于测试的客户端类。

static void Main(string[] args)
{
    ImageUploadHandler imageHandler = new ImageUploadHandler();
    TextUploadHandler textHandler = new TextUploadHandler();
    AudioUploadHandler audioHandler = new AudioUploadHandler();
    VideoUploadHandler videoHandler = new VideoUploadHandler();

    imageHandler.SetNextHandler(textHandler);
    textHandler.SetNextHandler(audioHandler);
    audioHandler.SetNextHandler(videoHandler);

    Console.WriteLine(imageHandler.Handle("png"));
    Console.WriteLine(imageHandler.Handle("doc"));
    Console.WriteLine(imageHandler.Handle("mp3"));
    Console.WriteLine(imageHandler.Handle("mp4"));
    Console.WriteLine(imageHandler.Handle("xlsx"));
}

在这个测试客户端中，我们首先创建了四个上传处理者类的实例。然后，我们设置它们的处理顺序，并且将第一个处理者传递给客户端。最后，我们将测试多个文件的上传类型，每个文件都会经过一个处理者并返回结果，如果某个文件类型没有被处理，则会返回不支持的文件类型。

另一个职责链模式的示例

职责链模式的另一个示例是实现在线支付的场景。在这个场景中，我们需要使用多个支付方式，例如信用卡、支付宝、微信支付、银行转账等等。

abstract class PaymentHandler
{
    protected PaymentHandler _nextHandler;

    public void SetNextHandler(PaymentHandler handler)
    {
        this._nextHandler = handler;
    }

    public abstract bool Handle(double amount);
}

我们定义了一个抽象的支付处理者类PaymentHandler，其中包括一个指向下一个处理者的引用，还有一个抽象的Handle方法用于处理支付请求。下面为我们实现具体的支付处理者类。

public class CreditCardHandler : PaymentHandler
{
    public override bool Handle(double amount)
    {
        if(amount <= 1000)
        {
            Console.WriteLine("使用信用卡支付了 {0} 元", amount);
            return true;
        }
        if(this._nextHandler != null)
        {
            return this._nextHandler.Handle(amount);
        }
        Console.WriteLine("支付金额过大！");
        return false;
    }
}

public class AlipayHandler : PaymentHandler
{
    public override bool Handle(double amount)
    {
        if(amount <= 500)
        {
            Console.WriteLine("使用支付宝支付了 {0} 元", amount);
            return true;
        }
        if(this._nextHandler != null)
        {
            return this._nextHandler.Handle(amount);
        }
        Console.WriteLine("支付金额过大！");
        return false;
    }
}

public class WechatPayHandler : PaymentHandler
{
    public override bool Handle(double amount)
    {
        if(amount <= 300)
        {
            Console.WriteLine("使用微信支付了 {0} 元", amount);
            return true;
        }
        if(this._nextHandler != null)
        {
            return this._nextHandler.Handle(amount);
        }
        Console.WriteLine("支付金额过大！");
        return false;
    }
}

public class BankTransferHandler : PaymentHandler
{
    public override bool Handle(double amount)
    {
        Console.WriteLine("使用银行转账支付了 {0} 元", amount);
        return true;
    }
}

我们实现了四个不同类型的支付处理者类，每个类都重写了Handle方法，用于检查支付金额并处理支付请求。如果有下一个处理者，则向下传递，否则返回支付金额过大。

最后，我们将实现一个用于测试的客户端类。

static void Main(string[] args)
{
    CreditCardHandler creditCardHandler = new CreditCardHandler();
    AlipayHandler alipayHandler = new AlipayHandler();
    WechatPayHandler wechatPayHandler = new WechatPayHandler();
    BankTransferHandler bankTransferHandler = new BankTransferHandler();

    creditCardHandler.SetNextHandler(alipayHandler);
    alipayHandler.SetNextHandler(wechatPayHandler);
    wechatPayHandler.SetNextHandler(bankTransferHandler);

    Console.WriteLine(creditCardHandler.Handle(100));
    Console.WriteLine(creditCardHandler.Handle(600));
    Console.WriteLine(creditCardHandler.Handle(400));
    Console.WriteLine(creditCardHandler.Handle(2000));
}

在这个测试客户端中，我们首先创建了四个支付处理者类的实例。然后，我们设置它们的处理顺序，并且将第一个处理者传递给客户端。最后，我们将测试多个支付金额，每个支付请求都会经过一个处理者并返回结果，如果某个支付金额过大，则会返回支付金额过大。