Zeige den Fortschritt während ich auf alle Aufgaben in der Liste <Task> warte

Question

Ich versuche gerade kontinuierlich Punkte am Ende einer Zeile als eine Art unbestimmten Fortschritt zu drucken, während eine große Liste von Aufgaben läuft, mit diesem Code:

start = DateTime.Now; 
Console.Write("*Processing variables"); 
Task entireTask = Task.WhenAll(tasks); 
Task progress = new Task(() => { while (!entireTask.IsCompleted) { Console.Write("."); System.Threading.Thread.Sleep(1000); } }); 
progress.Start(); 
entireTask.Wait(); 
timeDiff = DateTime.Now - start; 
Console.WriteLine("\n*Operation completed in {0} seconds.", timeDiff.TotalSeconds); 

Wo tasks von List<Task> tasks = new List<Task>(); ist,
und tasks.Add(Task.Run(() => someMethodAsync())); hat 10000 des mal aufgetreten ist.
Dieser Code funktioniert derzeit, ist dies jedoch der richtige Weg, um dies zu erreichen, und ist dies der kostengünstigste Weg?

Answer 1

Es gibt sicherlich mehrere Möglichkeiten, dies zu lösen, und einer davon gehört Ihnen. Es ist jedoch nicht wirklich eine gute Übung, lange laufende Aufgaben zu starten, besonders wenn sie nichts tun als synchrones Warten (das ist Thread.Sleep).

Sie sollten Ihren Code in einem technischen und einem Domain-Teil umgestalten. Der technische Teil ist:

1. Warten Sie, bis alle Aufgaben in einer bestimmten Sammlung
2. abgeschlossen Wenn das dauert nicht mehr regelmäßig über die Fortschritte

Der folgende Code dieses ein bisschen besser zu verstehen, könnte helfen, berichtet. Es startet vier Aufgaben, die verschiedene asynchrone Vorgänge simulieren und warten, bis alle ausgeführt sind. Wenn dies länger als 250 ms dauert, ruft der Aufruf von WhenAllEx weiterhin ein Lambda zum Wiederholen des Fortschrittsberichts auf.

static void Main(string[] args) 
{ 
    var tasks = Enumerable.Range(0, 4).Select(taskNumber => Task.Run(async() => 
    { 
     Console.WriteLine("Task {0} starting", taskNumber); 
     await Task.Delay((taskNumber + 1) * 1000); 
     Console.WriteLine("Task {0} stopping", taskNumber); 
    })).ToList(); 

    // Wait for all tasks to complete and do progress report 
    var whenAll = WhenAllEx(
     tasks, 
     _ => Console.WriteLine("Still in progress. ({0}/{1} completed)", _.Count(task => task.IsCompleted), tasks.Count())); 

    // Usually never wait for asynchronous operations unless your in Main 
    whenAll.Wait(); 
    Console.WriteLine("All tasks finished"); 
    Console.ReadKey(); 
} 

/// <summary> 
/// Takes a collection of tasks and completes the returned task when all tasks have completed. If completion 
/// takes a while a progress lambda is called where all tasks can be observed for their status. 
/// </summary> 
/// <param name="tasks"></param> 
/// <param name="reportProgressAction"></param> 
/// <returns></returns> 
public static async Task WhenAllEx(ICollection<Task> tasks, Action<ICollection<Task>> reportProgressAction) 
{ 
    // get Task which completes when all 'tasks' have completed 
    var whenAllTask = Task.WhenAll(tasks); 
    for (; ;) 
    { 
     // get Task which completes after 250ms 
     var timer = Task.Delay(250); // you might want to make this configurable 
     // Wait until either all tasks have completed OR 250ms passed 
     await Task.WhenAny(whenAllTask, timer); 
     // if all tasks have completed, complete the returned task 
     if (whenAllTask.IsCompleted) 
     { 
      return; 
     } 
     // Otherwise call progress report lambda and do another round 
     reportProgressAction(tasks); 
    } 
} 

Answer 2

Thomas Antwort ist gut, Sie sollten es akzeptieren. Ich werde eine Version mit einem kleineren Code Delta bieten:

des Ersetzen:

Task progress = new Task(() => { while (!entireTask.IsCompleted) { Console.Write("."); System.Threading.Thread.Sleep(1000); } }); 
progress.Start(); 

mit diesem:

Task progressTask = Task.Run(async() => { 
while (!entireTask.IsCompleted) { 
    Console.Write("."); 
    await Task.Delay(1000); 
} 
}); 

Das ist effizienter und, ich glaube, sauberen Code.

Die Version von Thomas hatte den zusätzlichen Vorteil, dass der Fortschritts-Task sofort beendet wurde, sobald die "gesamte Aufgabe" abgeschlossen wurde.

Answer 3

Wie Thomas erwähnt, gibt es sicherlich mehrere Möglichkeiten, damit umzugehen. Derjenige, der für mich sofort in den Sinn kommt ist:

start = DateTime.Now; 
Console.Write("*Processing variables"); 
Task entireTask = Task.WhenAll(tasks); 
while (await Task.WhenAny(entireTask, Task.Delay(1000)) != entireTask) 
{ 
    Console.Write("."); 
} 
timeDiff = DateTime.Now - start; 
Console.WriteLine("\n*Operation completed in {0} seconds.", timeDiff.TotalSeconds); 

Beachten Sie, dass dieser Ansatz await nicht verwendet, so diese Methode erfordert async zu sein. Normalerweise für Konsolen-Apps, empfehle ich eine Main rufen Sie einfach MainAsync, so dass Ihre Blockierung (oder Hauptschleife) ist alles in einer Zeile Code und nicht mit irgendeiner Logik gemischt.