如何并行化包含JSON反序列化的异步订单集成工作？

针对你的场景，每个订单的三个API调用存在依赖关系（必须按「获取订单详情→创建订单→记录日志」的顺序执行），但不同订单之间完全可以并行处理。以下是具体实现方案：

核心思路 #

将单个订单的完整处理逻辑封装为独立异步方法，然后通过Task.WhenAll同时启动多个订单的处理任务，实现并行执行。同时建议添加并发控制，避免短时间内发起过多请求触发API限流。

代码实现 #

using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Collections.Generic;

namespace Order_Integrator
{
    public class Program
    {
        static readonly HttpClient client = new HttpClient();
        // 控制最大并发数，根据API服务承受能力调整，示例设为20
        static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(20);

        static async Task Main()
        {
            // Auth 获取token
            var connectResponse = await client.PostAsync(connectUrl, connectContent);
            var connectResponseString = await connectResponse.Content.ReadAsStringAsync();
            var connect = JsonSerializer.Deserialize<connectResponse>(connectResponseString);
            var token = connect.Token;

            // 获取订单列表
            var orderResponse = await client.PostAsync(orderUrl, orderContent);
            var orderResponseString = await orderResponse.Content.ReadAsStringAsync();
            var orders = JsonSerializer.Deserialize<orderResponse>(orderResponseString);

            // 收集所有订单处理任务
            var processingTasks = new List<Task>();
            foreach (var order in orders)
            {
                processingTasks.Add(ProcessOrderAsync(token, order));
            }

            // 等待所有任务完成
            await Task.WhenAll(processingTasks);
        }

        // 封装单个订单的串行处理逻辑
        static async Task ProcessOrderAsync(string token, Order order)
        {
            await _semaphore.WaitAsync();
            try
            {
                // 1. 获取订单详情
                // 根据order和token生成getOrderDetailsContent
                var getOrderDetailsResponse = await client.PostAsync(getOrderDetailsUrl, getOrderDetailsContent);
                var getOrderDetailsResponseString = await getOrderDetailsResponse.Content.ReadAsStringAsync();
                var getOrderDetails = JsonSerializer.Deserialize<getOrderDetailsResponse>(getOrderDetailsResponseString);

                // 2. 创建订单
                // 根据getOrderDetails生成createOrderContent
                var createOrderResponse = await client.PostAsync(createOrderUrl, createOrderContent);
                var createOrderResponseString = await createOrderResponse.Content.ReadAsStringAsync();
                var createOrder = JsonSerializer.Deserialize<createOrderResponse>(createOrderResponseString);

                // 3. 创建日志
                // 根据createOrder生成createLogContent
                var createLogResponse = await client.PostAsync(createLogUrl, createLogContent);
                var createLogResponseString = await createLogResponse.Content.ReadAsStringAsync();
                var createLog = JsonSerializer.Deserialize<createLogResponse>(createLogResponseString);
            }
            finally
            {
                // 释放信号量，允许下一个任务执行
                _semaphore.Release();
            }
        }
    }

    // 补充定义相关模型类（原代码中省略的部分）
    public class connectResponse { public string Token { get; set; } }
    public class orderResponse : List<Order> { }
    public class Order { /* 订单属性定义 */ }
    public class getOrderDetailsResponse { /* 订单详情属性定义 */ }
    public class createOrderResponse { /* 订单创建结果属性定义 */ }
    public class createLogResponse { /* 日志创建结果属性定义 */ }
}

关键说明 #

• 异步方法封装：ProcessOrderAsync确保单个订单的三个API调用按依赖顺序执行，同时方法本身异步非阻塞，不占用主线程资源。
• 并发控制：SemaphoreSlim限制同时运行的订单处理任务数量，避免API服务因请求过载触发限流或报错，并发数可根据API的实际承载能力调整。
• Task.WhenAll：一次性等待所有订单处理任务完成，相比单线程逐个处理，能大幅提升整体处理效率。

内容的提问来源于stack exchange，提问作者Ali Karaçay