.NET Core 5.0中基于自定义注解实现无侵入式方法超时监控与终止的技术方案问询

刚好之前做过类似的需求，在.NET Core 5.0里用AOP（面向切面编程）+自定义注解就能完美解决你的问题——完全不用修改目标方法（比如你的A()）的任何内部代码，只需要加个注解就能实现超时监控、超时抛异常并终止执行的效果。下面是具体的实现步骤和示例：

1. 先装依赖包 #

首先得装个轻量级的AOP框架，AspectCore.Extensions.DependencyInjection对.NET Core支持很友好，直接在NuGet包管理器里搜这个安装，或者用命令行：

Install-Package AspectCore.Extensions.DependencyInjection

2. 定义自定义超时注解 #

先写一个自定义的Attribute，用来标记需要监控超时的方法，还能指定超时时间：

using System;

[AttributeUsage(AttributeTargets.Method)]
public class TimeoutAttribute : Attribute
{
    // 超时时间（单位：秒）
    public int Seconds { get; set; }

    public TimeoutAttribute(int seconds)
    {
        Seconds = seconds;
    }
}

3. 实现超时拦截器核心逻辑 #

接下来写一个拦截器，这是实现超时监控的关键。它会在目标方法执行前后切入，异步监控执行时长，超时就抛异常：

using AspectCore.DynamicProxy;
using System;
using System.Threading;
using System.Threading.Tasks;

public class TimeoutInterceptor : AbstractInterceptor
{
    public override async Task Invoke(AspectContext context, AspectDelegate next)
    {
        // 先拿到方法上的超时注解，如果没有就直接执行方法
        var timeoutAttr = context.Method.GetCustomAttribute<TimeoutAttribute>();
        if (timeoutAttr == null)
        {
            await next(context);
            return;
        }

        // 创建取消令牌源，设置好超时时间
        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(timeoutAttr.Seconds));
        var token = cts.Token;

        try
        {
            // 同时监控目标方法执行和超时事件
            var task = next(context);
            var completedTask = await Task.WhenAny(task, Task.Delay(Timeout.Infinite, token));

            if (completedTask == task)
            {
                // 方法正常跑完，等着拿结果就行
                await task;
            }
            else
            {
                // 超时了！直接抛超时异常
                throw new TimeoutException($"方法 {context.Method.Name} 执行超时，超过设定的 {timeoutAttr.Seconds} 秒");
            }
        }
        catch (OperationCanceledException)
        {
            // 捕获取消令牌的异常，转成超时异常抛出
            throw new TimeoutException($"方法 {context.Method.Name} 执行超时，超过设定的 {timeoutAttr.Seconds} 秒");
        }
    }
}

这里要提个注意点：如果你的A()方法本身不支持CancellationToken，强制终止线程会有资源泄漏的风险。如果A()能接受取消令牌，最好是在拦截器里注入令牌，但你说不能改方法内部，那这个方案会标记超时并抛异常，但没法完全强制终止正在执行的方法（不过调用方可以通过捕获异常来中断后续处理）。

4. 配置AOP让注解生效 #

在Program.cs里配置一下AspectCore，把拦截器和我们的自定义注解关联起来：

using AspectCore.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;
using System;

class Program
{
    static void Main(string[] args)
    {
        var services = new ServiceCollection();

        // 先注册你的服务（假设A()方法在ISampleService里）
        services.AddScoped<ISampleService, SampleService>();

        // 配置AspectCore，让所有标记了TimeoutAttribute的方法都用我们的拦截器
        services.ConfigureDynamicProxy(config =>
        {
            config.Interceptors.AddTyped<TimeoutInterceptor>(method => method.IsDefined(typeof(TimeoutAttribute)));
        });

        // 构建AspectCore的服务提供器
        var serviceProvider = services.BuildAspectCoreServiceProvider();

        // 测试调用
        var sampleService = serviceProvider.GetRequiredService<ISampleService>();
        try
        {
            sampleService.A();
        }
        catch (TimeoutException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

// 示例的服务和目标方法A()
public interface ISampleService
{
    void A();
}

public class SampleService : ISampleService
{
    // 给A()加个超时注解，设置3秒超时
    [Timeout(3)]
    public void A()
    {
        // 模拟耗时操作，比如跑5秒
        Thread.Sleep(5000);
        Console.WriteLine("方法A执行完成");
    }
}

5. 测试效果 #

运行代码后，你会发现A()执行到3秒的时候，直接抛出超时异常，不会输出"方法A执行完成"——完美实现了你要的超时监控和终止效果，而且完全没碰A()的内部代码！

最后再划个重点 #

• 完全无侵入：只需要给目标方法加个[Timeout(xx)]注解就行，不用改一行方法内部代码。
• 异步监控：拦截器用Task.WhenAny异步监控，不会阻塞主线程。
• 异常统一：超时后抛出标准的TimeoutException，方便你在调用方统一处理超时逻辑。

内容的提问来源于stack exchange，提问作者H.S