一、概述

责任链设计模式: 注重封装对象责任，支持责任的变化，通过动态构建职责链，实现业务处理。

简单的来说：就是把业务中与主体业务只要稍微带点不稳定因素的代码，都抛出给别的方法去执行。

二、示例

需求：我输入一个数字，判断数字大小执行不同的逻辑。

1、普通写法： 直接在接口中通过if elseif else 去写。

代码如下：

    [HttpGet]
    public string Get(int num)
    {
        //原逻辑
        if (num <= 10)
        {
            Console.WriteLine("我是小于10的数");
        }
        else if (num <= 20)
        {
            Console.WriteLine("我是小于20的数");
        }
        else if (num <= 30)
        {
            Console.WriteLine("我是小于30的数");
        }
        else if (num <= 40)
        {
            Console.WriteLine("我是小于20的数");
        }
        else
        {
            Console.WriteLine("我是大于40的数");
        }
        return "";
    }
    
    

2、责任链设计模式思想写法: 创建抽象类，具体实现对象去实现不同的执行逻辑。

代码如下:

/// <summary>
/// 责任链设计模式抽象类
/// </summary>
public abstract class ChainOfResponsibilityContext
{
    public int Num { get; set; }

    /// <summary>
    /// 大小判断抽象方法
    /// </summary>
    /// <param name="num"></param>
    public abstract void Adujit(int num);

    /// <summary>
    /// 存储下一个逻辑判断
    /// </summary>
    private ChainOfResponsibilityContext _NextAdujit = null;

    //设置下一个逻辑判断是谁
    public void SetNext(ChainOfResponsibilityContext data)
    {
        this._NextAdujit = data; 
    }

    /// <summary>
    ///继续下一个逻辑判断
    /// </summary>
    /// <param name="num"></param>
    protected void AdujitNext(int num)
    {
        if (this._NextAdujit != null)
        {
            this._NextAdujit.Adujit(num);
        }
        else
        {
            Console.WriteLine("我是大于40的数");
        }
    }
}

/// <summary>
/// 判断10区间的类
/// </summary>
public class Ten : ChainOfResponsibilityContext
{
    public override void Adujit(int num)
    {
        if (num <= this.Num)
        {
            Console.WriteLine("我是小于10的数");
        }
        else
        {
            base.AdujitNext(num);
        }
    }
}
/// <summary>
/// 判断20区间的类
/// </summary>
public class Twenty : ChainOfResponsibilityContext
{
    public override void Adujit(int num)
    {
        if (num <= this.Num)
        {
            Console.WriteLine("我是小于20的数");
        }
        else
        {
            base.AdujitNext(num);
        }
    }
}
/// <summary>
/// 判断30区间的类
/// </summary>
public class Thirty : ChainOfResponsibilityContext
{
    public override void Adujit(int num)
    {
        if (num <= this.Num)
        {
            Console.WriteLine("我是小于30的数");
        }
        else
        {
            base.AdujitNext(num);
        }
    }
}
/// <summary>
/// 判断40区间的类
/// </summary>
public class Forty : ChainOfResponsibilityContext
{
    public override void Adujit(int num)
    {
        if (num <= this.Num)
        {
            Console.WriteLine("我是小于40的数");
        }
        else
        {
            base.AdujitNext(num);
        }
    }
}

/// <summary>
/// 具体实现判断逻辑类
/// </summary>
public class AllContext
{
    public static ChainOfResponsibilityContext Buid(int num)
    {

        ChainOfResponsibilityContext context = new Ten()
        {
            Num = 10
        };
        ChainOfResponsibilityContext context1 = new Twenty()
        {
            Num = 20
        };
        ChainOfResponsibilityContext context2 = new Thirty()
        {
            Num = 30
        };
        ChainOfResponsibilityContext context3 = new Forty()
        {
            Num = 40
        };
        //设置10判断之后为20
        context.SetNext(context1);
        //设置20判断之后为30
        context1.SetNext(context2);
        //设置30判断之后为40
        context2.SetNext(context3);

        return context;
    }
}

三、代码调用

我在这里写了一个接口，去掉用具体判断逻辑的实现方法，并且这个业务中还会有自己的代码

[HttpGet]
public string Get(int num)
{
    Console.WriteLine();
    ChainOfResponsibilityContext context = AllContext.Buid(num);
    context.Adujit(num);
    return "";
}

如图所示: 可以看到我们输入的数字 跟我们需求 要求的是一样的，完全的执行了判断逻辑，并且如果有新的需求只需要修改具体实现类的判断顺序即可，并不会影响到主体代码业务逻辑的执行。

以上就是我了解到行为型设计模式的巅峰之作————"责任链模式"的简单示例，大家有更好的见解，欢迎到评论区讨论！！！