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<TResult>(IEnumerable<Task<TResult>> tasks)。

我這裡為了控制併發數量，使用 SemaphoreSlim 來控制同時執行的任務數量。

SemaphoreSlim 用於控制併發數量，確保同時只有最大數量的任務在執行。每個任務在開始執行時獲取信號量，完成後釋放信號量，這樣可以確保同時執行的任務數量不會超過預定的最大併發數。

請註意，這隻是一種控制併發數量的方式之一。

以下就是我的示例：

public async Task<Result<IEnumerable<T>>> RequestRemoteDatas<T>(string token, TableDataQueryParams param, int maxConcurrentTasks = -1)
{
    try
    {
        var content = new StringContent(JsonConvert.SerializeObject(param),
                                        Encoding.UTF8, Application.Json);
        var client = _httpClientFactory.CreateClient();
        client.DefaultRequestHeaders.Add("X-Access-Token", token);
        //client.Timeout = TimeSpan.FromSeconds(30);
        string url = AppSettings.TableDataHost + AppSettings.TableDataQueryUri;

        // 發送post請求
        HttpResponseMessage response = await client.PostAsync(url, content);
        var responseContent = await response.Content.ReadAsStringAsync();
        var result = JsonConvert.DeserializeObject<QueryApiResult>(responseContent);
        if (!result.success || result.code != 200)
        {
            return Result.BadRequest<IEnumerable<T>>(result.message); 
        }
        var records = JsonConvert.DeserializeObject<PlatformManagerDto<T>>(result.result.ToString());
        if (records == null)
        {
            return Result.NotFound<IEnumerable<T>>();
        }
        var dtos = new List<T>();

        if (records.Records.Any())
        {
            dtos.AddRange(records.Records);
        }

        if(records.Pages > 1)
        {
            var tasks = new List<Task<Result<IEnumerable<T>>>>();

            SemaphoreSlim? semaphore = null;
            if (maxConcurrentTasks >= 0)
            {
                //Maximum number of concurrent writes
                semaphore = new SemaphoreSlim(maxConcurrentTasks);
            }

            for (int i = 2; i <= records.Pages; i++)
            {
                int index = i;
                tasks.Add(Task.Run(async () =>
                                   {
                                       param.pageNo = index;
                                       var content1 = new StringContent(JsonConvert.SerializeObject(param),
                                                                        Encoding.UTF8, Application.Json);

                                       if (semaphore != null)
                                       {
                                           semaphore.Wait();
                                       }

                                       try
                                       {
                                           // Perform task operations
                                           // 發送post請求
                                           HttpResponseMessage response1 = await client.PostAsync(url, content1);
                                           var responseContent1 = await response1.Content.ReadAsStringAsync();
                                           var result1 = JsonConvert.DeserializeObject<QueryApiResult>(responseContent1);
                                           if (!result1.success || result1.code != 200)
                                           {
                                               return Result.BadRequest<IEnumerable<T>>(result1.message);
                                           }
                                           var records_next = JsonConvert.DeserializeObject<PlatformManagerDto<T>>(result1.result.ToString());
                                           if (records_next == null)
                                           {
                                               return Result.NotFound<IEnumerable<T>>();
                                           }
                                           return Result.Success(records_next.Records);
                                       }
                                       catch (Exception ex)
                                       {
                                           return Result.BadRequest<IEnumerable<T>>(ex.Message);
                                       }
                                       finally
                                       {
                                           if (semaphore != null)
                                           {
                                               semaphore.Release();
                                           }
                                       }                                
                                   }
                                  ));
            }

            var continuation = Task.WhenAll(tasks);
            continuation.Wait();
            if (continuation.Status == TaskStatus.RanToCompletion)
            {
                foreach (var result1 in continuation.Result)
                {
                    if (result1.Code != 200)
                    {
                        return Result.BadRequest<IEnumerable<T>>(result1.Msg);
                    }
                    dtos.AddRange(result1.Data);
                }
            }
        }
        return Result.Success(dtos.AsEnumerable());
    }
    catch (Exception ex) 
    {
        return Result.BadRequest<IEnumerable<T>>(ex.Message);
    }
}

總之，這篇博客希望能夠為您提供有價值的信息，並激發您的思考。

或者，您有更好的建議歡迎在評論區留言。

-感謝您花時間閱讀這篇博客-