Verwendung in einer Schleife erwarten

Question

Ich versuche, eine asynchrone Konsole App zu erstellen, die einige Arbeiten an einer Sammlung ausführt. Ich habe eine Version, die parallele for-Schleife eine andere Version verwendet, die async/erwartet verwendet. Ich erwartete, dass die async/await-Version ähnlich wie die parallele Version funktioniert, aber synchron ausgeführt wird. Was mache ich falsch?

class Program 
{ 
    static void Main(string[] args) 
    { 
     var worker = new Worker(); 
     worker.ParallelInit(); 
     var t = worker.Init(); 
     t.Wait(); 
     Console.ReadKey(); 
    } 
} 

public class Worker 
{ 
    public async Task<bool> Init() 
    { 
     var series = Enumerable.Range(1, 5).ToList(); 
     foreach (var i in series) 
     { 
      Console.WriteLine("Starting Process {0}", i); 
      var result = await DoWorkAsync(i); 
      if (result) 
      { 
       Console.WriteLine("Ending Process {0}", i); 
      } 
     } 

     return true; 
    } 

    public async Task<bool> DoWorkAsync(int i) 
    { 
     Console.WriteLine("working..{0}", i); 
     await Task.Delay(1000); 
     return true; 
    } 

    public bool ParallelInit() 
    { 
     var series = Enumerable.Range(1, 5).ToList(); 
     Parallel.ForEach(series, i => 
     { 
      Console.WriteLine("Starting Process {0}", i); 
      DoWorkAsync(i); 
      Console.WriteLine("Ending Process {0}", i); 
     }); 
     return true; 
    } 
} 

Answer 1

Die Art und Weise Sie das await Schlüsselwort verwenden sagt C#, die Sie warten möchten jedes Mal, wenn Sie die Schleife durchlaufen, die nicht parallel ist. Sie können Ihre Methode wie folgt umschreiben, indem Sie eine Liste von Task s und dann await mit Task.WhenAll speichern.

public async Task<bool> Init() 
{ 
    var series = Enumerable.Range(1, 5).ToList(); 
    var tasks = new List<Task<Tuple<int, bool>>>(); 
    foreach (var i in series) 
    { 
     Console.WriteLine("Starting Process {0}", i); 
     tasks.Add(DoWorkAsync(i)); 
    } 
    foreach (var task in await Task.WhenAll(tasks)) 
    { 
     if (task.Item2) 
     { 
      Console.WriteLine("Ending Process {0}", task.Item1); 
     } 
    } 
    return true; 
} 

public async Task<Tuple<int, bool>> DoWorkAsync(int i) 
{ 
    Console.WriteLine("working..{0}", i); 
    await Task.Delay(1000); 
    return Tuple.Create(i, true); 
} 

Answer 2

Ihr Code wartet für jeden Vorgang (mit await) vor dem Start der nächsten Iteration zu beenden.
Daher erhalten Sie keine Parallelität.

Wenn Sie eine vorhandene asynchrone Operation parallel ausführen möchten, benötigen Sie nicht await; Sie benötigen nur eine Sammlung von Task s zu erhalten und Task.WhenAll() rufen eine Aufgabe zurück, die für alle von ihnen wartet:

return Task.WhenAll(list.Select(DoWorkAsync)); 

Answer 3

public async Task<bool> Init() 
{ 
    var series = Enumerable.Range(1, 5); 
    Task.WhenAll(series.Select(i => DoWorkAsync(i))); 
    return true; 
}