C# Web API并发调用第三方API时如何关联请求与响应？

问题描述 #

我正在开发一个C# Web API，为提升性能会并发调用third-party-api-1完成特定操作；获取其输出后，再并发调用third-party-api-2做额外处理，最终将两个API的结果关联后返回给调用方。流程如下：

• 我的API接收用户输入
• 并发调用third-party-api-1（必须保留并发逻辑以保证速度）
• 基于third-party-api-1的结果，并发调用third-party-api-2（同样希望保持并发）

目前遇到的问题是：无法控制第三方API的响应，没办法通过请求头的correlation-id来关联请求与响应。一旦改成并发调用，就无法将每个响应和对应的原始输入关联起来。现在的备选方案是改成串行执行，但希望找到不需要放弃并发的可行方案。

相关代码片段：

// 从用户请求构建查询参数
foreach (ParsedInputAddress ia in inaddr)
{
    // ... 构建逻辑
    addresses.Add(addrbuilder.ToString());
    addrbuilder.Clear();
}

// 并发调用第三方API
IEnumerable<Task<HttpResponseMessage>> getTasks = addresses.Select(async ia => await httpClient.GetAsync(basepath + ia.ToString()));
var gets = await Task.WhenAll(getTasks);

foreach (var getContent in gets)
{
    jsonResponse = await getContent.Content.ReadAsStringAsync();
    if (jsonResponse != null)
        vaddr = JsonSerializer.Deserialize<ValidatedAddress>(jsonResponse);
    if (vaddr != null && vaddr.address != null)
        vaddresses.Add(vaddr.address);
}

可行方案 #

不需要放弃并发，核心思路是在异步任务中保留原始请求的上下文信息，让每个任务不仅返回第三方API的响应，同时携带对应的原始输入或标识，这样就能在任务完成后直接关联请求与响应。

1. 匿名类型携带上下文 #

在构建异步任务时，返回包含原始输入和响应的匿名类型，这样Task.WhenAll完成后，就能直接拿到每个请求对应的结果：

// 并发调用third-party-api-1，同时保留原始请求地址
var getTasks = addresses.Select(async originalAddr => 
{
    var response = await httpClient.GetAsync(basepath + originalAddr);
    return (OriginalAddress: originalAddr, Response: response);
});
var api1Results = await Task.WhenAll(getTasks);

// 遍历结果，关联原始地址与API响应
var api1Processed = new List<(string OriginalAddress, ValidatedAddress ValidatedAddr)>();
foreach (var result in api1Results)
{
    var jsonResponse = await result.Response.Content.ReadAsStringAsync();
    if (jsonResponse != null)
    {
        var vaddr = JsonSerializer.Deserialize<ValidatedAddress>(jsonResponse);
        if (vaddr != null && vaddr.address != null)
        {
            api1Processed.Add((result.OriginalAddress, vaddr));
        }
    }
}

2. 并发调用third-party-api-2时延续上下文 #

基于third-party-api-1的关联结果，继续用同样的方式并发调用third-party-api-2，保留完整的上下文链路：

// 基于api1的关联结果，并发调用third-party-api-2
var api2Tasks = api1Processed.Select(async pair => 
{
    var api2Response = await httpClient.GetAsync(api2BasePath + pair.ValidatedAddr.address);
    var api2Json = await api2Response.Content.ReadAsStringAsync();
    var api2Result = JsonSerializer.Deserialize<ExtraProcessResult>(api2Json);
    
    return new 
    {
        InputAddress = pair.OriginalAddress,
        Api1Validated = pair.ValidatedAddr.address,
        Api2ExtraData = api2Result
    };
});
var finalResults = await Task.WhenAll(api2Tasks);

// 整理最终返回给调用方的结果
var apiOutput = finalResults.Select(r => new 
{
    OriginalInput = r.InputAddress,
    ValidatedAddress = r.Api1Validated,
    ExtraProcessing = r.Api2ExtraData
});

3. 自定义上下文类（复杂场景） #

如果需要携带更多上下文信息（比如请求ID、用户标识等），可以定义一个自定义类来封装：

public class ApiRequestContext
{
    public string OriginalAddress { get; set; }
    public Guid RequestId { get; set; } = Guid.NewGuid();
    // 可添加其他需要的字段
}

// 使用方式
var requestContexts = addresses.Select(addr => new ApiRequestContext { OriginalAddress = addr });
var api1Tasks = requestContexts.Select(async ctx => 
{
    var response = await httpClient.GetAsync(basepath + ctx.OriginalAddress);
    return (Context: ctx, Response: response);
});

这种方式既保留了并发带来的性能提升，又能完美实现请求与响应的关联，不需要退化为串行执行。

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