如何使一系列任務順序運行？

-3

我有一系列的Task s，我想從a-z開始依次運行。我想同步執行這些呼叫starting from 1 and ending at N。如何使一系列任務順序運行？

TASK1 DeleteSubProjects ... 1個
- TASK1 DeleteActivities ... 2個
  - TASK1 DeleteActivityPersons ... 3
  - TASK2 DeleteThreads ... 4
    - TASK1 DeleteCommunicationThreadContentTags ... 5個
    - TASK2 DeleteCommunicationThreadParticipants ...6個
    - TASK3 DeleteMessages
    - task4刪除（communicationThread）
  - TASK3 DeleteActivityDocuments
  - task4 DeleteActivityNotes
  - 任務5 DeleteActivityMachines
  - Task6中 DeleteActivityLinks
  - task7 DeleteActivityLinks
  - 任務8刪除（活性）
- TASK2 DeleteSubProjectDocuments
- TASK3 DeleteSubProjectNotes
- task4 DeleteSubProjectPersons
- 任務5 DeleteSubProjects
- Task6中刪除（子項目）
TASK2 deleteProjectNotes
TASK3 deleteProjectDocuments
task4 deleteActivities
任務5 deleteProjectPersons

這裏是代碼的樣子

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(); 
}

來源

2016-10-25 Ortho Home Defense

...首先不要讓它們異步？ –

@MikeMcCaughan我想在我開始實施級聯刪除之前嘗試一下。不會使異步拋出內存異常。 –

不需要調用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);   
}

現在刪除操作的順序在這個具體的例子中是序列化的。

來源

2016-10-25 16:51:22

這實際上是我之前的，但有人給我這樣做的建議，因爲他們說它需要更少的內存。我要刪除一個級聯，但我想嘗試其他替代方案。感謝這個答案， –

如何使一系列任務順序運行？

回答

相關問題