C# Task 使用 WhenAll 请求远程分页接口

首先WhenAll 是什么？

-所有提供的任务已完成时，创建将完成的任务-
-Creates a task that will complete when all of the supplied tasks have completed-
Task.WhenAll() 方法是 C# 中用于等待多个任务（Task）完成的一种方式。它不会控制并发数量，而是等待所有传递给它的任务都完成后才会继续执行下一步操作。这意味着一旦所有任务都完成，无论这些任务是如何并发执行的，Task.WhenAll() 方法才会返回。
具体用法还是去看官方文档，这是最好的教程： .NET Core 官方教程-Task.WhenAll()
请求远程分页接口并返回实体数据

我这里写的通用模板，用的Task.WhenAll 的重载方法： WhenAll(IEnumerable tasks)。
我这里为了控制并发数量，使用 SemaphoreSlim 来控制同时执行的任务数量。
SemaphoreSlim 用于控制并发数量，确保同时只有最大数量的任务在执行。每个任务在开始执行时获取信号量，完成后释放信号量，这样可以确保同时执行的任务数量不会超过预定的最大并发数。
请注意，这只是一种控制并发数量的方式之一。
以下就是我的示例：

1. public async Task<Result<IEnumerable<T>>> RequestRemoteDatas<T>(string token, TableDataQueryParams param, int maxConcurrentTasks = -1)
2. {
3.     try
4.     {
5.         var content = new StringContent(JsonConvert.SerializeObject(param),
6.                                         Encoding.UTF8, Application.Json);
7.         var client = _httpClientFactory.CreateClient();
8.         client.DefaultRequestHeaders.Add("X-Access-Token", token);
9.         //client.Timeout = TimeSpan.FromSeconds(30);
10.         string url = AppSettings.TableDataHost + AppSettings.TableDataQueryUri;
12.         // 发送post请求
13.         HttpResponseMessage response = await client.PostAsync(url, content);
14.         var responseContent = await response.Content.ReadAsStringAsync();
15.         var result = JsonConvert.DeserializeObject<QueryApiResult>(responseContent);
16.         if (!result.success || result.code != 200)
17.         {
18.             return Result.BadRequest<IEnumerable<T>>(result.message);
19.         }
20.         var records = JsonConvert.DeserializeObject<PlatformManagerDto<T>>(result.result.ToString());
21.         if (records == null)
22.         {
23.             return Result.NotFound<IEnumerable<T>>();
24.         }
25.         var dtos = new List<T>();
27.         if (records.Records.Any())
28.         {
29.             dtos.AddRange(records.Records);
30.         }
32.         if(records.Pages > 1)
33.         {
34.             var tasks = new List<Task<Result<IEnumerable<T>>>>();
36.             SemaphoreSlim? semaphore = null;
37.             if (maxConcurrentTasks >= 0)
38.             {
39.                 //Maximum number of concurrent writes
40.                 semaphore = new SemaphoreSlim(maxConcurrentTasks);
41.             }
43.             for (int i = 2; i <= records.Pages; i++)
44.             {
45.                 int index = i;
46.                 tasks.Add(Task.Run(async () =>
47.                                    {
48.                                        param.pageNo = index;
49.                                        var content1 = new StringContent(JsonConvert.SerializeObject(param),
50.                                                                         Encoding.UTF8, Application.Json);
52.                                        if (semaphore != null)
53.                                        {
54.                                            semaphore.Wait();
55.                                        }
57.                                        try
58.                                        {
59.                                            // Perform task operations
60.                                            // 发送post请求
61.                                            HttpResponseMessage response1 = await client.PostAsync(url, content1);
62.                                            var responseContent1 = await response1.Content.ReadAsStringAsync();
63.                                            var result1 = JsonConvert.DeserializeObject<QueryApiResult>(responseContent1);
64.                                            if (!result1.success || result1.code != 200)
65.                                            {
66.                                                return Result.BadRequest<IEnumerable<T>>(result1.message);
67.                                            }
68.                                            var records_next = JsonConvert.DeserializeObject<PlatformManagerDto<T>>(result1.result.ToString());
69.                                            if (records_next == null)
70.                                            {
71.                                                return Result.NotFound<IEnumerable<T>>();
72.                                            }
73.                                            return Result.Success(records_next.Records);
74.                                        }
75.                                        catch (Exception ex)
76.                                        {
77.                                            return Result.BadRequest<IEnumerable<T>>(ex.Message);
78.                                        }
79.                                        finally
80.                                        {
81.                                            if (semaphore != null)
82.                                            {
83.                                                semaphore.Release();
84.                                            }
85.                                        }                                
86.                                    }
87.                                   ));
88.             }
90.             var continuation = Task.WhenAll(tasks);
91.             continuation.Wait();
92.             if (continuation.Status == TaskStatus.RanToCompletion)
93.             {
94.                 foreach (var result1 in continuation.Result)
95.                 {
96.                     if (result1.Code != 200)
97.                     {
98.                         return Result.BadRequest<IEnumerable<T>>(result1.Msg);
99.                     }
100.                     dtos.AddRange(result1.Data);
101.                 }
102.             }
103.         }
104.         return Result.Success(dtos.AsEnumerable());
105.     }
106.     catch (Exception ex)
107.     {
108.         return Result.BadRequest<IEnumerable<T>>(ex.Message);
109.     }
110. }

复制代码

总之，这篇博客希望能够为您提供有价值的信息，并激发您的思考。
或者，您有更好的建议欢迎在评论区留言。
-感谢您花时间阅读这篇博客-

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！