.NET 5.0 WebApi批量请求处理配置及MapHttpBatchRoute访问问题咨询

你使用的System.Web.Http.Batch是*ASP.NET Web API 2（仅支持.NET Framework）*的专属组件，不兼容.NET 5及以上的.NET Core架构，因此无法找到MapHttpBatchRoute方法，也不能直接沿用旧版本的配置逻辑。

.NET 5+环境下实现批量请求功能可以参考以下两种方案：

方案1：使用官方OData组件（兼容标准批量协议，无需自定义逻辑） #

如果你的场景可以兼容OData标准的批量请求格式，直接用官方内置的批量处理能力即可，配置非常简单：

1. 安装NuGet包Microsoft.AspNetCore.OData
2. 在Startup.cs的ConfigureServices方法中添加配置：

services.AddControllers().AddOData(opt => opt.EnableBatchRoute());

3. 在Configure方法中，UseRouting之后、UseEndpoints之前添加批量处理中间件：

app.UseODataBatching();

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

配置完成后直接使用/$batch端点即可处理符合OData规范的批量请求。

方案2：自定义批量端点（适合自定义请求格式的场景） #

如果需要自定义批量请求的格式，可以自己实现api/batch端点：

步骤1：定义批量请求/响应模型 #

// 单条子请求模型
public class BatchRequestItem
{
    public string HttpMethod { get; set; }
    public string Path { get; set; }
    public Dictionary<string, string> Headers { get; set; }
    public object Body { get; set; }
}

// 单条子响应模型
public class BatchResponseItem
{
    public int StatusCode { get; set; }
    public Dictionary<string, string> Headers { get; set; }
    public object Body { get; set; }
}

步骤2：实现批量处理控制器 #

[ApiController]
[Route("api/[controller]")]
public class BatchController : ControllerBase
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly IServiceProvider _serviceProvider;

    public BatchController(IHttpContextAccessor httpContextAccessor, IServiceProvider serviceProvider)
    {
        _httpContextAccessor = httpContextAccessor;
        _serviceProvider = serviceProvider;
    }

    [HttpPost]
    public async Task<IActionResult> ProcessBatch([FromBody] List<BatchRequestItem> requests)
    {
        // 可自行添加单批请求数量上限校验
        var responses = new List<BatchResponseItem>();
        foreach (var req in requests)
        {
            // 构造子请求上下文
            var context = new DefaultHttpContext();
            context.RequestServices = _serviceProvider;
            context.Request.Method = req.HttpMethod;
            context.Request.Path = req.Path;
            context.User = _httpContextAccessor.HttpContext.User; // 继承父请求的身份信息

            // 填充请求头
            if (req.Headers != null)
            {
                foreach (var header in req.Headers)
                {
                    context.Request.Headers.TryAdd(header.Key, header.Value);
                }
            }

            // 填充请求体
            if (req.Body != null && new[] { HttpMethod.Post.Method, HttpMethod.Put.Method, HttpMethod.Patch.Method }.Contains(req.HttpMethod))
            {
                var json = System.Text.Json.JsonSerializer.Serialize(req.Body);
                var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(json));
                context.Request.Body = stream;
                context.Request.ContentType = "application/json";
                context.Request.ContentLength = stream.Length;
            }

            // 执行子请求
            var requestDelegate = _serviceProvider.GetRequiredService<RequestDelegate>();
            await requestDelegate.Invoke(context);

            // 解析响应
            var response = new BatchResponseItem
            {
                StatusCode = context.Response.StatusCode,
                Headers = context.Response.Headers.ToDictionary(h => h.Key, h => h.Value.ToString())
            };

            if (context.Response.Body.CanRead)
            {
                context.Response.Body.Seek(0, SeekOrigin.Begin);
                using var reader = new StreamReader(context.Response.Body);
                var bodyStr = await reader.ReadToEndAsync();
                response.Body = System.Text.Json.JsonSerializer.Deserialize<object>(bodyStr);
            }

            responses.Add(response);
        }

        return Ok(responses);
    }
}

步骤3：注册必要服务和中间件 #

在Startup.cs的ConfigureServices方法中添加：

services.AddHttpContextAccessor();

在Configure方法中，UseEndpoints之前添加响应体缓冲中间件：

app.Use(async (context, next) =>
{
    context.Response.Body = new MemoryStream();
    await next();
});

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

注意事项 #

• 批量接口需要单独配置限流、超时规则，避免大量并发子请求拖垮服务
• 子请求可以根据业务需要调整为并行执行，注意处理共享上下文的线程安全问题

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