Konvertieren Schleife Aufgaben

Question

Ich habe folgenden Synchroncode:

foreach (var step in result) { 
    step.Run(); 
} 

Ich habe versucht, es zu Aufgaben zu konvertieren, aber ich nicht tun. Ich habe versucht, es zu konvertieren Task.WhenAll wie folgt aus (und ich habe async der Methode Signatur anhängen):

var tasks = new List<Task>(); 
foreach (var step in result) { 
    tasks.Add(new Task(() => step.Run())); 
} 
await Task.WhenAll(tasks); 

Dieser kehrt sofort zurück und stellt die Run() Methode nicht ausgeführt werden. Dann habe ich versucht, es in den folgenden Code zu konvertieren:

Dies blockiert für immer. Allerdings, wenn ich ein innerhalb der Schleife erstellen funktioniert es:

foreach (var step in result) { 
    var t = Task.Run(() => step.Run()); 
    t.Wait(); 
} 

Wenn ich stattdessen await Task.Run(() => step.Run()); es wartet nur die ersten und nimmt den Haupt-Thread.

Die run-Methode sieht wie folgt aus:

public async void Run() { 
    var result = Work(); 
    if (null != result && result.Count > 0) { 
     var tasks = new List<Task>(); 
     foreach (var step in result) { 
      await Task.Run(() => step.Run()); 
     } 
    } 
} 

Alle Schritte, um eine Arbeit() Methode implementieren (die in einer Basisklasse abstrakt ist). Mein erster Schritt sieht wie folgt aus:

class NoWorkStep : WorkerStep { 
    protected override IList<WorkerStep> Work() { 
     Console.WriteLine("HERE"); 
     List<WorkerStep> newList = new List<WorkerStep>(); 
     for (int i = 0; i < 10; i++) { 
      newList.Add(new NoWorkStep2()); 
     } 
     return newList; 
    } 
} 

Und meine zweite Schritt sieht wie folgt aus:

class NoWorkStep2 : WorkerStep { 
    protected override IList<WorkerStep> Work() { 
     Console.WriteLine("HERE-2"); 
     return new List<WorkerStep>(); 
    } 
} 

ich einfach eine Instanz von NoWorkStep erstellen und instance.Run() nennen.

Wo habe ich ein Problem mit der Ausführung der Schritte mit Task.WhenAll?

Edit: Code aufrufen, nachdem ich die Run-Methode zu async Task RunAsync geändert:

private static async void doIt() { 
    var step = new NoWorkStep(); 
    await step.RunAsync(); 
} 

Answer 1

Hier können die Probleme mit Ihrem Code kartieren:

new Task(() => step.Run()) 

Das gibt eine kalte Task, was bedeutet, die Task wurde nicht wirklich gestartet. Damit es müssten Sie anrufen starten:

new Task(() => step.Run()).Start) 

Aber Sie nicht new Task sowieso verwenden sollten, sollten Sie Task.Run verwenden.

Wenn ich stattdessen verwenden, warten Task.Run (() => step.Run()); es wartet nur der erste und setzt den Hauptthread fort.

Das ist, weil Runasync void ist, die nicht erwartet werden kann. async void ist nur in Top-Level-Event-Handlern zu verwenden, wo dies hier eindeutig nicht der Fall ist.

Wenn Sie abwarten wollen, bis alle Aufgaben abgeschlossen sind, können Sie tun, dass folgende:

public async Task RunAsync() 
{ 
    var result = Work(); 
    var stepTasks = result.Select(step => Task.Run(() => step.Run())); 
    await Task.WhenAll(steps); 
} 

Dies wird garantieren, dass alle Aufgaben Ausführung einmal RunAsync beendet abgeschlossen haben.

Answer 2

Sie scheinen nicht die Aufgaben zu starten.

Versuchen:

var tasks = new List<Task>(); 

foreach (var step in result) 
{ 
    var t = new Task(() => step.Run()); 
    t.Start(); 
    tasks.Add(t); 
} 

Task.WhenAll(tasks); 

Answer 3

können Sie Parallel.ForEach verwenden.

Parallel.ForEach(result, step => step.Run()); 

Auf diese Weise können Sie nicht einmal mit den unteren Ebenen des Parallel Frameworks herumspielen.