如何用CancellationToken和Task.WhenAny实现Web服务并行调用的单任务超时取消

嘿，这个需求我之前也帮朋友处理过，在C#里用Task体系就能完美解决——核心是给每个Web服务调用单独设置独立的超时取消逻辑，这样单个任务超时被终止时，完全不会影响其他任务继续执行。下面给你一步步拆解实现方案：

我们要避免给所有并行任务加全局取消令牌，而是给每个Web服务调用分配独立的CancellationTokenSource，通过Task.WhenAny监听任务本身和超时延迟任务的完成状态，一旦超时就取消当前任务，同时让其他任务不受干扰地继续执行。

第一步：封装通用的带超时异步操作方法 #

先写一个复用性强的工具方法，给任意异步操作加上单独的超时取消逻辑：

public static async Task<T> WithTimeout<T>(Func<CancellationToken, Task<T>> operation, TimeSpan timeout)
{
    using var cts = new CancellationTokenSource();
    // 启动超时延迟任务
    var timeoutTask = Task.Delay(timeout, cts.Token);
    // 启动目标异步操作（传入取消令牌）
    var operationTask = operation(cts.Token);

    // 监听哪个任务先完成
    var completedTask = await Task.WhenAny(operationTask, timeoutTask);
    
    if (completedTask == timeoutTask)
    {
        // 超时触发：取消当前操作，抛出超时异常（也可以自定义返回结果/状态）
        cts.Cancel();
        throw new TimeoutException($"操作超时，超过{timeout.TotalSeconds}秒");
    }

    // 操作正常完成，返回结果
    return await operationTask;
}

这个方法的优势：

• 每个操作拥有独立的取消令牌，超时只影响自身
• 主动取消正在进行的Web请求（前提是底层调用支持取消，比如HttpClient的SendAsync）
• 逻辑清晰，可复用在任何需要单独超时的异步场景

第二步：并行调用多个Web服务 #

把你的各个Web服务调用用上面的方法包装，再通过Task.WhenAll并行执行，最后统一处理每个任务的结果或异常：

public async Task RunParallelServiceCalls()
{
    // 定义所有带5秒超时的Web服务任务
    var serviceTasks = new List<Task<object>>
    {
        WithTimeout(token => CallUserService(token), TimeSpan.FromSeconds(5)),
        WithTimeout(token => CallPaymentService(token), TimeSpan.FromSeconds(5)),
        WithTimeout(token => CallNotificationService(token), TimeSpan.FromSeconds(5))
    };

    // 等待所有任务完成（无论成功/失败）
    await Task.WhenAll(serviceTasks);

    // 逐个处理任务结果
    foreach (var task in serviceTasks)
    {
        if (task.Status == TaskStatus.RanToCompletion)
        {
            Console.WriteLine($"服务调用成功：{task.Result}");
        }
        else if (task.IsFaulted)
        {
            var innerEx = task.Exception.InnerException;
            if (innerEx is TimeoutException)
            {
                Console.WriteLine($"服务调用超时：{innerEx.Message}");
            }
            else
            {
                Console.WriteLine($"服务调用失败：{innerEx.Message}");
            }
        }
    }
}

// 示例Web服务调用（实际替换成你的HttpClient请求逻辑）
private async Task<object> CallUserService(CancellationToken token)
{
    // 注意：实际项目建议复用HttpClient或用IHttpClientFactory，避免socket耗尽
    using var httpClient = new HttpClient();
    var response = await httpClient.GetAsync("https://your-user-service-url", token);
    response.EnsureSuccessStatusCode();
    return await response.Content.ReadAsStringAsync();
}

// 同理实现CallPaymentService、CallNotificationService...

关键注意事项 #

• HttpClient复用：示例里每个服务调用都新建了HttpClient，实际生产环境一定要复用单例HttpClient或者依赖注入IHttpClientFactory，否则会导致系统socket资源耗尽。
• 自定义结果替代异常：如果不想用异常处理来判断超时，可以定义一个ServiceResult<T>类（包含IsSuccess、Result、ErrorType等字段），让WithTimeout方法返回这个类，代码可读性会更好。
• 取消令牌传递：一定要把CancellationToken传递到Web请求的底层方法（比如HttpClient.SendAsync），这样超时后才能真正中断正在进行的HTTP请求，而不是只是被动等待任务结束。

进阶优化：用ValueTask提升性能 #

如果你的Web服务调用是轻量级异步或者同步逻辑，可以把工具方法改成用ValueTask来减少内存分配：

public static async ValueTask<T> WithTimeout<T>(Func<CancellationToken, ValueTask<T>> operation, TimeSpan timeout)
{
    using var cts = new CancellationTokenSource();
    var timeoutTask = Task.Delay(timeout, cts.Token);
    var operationTask = operation(cts.Token);

    var completedTask = await Task.WhenAny(timeoutTask, operationTask.AsTask());
    
    if (completedTask == timeoutTask)
    {
        cts.Cancel();
        throw new TimeoutException($"操作超时，超过{timeout.TotalSeconds}秒");
    }

    return await operationTask;
}

内容的提问来源于stack exchange，提问作者Morshed