Conversione ciclo per compiti

Question

Ho il seguente codice sincrono:

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

ho cercato di convertirlo in compiti, ma non sono riuscito a farlo. Ho provato a convertirlo utilizzando Task.WhenAll come questo (e l'ho fatto aggiungere asincrona per la firma del metodo):

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

Questo restituisce immediatamente e non esegue il metodo Run(). Quindi ho provato a convertirlo al seguente codice:

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

Questo blocco per sempre. Tuttavia, quando creo un all'interno del ciclo funziona:

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

Se uso invece await Task.Run(() => step.Run()); attende solo la prima e riprende il filo conduttore.

metodo

Il percorso è simile al seguente:

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

Tutte le fasi di implementare un metodo di lavoro() (che è astratto in una classe base). Il mio primo passo è simile al seguente:

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

E il mio secondo passo è simile al seguente:

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

ho semplice creare un'istanza di NoWorkStep e chiamare instance.Run().

Dove si verifica un problema con l'esecuzione dei passaggi con Task.WhenAll?

Edit: Calling codice dopo ho cambiato il metodo Run per async Task RunAsync:

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

Answer 1

Consente tracciare i problemi con il tuo codice:

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

Ciò restituisce un raffreddore Task, cioè la Task non è stato effettivamente avviato. Al fine di farlo per iniziare si avrebbe bisogno di chiamare:

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

Ma, non si dovrebbe usare new Task in ogni caso, è necessario utilizzare Task.Run.

Se utilizzo, attendo Task.Run (() => step.Run()); attende solo il primo e riprende il thread principale.

Questo perché Run è async void che non può essere atteso. async void è da utilizzare solo nei gestori di eventi di livello superiore, dove chiaramente non è il caso qui.

Se si vuole attendere fino a quando tutti i compiti sono stati completati, si può fare che a seguito:

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

Ciò garantirà tutte le attività hanno completato l'esecuzione una volta RunAsync finiture.

Answer 2

Sembra che tu non stia iniziando le attività.

Prova:

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

È possibile utilizzare Parallel.ForEach.

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

In questo modo non si scherza nemmeno con le parti di livello inferiore di Parallel Framework.