如何让一系列Task按顺序运行？

Question

我有一系列Tasks，我想从 a-z 按顺序运行。

我想同步执行这些调用starting from 1 and ending at N。

• task1 删除子项目...1
  • task1 删除活动...2
    • task1 删除ActivityPersons...3
    • task2 删除线程...4
      • task1 删除CommunicationThreadContentTags...5
      • task2 删除CommunicationThreadParticipants...6
      • task3 删除消息
      • task4 删除(communicationThread)
    • task3 删除ActivityDocuments
    • task4删除ActivityNotes
    • task5 删除ActivityMachines
    • task6 删除ActivityLinks
    • task7 删除ActivityLinks
    • task8 删除（活动）
  • task2 删除SubProjectDocuments
  • task3 删除SubProjectNotes
  • task4 删除SubProjectPersons
  • task5 删除子项目
  • task6 删除（子项目）
• task2 删除ProjectNotes
• task3 删除项目文档
• task4 删除活动
• task5 删除ProjectPersons

这是代码的样子

public async Task DeleteProject(Project project)
{

    var deleteSubProjects = UnitOfWork.Instance.SubProjectService.DeleteSubProjects(project.SubProjects);
    var deleteProjectNotes = UnitOfWork.Instance.ProjectNoteService.DeleteProjectNotes(project.ProjectNotes);
    var deleteProjectDocuments = UnitOfWork.Instance.ProjectDocumentService.DeleteProjectDocuments(project.ProjectDocuments);
    var deleteActivities = UnitOfWork.Instance.ActivityService.DeleteActivities(project.Activities);
    var deleteProjectPersons = UnitOfWork.Instance.ProjectPersonService.DeleteProjectPersons(project.ProjectPersons);

    await Task.WhenAll(deleteSubProjects)
        .ContinueWith(_ => deleteProjectNotes)
        .ContinueWith(_ => deleteProjectDocuments)
        .ContinueWith(_ => deleteActivities)
        .ContinueWith(_ => deleteProjectPersons)
        .ContinueWith(_ => Delete(project)).Unwrap();            
}

子项目

public async Task DeleteSubProjects(IList<SubProject> subProjects)
{
    foreach (var subProject in subProjects.ToList())
    {
        await DeleteSubProject(subProject);
    }
}
public async Task DeleteSubProject(SubProject subProject)
{
    var task1 = UnitOfWork.Instance.ActivityService.DeleteActivities(subProject.Activities);
    var task2 = UnitOfWork.Instance.SubProjectDocumentService.DeleteSubProjectDocuments(subProject.SubProjectDocuments);
    var task3 = UnitOfWork.Instance.SubProjectNoteService.DeleteSubProjectNotes(subProject.SubProjectNotes);
    var task4 = UnitOfWork.Instance.SubProjectPersonService.DeleteSubProjectPersons(subProject.SubProjectPersons);
    var task5 = DeleteSubProjects(subProject.ChildSubProjects);
    var task6 = Delete(subProject);

    await Task.WhenAll(task1)
        .ContinueWith(_ => task2)
        .ContinueWith(_ => task3)
        .ContinueWith(_ => task4)
        .ContinueWith(_ => task5)
        .ContinueWith(_ => task6).Unwrap();
    //Delete(subProject);    
}

活动

public async Task DeleteActivities(IList<Activity> activities)
{
    foreach (var activity in activities)
    {
         await DeleteActivity(activity);
    }
}
public async Task DeleteActivity(Activity activity)
{
    var task1 = UnitOfWork.Instance.ActivityPersonService.DeleteActivityPersons(activity.ActivityPersons);
    var task2 = UnitOfWork.Instance.CommunicationThreadService.DeleteThreads(activity.CommunicationThreads);
    var task3 = UnitOfWork.Instance.ActivityDocumentService.DeleteActivityDocuments(activity.ActivityDocuments);
    var task4 = UnitOfWork.Instance.ActivityNoteService.DeleteActivityNotes(activity.ActivityNotes);
    var task5 = UnitOfWork.Instance.ActivityMachineService.DeleteActivityMachines(activity.ActivityMachines);
    var task6 = UnitOfWork.Instance.ActivityLinkService.DeleteActivityLinks(activity.SuccActivityLinks);
    var task7 = UnitOfWork.Instance.ActivityLinkService.DeleteActivityLinks(activity.PredActivityLinks);
    var task8 = Delete(activity);

    await Task.WhenAll(task1)
        .ContinueWith(_ => task2)
        .ContinueWith(_ => task3)
        .ContinueWith(_ => task4)
        .ContinueWith(_ => task5)
        .ContinueWith(_ => task6)
        .ContinueWith(_ => task7)
        .ContinueWith(_ => task8).Unwrap();
   // Delete(activity);
}

线程

internal async Task DeleteThreads(IList<CommunicationThread> threads)
{
    foreach (var thread in threads)
    {
      await  DeleteThread(thread);
    }
}
internal async Task DeleteThread(CommunicationThread communicationThread)
{
   var task1 = UnitOfWork.Instance.CommunicationThreadContentTagService.DeleteCommunicationThreadContentTags(communicationThread.CommunicationThreadContentTags);
   var task2 = UnitOfWork.Instance.CommunicationThreadParticipantService.DeleteCommunicationThreadParticipants(communicationThread.CommunicationThreadParticipants);
   var task3 = UnitOfWork.Instance.CommunicationMessageService.DeleteMessages(communicationThread.CommunicationMessages.Where(msg => msg.CommentOnMessageID == null).ToList());
   var task4 = Delete(communicationThread);

   await Task.WhenAll(task1)
        .ContinueWith(_ => task2)
        .ContinueWith(_ => task3)
        .ContinueWith(_ => task4).Unwrap();
}

Answer 1

而不是调用Task.WhenAll 并为每个Task 声明一个变量，只需按您需要的顺序为每个await 声明一个变量——例如：

public async Task DeleteProject(Project project)
{
    var instance = UnitOfWork.Instance;

    await instance.SubProjectService.DeleteSubProjects(project.SubProjects);
    await instance.ProjectNoteService.DeleteProjectNotes(project.ProjectNotes);
    await instance.ProjectDocumentService.DeleteProjectDocuments(project.ProjectDocuments);
    await instance.ActivityService.DeleteActivities(project.Activities);
    await instance.ProjectPersonService.DeleteProjectPersons(project.ProjectPersons);          
}

现在这个具体例子中删除操作的顺序是序列化的。