等待多個獨立任務的最佳方法/實踐是什么？

Question

var contractSchemaTask = contractSchemaRepository.GetByContractIdAsync(data.Id);
var sectionsTask = sectionRepository.GetAllByContractIdAsync(id);
var latestContractIdTask = contractRepository
    .GetLatestContractIdByFolderIdAsync(data.FolderId.Value);
List<Task> allTasks = new List<Task>()
    { contractSchemaTask, sectionsTask, latestContractIdTask };
while (allTasks.Any())
{
    Task finished = await Task.WhenAny(allTasks);
    if (finished == contractSchemaTask)
    {
        var contractSchema = await contractSchemaTask;
        result.ReturnData.IsSchedules = contractSchema.Count > 0 ? true : false;
    }
    else if (finished == sectionsTask)
    {
        List<Section> sections = await sectionsTask;

        List<TextValueVM> SectionTabList = sections.Count > 0 ? sections
            .OrderBy(a => a.SectionNumber)
            .Select(a => new TextValueVM()
                { Text = a.ToString(), Value = a.Id.ToString() })
            .ToList() : new List<TextValueVM>();

        bool IsSectionsLinked = false;
        int linkSectionCount = sections
            .Where(x => x.LinkSectionId != null && x.LinkSectionId != Guid.Empty)
            .ToList()
            .Count();
        if (linkSectionCount == 0 && sections.Count > 0)
        {
            List<Guid> sectionIds = sections.Select(x => x.Id.Value).ToList();
            List<Section> currentContractLinkSections = await sectionRepository
                .GetSectionsByLinkSectionIdAsync(sectionIds);
            if (currentContractLinkSections.Count > 0)
            {
                IsSectionsLinked = true;
            }
        }
        else if (linkSectionCount > 0)
        {
            IsSectionsLinked = true;
        }
        result.ReturnData.SectionTabList = SectionTabList;
        result.ReturnData.IsSectionsLinked = IsSectionsLinked;
    }
    else if (finished == latestContractIdTask)
    {
        Guid LatestContractId = await latestContractIdTask;
        result.ReturnData.isLatestContract
            = (data.Id == LatestContractId) ? true : false;
    }
    allTasks.Remove(finished);
}

我正在開發一個 asp.net core 3.0 WebAPI 項目。 以上是我使用 while 循環處理的獨立任務的示例代碼。 在異步編程中是否有更好或有效的方法來處理獨立任務？

PS：所有 3 個任務都是獨立的，它們的響應時間可能會有所不同，具體取決於從數據庫中提取的記錄數。

Answer 1

你應該這樣做：

public Task Main()
{
    var result = new Result();
    return Task.WhenAll(TaskOne(result), TaskTwo(result), TaskThree(result));
}

    private async Task TaskOne(Result result)
    {
        var contractSchema = await contractSchemaRepository.GetByContractIdAsync(data.Id);
        //your logic for task1, set related result properties
    }

    private async Task TaskTwo(Result result)
    {
        var sections = await sectionRepository.GetAllByContractIdAsync(id);
        //your logic for task2, set related result properties
    }

    private async Task TaskThree(Result result)
    {
        var latestContractId = await contractRepository.GetLatestContractIdByFolderIdAsync(data.FolderId.Value);
        //your logic for Task3, set related result properties
    }

Result類應該實現為線程安全的，因為任務可以同時執行。 如果你只是在每個方法中設置不同的屬性應該沒問題。

Answer 2

將 Task.WhenAll 與 Continue 結合使用，您可以在任務完成后立即執行代碼，而無需等待其余任務。

class Test {

    public static async Task Main() {

      var t1 = AsyncWork1().ContinueWith((t) => Console.WriteLine($"Task1 finished with value {t.Result}"));
      var t2 = AsyncWork2().ContinueWith((t) => Console.WriteLine($"Task2 finished with value {t.Result}"));
      var t3 = AsyncWork3().ContinueWith((t) => Console.WriteLine($"Task3 finished with value {t.Result}"));

      await Task.WhenAll(new[] { t1, t2, t3 });

      //here we know that all tasks has been finished and its result behaviour executed.

      Console.ReadKey();    
    }//main

    public static async Task<int> AsyncWork1() {
      await Task.Delay(1000);
      return 1;
    }

    public static async Task<string> AsyncWork2() {
     await Task.Delay(100);
      return "work2";
    }

    public static async Task<bool> AsyncWork3() {
      await Task.Delay(500);
      return true;
    }

  }//class Test

與此比較：

 class Test {

        public static async Task Main() {

          var t1 = AsyncWork1();
          var t2 = AsyncWork2();
          var t3 = AsyncWork3();

          await Task.WhenAll(new[] { t1, t2, t3 });

         //all task finished but now we have to execute the result behaviour in a sync way          

         Console.WriteLine($"Task1 finished with value {t1.Result}");
         Console.WriteLine($"Task2 finished with value {t2.Result}");
         Console.WriteLine($"Task3 finished with value {t3.Result}");

          Console.ReadKey();    
        }//main

        public static async Task<int> AsyncWork1() {
          await Task.Delay(1000);
          return 1;
        }

        public static async Task<string> AsyncWork2() {
         await Task.Delay(100);
          return "work2";
        }

        public static async Task<bool> AsyncWork3() {
          await Task.Delay(500);
          return true;
        }

      }//class Test