asp.net-core - 覆盖默认的 asp.net 核心取消令牌或更改请求的默认超时

Question

在我的 asp.net core 5.0 应用程序中，我调用了一个可能需要一些时间来处理的异步方法。

 await someObject.LongRunningProcess(cancelationToken);

但是，我希望该方法在 5 秒后超时。我知道，我可以使用“CancellationTokenSource”，而不是 asp.net 核心操作传递的“cancelationToken”：

var s_cts = new CancellationTokenSource();
s_cts.CancelAfter(TimeSpan.FromSeconds(5);
    
await someObject.LongRunningProcess(s_cts );

是否可以将“ CancellationTokenSource ”用作所有 asp.net 核心请求的默认“取消令牌”策略？我的意思是覆盖作为动作参数传递的那个？

或者是否可以更改 asp.net core 5.0 中所有请求的默认超时？

[更新]

标签： asp.net-coreasynchronousasp.net-core-5.0cancellation-token

Answer 1

解决这个问题的一种方法是将该逻辑包装在一个类中。编写一个运行具有可配置超时的任务的类。

然后在 DI 中注册它，然后在任何你想重用配置的地方使用它。

public class TimeoutRunner
{
    private TimeoutRunnerOptions _options;

    public TimeoutRunner(IOptions<TimeoutRunnerOptions> options)
    {
        _options = options.Value;
    }

    public async Task<T> RunAsync<T>(Func<CancellationToken, Task<T>> runnable,
                                     CancellationToken cancellationToken = default)
    {
        // cancel the task as soon as one of the tokens is set
        var timeoutCts = new CancellationTokenSource();
        var token = timeoutCts.Token;
        if (cancellationToken != default)
        {
            timeoutCts.CancelAfter(_options.Timeout);
            var combinedCts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken);
            token = combinedCts.Token;
        }

        return await runnable(token);
    }
}

internal static class ServiceCollectionExtensions
{
    public static IServiceCollection AddTimeoutRunner(this IServiceCollection services,
                                                      Action<TimeoutRunnerOptions> configure = null)
    {
        if (configure != null)
        {
            services.Configure<TimeoutRunnerOptions>(configure);
        }

        return services.AddTransient<TimeoutRunner>();
    }
}

public class TimeoutRunnerOptions
{
    public int TimeoutSeconds { get; set; } = 10;
    public TimeSpan Timeout => TimeSpan.FromSeconds(TimeoutSeconds);
}

然后你会在 Startup 类中注册它，

public void ConfigureServices(IServiceCollection services)
{
    services.AddTimeoutRunner(options =>
    {
        options.TimeoutSeconds = 10;
    });
}

然后在需要该全局选项的任何地方使用它：

public class MyController : ControllerBase
{
    private TimeoutRunner _timeoutRunner;

    public MyController(TimeoutRunner timeoutRunner)
    {
        _timeoutRunner = timeoutRunner;
    }

    public async Task<IActionResult> DoSomething(CancellationToken cancellationToken)
    {
        await _timeoutRunner.RunAsync(
            async (CancellationToken token) => {
                await Task.Delay(TimeSpan.FromSeconds(20), token);
            },
            cancellationToken
        );
        return Ok();
    }
}

在每次动作调度之前运行一个任务

方法 1：动作过滤器

我们可以使用操作过滤器在每个请求之前/之后运行任务。

public class ApiCallWithTimeeotActionFilter : IAsyncActionFilter
{
    private TimeoutRunner _runner;

    public ApiCallWithTimeeotActionFilter(TimeoutRunner runner)
    {
        _runner = runner;
    }

    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        var result = await _runner.RunAsync(
            async (CancellationToken token) =>
            {
                await Task.Delay(TimeSpan.FromSeconds(20), token);
                return 42;
            },
            default
        );
        await next();
    }
}

然后使用它注释一个类[TypeFilter(typeof(MyAction))]：

[TypeFilter(typeof(ApiCallWithTimeeotActionFilter))]
public class MyController : ControllerBase { /* ... */ }

方法二：中间件

另一种选择是使用中间件

class ApiCallTimeoutMiddleware
{
    private TimeoutRunner _runner;

    public ApiCallTimeoutMiddleware(TimeoutRunner runner)
    {
        _runner = runner;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        // run a task before every request
        var result = await _runner.RunAsync(
            async (CancellationToken token) =>
            {
                await Task.Delay(TimeSpan.FromSeconds(20), token);
                return 42;
            },
            default
        );
        await next(context);
    }
}

然后在方法中附加中间件Startup.Configure：

public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware<ApiCallTimeoutMiddleware>();
    app.UseRouting();
    app.UseEndpoints(e => e.MapControllers());
}