Skip to content

9. Asynchrone Programmierung

Das vorherige Kapitel hat Threads eingeführt: Wir können mehrere Codeabschnitte „gleichzeitig“ ausführen, synchronisieren und dem Thread-Pool Aufgaben zuweisen. Dieses Kapitel, das im Kurs von 2008 nicht enthalten war, behandelt ein verwandtes, aber eigenständiges Problem: wie man ein Programm schreibt, das lange wartet (auf die Festplatte, das Netzwerk oder eine Datenbank), ohne bei diesen Wartezeiten Threads zu blockieren. Die Antwort in .NET liegt in zwei Schlüsselwörtern der Sprache C#, [async] und [await], und in einem Typ, [Task]. Sie sind heute allgegenwärtig: Die folgenden Kapitel werden sie verwenden, um auf Datenbanken zuzugreifen ([OpenAsync], [ExecuteReaderAsync], [ToListAsync], [SaveChangesAsync]), um TCP-Server ([AcceptTcpClientAsync]), Webclients ([HttpClient]) und Webdienste mit ASP.NET Core zu schreiben.

Alle Beispiele dieses Kapitels sind Single-File-Anwendungen ([async-01.cs], [async-02.cs] …), die mit [dotnet run async-NN.cs] im Ordner [09-async] ausgeführt werden. Viele von ihnen messen Zeitdauern mit einer Stoppuhr ([Stopwatch]): Die angezeigten Millisekunden variieren von einer Ausführung zur anderen und von einem Rechner zum anderen (die Beispiele wurden auf einem Rechner mit zwei Prozessoren ausgeführt). Entscheidend sind die Größenordnungen: 1 Sekunde oder 3 Sekunden, 300 ms oder 0 ms.

9.1. Warum Asynchronität

9.1.1. Operationen, die warten

Ein Programm erledigt zwei Arten von Arbeit:

  • Rechenaufgaben, die den Prozessor belegen: eine Liste sortieren, eine Steuer berechnen, einen Text analysieren;
  • Ein- und Ausgabe (E/A), die im Wesentlichen im Warten auf ein Peripheriegerät besteht: eine Datei von der Festplatte lesen, eine Anfrage an einen Webserver senden und auf dessen Antwort warten, eine SQL-Abfrage auf einem Datenbankserver ausführen.

Die Größenordnungen sind sehr unterschiedlich. Ein Prozessor führt einige Milliarden Anweisungen pro Sekunde aus. Ein Lesevorgang auf einer Festplatte (SSD) dauert etwa eine zehntel Millisekunde; ein Hin- und Rückweg über ein lokales Netzwerk dauert den Bruchteil einer Millisekunde; ein Hin- und Rückweg zu einem Server am anderen Ende des Landes dauert einige zehn Millisekunden; und eine etwas komplexere SQL-Abfrage kann mitunter mehrere Sekunden dauern. Während dieser Wartezeiten hätte der Prozessor Millionen von Anweisungen ausführen können.

Wenn ein Programm mit einer synchronen (blockierenden) Methode eine Zeile über eine Netzwerkverbindung liest, ist der Thread, der dieses Lesen ausführt, blockiert: Er tut nichts, existiert aber weiterhin. Er belegt Speicher (seinen Stack, in der Größenordnung von einem Megabyte), er ist dem Betriebssystem bekannt, und vor allem steht er nicht mehr zur Verfügung, um etwas anderes zu tun. In einem kleinen Konsolenprogramm, das jeweils nur eine Sache erledigt, ist das kein Problem. In zwei Situationen ist es dagegen ein viel größeres Problem:

  • auf einem Server: Jeder Client, der von einem blockierten Thread bedient wird, bindet diesen Thread. Der Kurs von 2008 erklärte dies bereits im Fazit seiner Behandlung des asynchronen TCP-Clients: Wenn der Thread-Pool N Threads hat und alle N Threads eine blockierende Operation ausführen, steht für einen neuen Client kein Thread mehr zur Verfügung. Ein moderner Webserver bearbeitet Tausende gleichzeitiger Anfragen mit nur wenigen Dutzend Threads: Das ist möglich, weil seine Threads bei der E/A nie blockiert werden;
  • in einer grafischen Benutzeroberfläche: Ein einzelner Thread – der UI-Thread – verarbeitet Klicks und zeichnet Fenster neu. Wird er durch einen Download blockiert, friert das Fenster ein.

Asynchronität bedeutet, die E/A-Operation zu starten, den Thread freizugeben, während sie läuft (die Hardware und das Betriebssystem brauchen ihn nicht für die Datenübertragung), und die Arbeit nach Abschluss der Operation fortzusetzen, möglicherweise in einem anderen Thread:

Image

  • In [1] startet der Thread T1 die E/A und bleibt blockiert, bis sie beendet ist;
  • in [2] startet der Thread T1 die E/A und kehrt in den Thread-Pool zurück, wo er andere Anfragen bearbeiten kann. Wenn die E/A-Operation abgeschlossen ist, benachrichtigt das System .NET, das einen Thread aus dem Pool – T2 (oder T1, falls er verfügbar ist) – den Rest der Verarbeitung ausführen lässt.

Das Programm [async-01.cs] misst den Unterschied bei 100 Operationen, die jeweils eine Sekunde warten (das Warten simuliert E/A). Es verwendet Anweisungen, die wir später in diesem Kapitel erläutern ([Task.Run], [Task.Delay], [await]); hier interessieren uns nur die Ergebnisse.

// Warum Asynchronität: 100 Operationen, die jeweils eine Sekunde warten
// (ein Warten simuliert eine E/A-Operation: Lesen von der Festplatte, Netzwerkanfrage, SQL-Abfrage …)
using System.Diagnostics;

const int nbOperations = 100;
Console.WriteLine($"{nbOperations} operations of one second, {Environment.ProcessorCount} processors");

// 1 - ein Thread pro Operation, jeder Thread ist während des Wartens blockiert
var stopwatch = Stopwatch.StartNew();
var threads = new Thread[nbOperations];
for (int i = 0; i < nbOperations; i++)
{
    threads[i] = new Thread(() => Thread.Sleep(1000));
    threads[i].Start();
}
Display("1 - one thread per operation", ProcessThreads());
foreach (var thread in threads)
{
    thread.Join();
}
Display("    end");

// 2 - die Operationen werden an den Thread-Pool übergeben, blockieren ihn aber
stopwatch.Restart();
var tasks = new Task[nbOperations];
for (int i = 0; i < nbOperations; i++)
{
    tasks[i] = Task.Run(() => Thread.Sleep(1000));
}
Display("2 - thread pool, blocking waits", ProcessThreads());
Task.WaitAll(tasks);
Display("    end");

// 3 - asynchrone Wartezeiten: während des Wartens ist kein Thread blockiert
stopwatch.Restart();
for (int i = 0; i < nbOperations; i++)
{
    tasks[i] = Task.Delay(1000);
}
Display("3 - asynchronous waits", ProcessThreads());
await Task.WhenAll(tasks);
Display("    end");

// Anzahl der Threads des Prozesses, eine halbe Sekunde nach dem Start der Operationen
int ProcessThreads()
{
    if (stopwatch.ElapsedMilliseconds < 500)
    {
        Thread.Sleep(500 - (int)stopwatch.ElapsedMilliseconds);
    }
    using var process = Process.GetCurrentProcess();
    return process.Threads.Count;
}

// Anzeige der verstrichenen Zeit und, falls angegeben, der Anzahl der Threads
void Display(string message, int? nbThreads = null)
{
    string threadsInfo = nbThreads is null ? "" : $", {nbThreads,3} threads in the process";
    Console.WriteLine($"{message,-42} : {stopwatch.ElapsedMilliseconds,5} ms{threadsInfo}");
}

Ergebnisse:

1
2
3
4
5
6
7
8
> dotnet run async-01.cs
100 operations of one second, 2 processors
1 - one thread per operation               :   526 ms, 110 threads in the process
    end                                    :  1012 ms
2 - thread pool, blocking waits            :   501 ms,  13 threads in the process
    end                                    : 24007 ms
3 - asynchronous waits                     :   501 ms,  17 threads in the process
    end                                    :  1002 ms

Kommentare:

  • Zeilen 8–21: Die Lösung aus dem Kurs von 2008, ein Thread pro Operation. Jeder Thread führt [Thread.Sleep(1000)] aus: Er ist eine Sekunde lang blockiert. Die 100 Wartevorgänge laufen gleichzeitig ab, und der gesamte Vorgang dauert genau eine Sekunde (Zeile 4), jedoch um den Preis von 100 zusätzlichen Threads: Der Prozess hat nun mehr als 100 Threads (Zeile 3). Bei 10.000 Operationen wären 10.000 Threads erforderlich;
  • Zeilen 23–31: Die Operationen werden an den Thread-Pool delegiert ([Task.Run]), der im vorherigen Kapitel vorgestellt wurde. Der Pool startet mit so vielen Threads, wie es Prozessoren gibt (hier 2), und fügt nur schrittweise weitere hinzu, wenn alle ausgelastet sind, da er davon ausgeht, dass seine Threads Berechnungen durchführen und es nicht nötig ist, deutlich mehr Threads als Prozessoren zu haben. Hier rechnen die Threads aber nicht: Sie sind untätig. Die Operationen warten auf einen freien Thread, und der gesamte Vorgang dauert … mehr als zwanzig Sekunden (Zeile 6). Dies wird als „Thread-Pool-Starvation“ bezeichnet, der häufigste Fehler bei Servern, die Thread-Pools mit blockierender E/A kombinieren;
  • Zeilen 34–41: Die Wartevorgänge sind asynchron ([Task.Delay] statt [Thread.Sleep]). Während des Wartens ist kein Thread blockiert: Ein Systemtimer weckt .NET nach einer Sekunde. Der gesamte Vorgang dauert eine Sekunde, und die Anzahl der Threads steigt nicht (die in Zeile 7 angezeigten Threads sind diejenigen, die der Pool in Schritt 2 erzeugt hat; sie sind untätig);
  • Zeile 51: [Process.GetCurrentProcess()] ermöglicht den Zugriff auf den aktuell laufenden Prozess; seine Eigenschaft [Threads] ist die Sammlung seiner Threads (die von .NET und die des Systems).

Merken wir uns die Lehre: Um zu warten, darf man keinen Thread blockieren. Asynchronität macht E/A nicht schneller; sie erlaubt es, viele E/A-Operationen gleichzeitig mit wenigen Threads zu bewältigen und die Threads, die die Anwendung braucht, verfügbar zu halten (den GUI-Thread, die Threads im Pool eines Servers).

9.1.2. Drei aufeinanderfolgende Modelle

.NET bot drei Möglichkeiten, asynchronen Code zu schreiben. Die ersten beiden findet man noch in Legacy-Code und älteren Artikeln, daher ist es nützlich, sie zu erkennen.

Modell
Ursprung
Prinzip
APM („Asynchronous Programming Model“)
.NET 1.0 (2002)
ein Methodenpaar: [BeginXxx] und [EndXxx]. [BeginXxx] startet die Operation und erhält eine Callback-Methode ([AsyncCallback]); die Callback-Methode, die am Ende der Operation von einem Thread aus dem Pool ausgeführt wird, ruft [EndXxx] auf, um das Ergebnis oder die Ausnahme abzurufen. Beispiel: [Socket.BeginConnect] / [EndConnect], verwendet vom asynchronen TCP-Client aus dem Kurs von 2008.
EAP („Event-based Asynchronous Pattern“)
.NET 2.0 (2005)
eine Methode [XxxAsync], die die Operation startet, und ein Ereignis [XxxCompleted], das bei deren Abschluss ausgelöst wird. Beispiele: [WebClient.DownloadStringAsync] und [DownloadStringCompleted], die Klasse [BackgroundWorker] (Ereignisse [DoWork], [ProgressChanged], [RunWorkerCompleted]), die im Kurs von 2008 behandelt wurde.
TAP („Task-based Asynchronous Pattern“)
.NET 4.0 (2010), C# 5 (2012)
eine Methode [XxxAsync] , die einen Task ([Task] oder [Task<T>]) zurückgibt, der die laufende Operation darstellt. Der aufrufende Code wartet mit dem Schlüsselwort [await] auf den Task. Dies ist das aktuelle Modell, das im weiteren Verlauf des Kurses ausschließlich verwendet wird.

Die Muster APM und EAP haben denselben Nachteil: Der Code wird in Stücke zerlegt. Was natürlich als „verbinden, dann lesen, dann anzeigen“ gelesen wird, wird zu einer Methode, die die Verbindung startet, einer Callback-Methode, die das Lesen startet, und einer weiteren Callback-Methode, die die Daten anzeigt; Variablen müssen zwischen diesen Methoden geteilt werden, Ausnahmen werden an verschiedenen Stellen behandelt, und eine einfache Schleife („lesen, solange Daten vorhanden sind“) wird zu einer Callback-Methode, die sich rekursiv selbst aufruft, wie die Lesemethode ([lecture]) aus dem Kurs von 2008. Das TAP-Muster erlaubt es zusammen mit [async] und [await], asynchronen Code zu schreiben, der die Form von synchronem Code hat.

Das Programm [async-02.cs] schreibt denselben TCP-Client nach den beiden extremen Modellen, APM und TAP. Es enthält außerdem einen kleinen Server, der von einem Thread ausgeführt wird und zwei Clients antwortet (die Netzwerkprogrammierung wird in Kapitel 12 ausführlich behandelt; vorerst genügt es zu wissen, dass ein Client sich mit dem Server verbindet und die Nachricht liest, die der Server ihm sendet).

// derselbe TCP-Client, geschrieben mit dem APM-Modell von 2008 und anschließend mit dem aktuellen TAP-Modell
using System.Net;
using System.Net.Sockets;
using System.Text;

const int port = 27500;
// ein minimaler Server, ausgeführt von einem Thread: er bedient zwei Clients und endet dann
var listener = new TcpListener(IPAddress.Loopback, port);
listener.Start();
var server = new Thread(() =>
{
    for (int i = 1; i <= 2; i++)
    {
        using Socket service = listener.AcceptSocket();
        // der Server lässt sich mit der Antwort Zeit
        Thread.Sleep(500);
        service.Send(Encoding.UTF8.GetBytes($"Hello client no. {i}"));
    }
    listener.Stop();
});
server.Start();
Display("start of the program");

// 1 - das APM-Modell (Asynchronous Programming Model): BeginXxx / EndXxx und Callback-Methoden
var end = new ManualResetEventSlim(false);
byte[] buffer = new byte[1024];
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// wir starten den Verbindungsaufbau und geben die Methode an, die nach dessen Abschluss aufgerufen wird
client.BeginConnect(IPAddress.Loopback, port, Connected, client);
Display("APM: connection launched, the program goes on");
// der Hauptthread hat nichts mehr zu tun: er wartet auf das Signal der letzten Callback-Methode
end.Wait();

// Callback-Methode Nr. 1: die Verbindung ist hergestellt
void Connected(IAsyncResult result)
{
    // wir rufen das Objekt ab, das als letzter Parameter an BeginConnect übergeben wurde
    var socket = (Socket)result.AsyncState!;
    // wir beenden die Operation (erst EndConnect würde bei einem Fehlschlag die Ausnahme auslösen)
    socket.EndConnect(result);
    Display("APM: connected, read launched");
    // wir starten das Lesen der Serverantwort mit einer weiteren Callback-Methode
    socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, Received, socket);
}

// Callback-Methode Nr. 2: Daten sind eingetroffen
void Received(IAsyncResult result)
{
    var socket = (Socket)result.AsyncState!;
    int nbBytes = socket.EndReceive(result);
    Display($"APM: received [{Encoding.UTF8.GetString(buffer, 0, nbBytes)}]");
    socket.Close();
    // wir benachrichtigen den Hauptthread
    end.Set();
}

// 2 - das TAP-Modell (Task-based Asynchronous Pattern): XxxAsync und await
using (var client2 = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
    await client2.ConnectAsync(IPAddress.Loopback, port);
    Display("TAP: connected, read launched");
    int nbBytes = await client2.ReceiveAsync(buffer);
    Display($"TAP: received [{Encoding.UTF8.GetString(buffer, 0, nbBytes)}]");
}
server.Join();

// Ausgabe mit vorangestellter Nummer des Threads, der sie ausführt
static void Display(string message)
{
    Console.WriteLine($"[thread {Environment.CurrentManagedThreadId,2}] {message}");
}

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run async-02.cs
[thread  1] start of the program
[thread  1] APM: connection launched, the program goes on
[thread  6] APM: connected, read launched
[thread  6] APM: received [Hello client no. 1]
[thread  6] TAP: connected, read launched
[thread  6] TAP: received [Hello client no. 2]

Kommentare:

  • Zeilen 8–21: der Server. Er lauscht auf Port 27500 des lokalen Rechners ([IPAddress.Loopback], d. h. 127.0.0.1), akzeptiert nacheinander zwei Verbindungen und sendet jedem Client nach einer halben Sekunde eine Willkommensnachricht;
  • Zeilen 24–54: Der nach dem APM-Muster geschriebene Client, wie im Kurs von 2008:
    • Zeile 29: [BeginConnect] startet die Verbindung und gibt sofort die Kontrolle zurück (Zeile 3 der Ergebnisse). Seine letzten beiden Parameter sind die Callback-Methode, die am Ende der Verbindung aufgerufen wird, [Connected], und ein beliebiges Objekt, das die Callback-Methode in der Eigenschaft [AsyncState] ihres Parameters [IAsyncResult] vorfindet: hier der Socket selbst;
    • Zeile 32: Der Hauptthread hat nichts mehr zu tun. Damit das Programm nicht endet, bevor der Austausch abgeschlossen ist, wartet er auf ein Signal, das von der letzten Callback-Methode gesendet wird: ein Objekt [ManualResetEventSlim], dessen Methode [Wait] den aufrufenden Thread blockiert, bis ein anderer Thread seine Methode [Set] aufruft (dies ist eine leichtgewichtige Version der bei den Threads gesehenen Barrieren [AutoResetEvent]);
    • Zeilen 35–43: die Callback-Methode der Verbindung. Sie muss [EndConnect] mit dem erhaltenen Parameter aufrufen: Dieser Aufruf beendet die Operation und würde eine Ausnahme auslösen, wenn die Verbindung fehlgeschlagen wäre. Danach startet sie die Leseoperation mit [BeginReceive] und gibt eine zweite Callback-Methode an, [Received];
    • Zeilen 47–54: Die Lese-Callback-Methode ermittelt mit [EndReceive] die Anzahl der empfangenen Bytes, zeigt die Nachricht an, schließt den Socket und gibt den Hauptthread frei;
    • die Ergebnisse zeigen, dass die Callback-Methoden von einem anderen Thread als dem Hauptthread ausgeführt werden (einem Thread aus dem Pool, nicht Thread 1);
  • Zeilen 57–65: derselbe Client nach dem TAP-Modell. [ConnectAsync] und [ReceiveAsync] geben Tasks zurück, und [await] wartet auf deren Abschluss, ohne den Thread zu blockieren: Der Code liest sich von oben nach unten wie synchroner Code; die Variablen sind gewöhnliche lokale Variablen; es gibt weder Callback-Methoden noch Signale zu verwalten. Der Thread, der den Rest des Codes ausführt, ist im Allgemeinen nicht mehr Thread 1: Warum, erklären wir im Abschnitt „Welcher Thread führt den Rest aus?“;
  • Zeile 68: Jeder Anzeige wird die Nummer des Threads vorangestellt, der sie ausführt, [Environment.CurrentManagedThreadId].

Es ist nicht nötig, sich das APM-Muster zu merken. Wenn Sie eine ältere Bibliothek verwenden müssen, die nur dieses Muster anbietet, wandelt die Methode [Task.Factory.FromAsync] ein Paar [BeginXxx] / [EndXxx] in eine Methode um, die einen [Task] zurückgibt; und im Abschnitt über [TaskCompletionSource] sehen wir, wie man eine ereignisbasierte API (EAP-Modell) in einen Task umwandelt.

9.2. Tasks: Task und Task<T>

Ein Task ist ein Objekt, das eine laufende oder abgeschlossene Operation darstellt:

  • [Task] stellt eine Operation dar, die kein Ergebnis zurückgibt;
  • [Task<T>] stellt eine Operation dar, die ein Ergebnis vom Typ [T] zurückgeben wird. [Task<T>] leitet sich von [Task] ab.

Ein Task ist kein Thread. Ein Task kann von einem Thread aus dem Pool ausgeführt werden (wie bei Tasks, die mit [Task.Run] erzeugt werden), aber viele Tasks werden von keinem Thread ausgeführt: Der von [Task.Delay(1000)] zurückgegebene Task wird nach einer Sekunde einfach von einem Timer „abgeschlossen“; der von [ReceiveAsync] zurückgegebene Task wird abgeschlossen, wenn das System signalisiert, dass Daten eingetroffen sind. Ein Task ist ein Versprechen auf ein Ergebnis, das abgefragt (Ist er beendet? War er erfolgreich?) und auf das gewartet werden kann.

Das Programm [async-03.cs] zeigt die wichtigsten Möglichkeiten, einen Task zu erzeugen und auf ihn zu warten:

// Tasks: Erstellung, Warten, Status, Ergebnis, Fortsetzung

// 1 - Task.Run übergibt eine Verarbeitung an den Thread-Pool und gibt einen Task<T> zurück
Task<long> task1 = Task.Run(() =>
{
    // eine Berechnung von einigen Zehntelsekunden
    long sum = 0;
    for (int i = 1; i <= 200_000_000; i++)
    {
        sum += i % 7;
    }
    return sum;
});
Console.WriteLine($"task1 launched, status: {task1.Status}");
// await unterbricht das Programm bis zum Ende des Tasks und liefert dessen Ergebnis
long result = await task1;
Console.WriteLine($"task1 finished, status: {task1.Status}, result: {result}");

// 2 - Task.Delay gibt einen Task zurück, der nach einer Verzögerung endet, ohne einen Thread zu belegen
Task task2 = Task.Delay(300);
Console.WriteLine($"task2 launched, status: {task2.Status}");
await task2;
Console.WriteLine($"task2 finished, status: {task2.Status}");

// 3 - Tasks, die bereits abgeschlossen sind
Task<int> task3 = Task.FromResult(42);
Task task4 = Task.CompletedTask;
Console.WriteLine($"task3: status {task3.Status}, result {await task3} ; task4: status {task4.Status}");

// 4 - ein fehlschlagender Task: await löst seine Ausnahme erneut aus
Task<int> task5 = Task.Run(() => int.Parse("abc"));
try
{
    await task5;
}
catch (FormatException e)
{
    Console.WriteLine($"task5: status {task5.Status}, {e.GetType().Name}: {e.Message}");
}

// 5 - die blockierenden Formen Wait() und Result: der aktuelle Thread ist während des Wartens blockiert
Task<string> task6 = Task.Run(() =>
{
    Thread.Sleep(300);
    return "done";
});
task6.Wait();
Console.WriteLine($"task6: Wait() then Result = {task6.Result}");

// 6 - eine Fortsetzung: was zu tun ist, wenn der Task abgeschlossen ist
Task<int> task7 = Task.Delay(300).ContinueWith(t => 2 * 21);
Console.WriteLine($"task7: result of the continuation = {await task7}");

// 7 - IsCompleted, IsCompletedSuccessfully, IsFaulted, IsCanceled
Console.WriteLine($"task1: IsCompletedSuccessfully={task1.IsCompletedSuccessfully}, task5: IsCompleted={task5.IsCompleted}, IsFaulted={task5.IsFaulted}");
Console.WriteLine($"task5.Exception: {task5.Exception?.GetType().Name}, {task5.Exception?.InnerException?.GetType().Name}");

Ergebnisse:

> dotnet run async-03.cs
task1 launched, status: WaitingToRun
task1 finished, status: RanToCompletion, result: 599999998
task2 launched, status: WaitingForActivation
task2 finished, status: RanToCompletion
task3: status RanToCompletion, result 42 ; task4: status RanToCompletion
task5: status Faulted, FormatException: The input string 'abc' was not in a correct format.
task6: Wait() then Result = done
task7: result of the continuation = 42
task1: IsCompletedSuccessfully=True, task5: IsCompleted=True, IsFaulted=True
task5.Exception: AggregateException, FormatException

Kommentare:

  • Zeilen 4–12: [Task.Run] weist dem Thread-Pool eine Funktion zu und gibt sofort einen Task zurück, der ihre Ausführung darstellt. Die Funktion gibt einen [long] zurück, daher hat der Task den Typ [Task<long>]. [Task.Run] ist das Werkzeug für Berechnungen, die im Hintergrund ausgeführt werden sollen; es darf nicht dazu verwendet werden, eine blockierende E/A-Operation „asynchron zu machen“ (wie es Schritt 2 von [async-01.cs] getan hat);
  • Zeile 14: Die Eigenschaft [Status] gibt den Zustand des Tasks zurück. Unmittelbar nach dem Start wartet der Task hier darauf, dass ein Thread aus dem Pool ihn übernimmt ([WaitingToRun]); je nach Auslastung des Rechners kann auch [Running] (läuft) erscheinen;
  • Zeile 16: [await task1] wartet auf das Ende des Tasks, ohne den Thread zu blockieren, und gibt sein Ergebnis zurück, das hier den Typ [long] hat. Der Ausdruck [await t] hat den Typ [T] , wenn [t] den Typ [Task<T>] hat, und hat keinen Wert, wenn [t] den Typ [Task] hat;
  • Zeile 20: [Task.Delay(300)] gibt einen Task zurück, der in 300 ms abgeschlossen sein wird. Während dieser Zeit ist kein Thread belegt. Dies ist das asynchrone Äquivalent zu [Thread.Sleep(300)]. Sein Zustand, [WaitingForActivation], bedeutet „wartet auf ein externes Ereignis“;
  • Zeilen 26–27: [Task.FromResult(42)] gibt einen Task zurück, der bereits mit dem Ergebnis 42 abgeschlossen ist, während [Task.CompletedTask] einen Task zurückgibt, der bereits ohne Ergebnis abgeschlossen ist. Sie werden verwendet, wenn eine Methode einen Task zurückgeben muss, das Ergebnis aber bereits vorliegt (zum Beispiel ein zwischengespeicherter Wert);
  • Zeilen 31–36: Ein Task, dessen Funktion eine Ausnahme auslöst, endet mit dem Zustand [Faulted]. Die Ausnahme wird im Task aufbewahrt, und [await] löst sie erneut aus; sie wird mit einem gewöhnlichen [try / catch] abgefangen;
  • Zeilen 42–48: [Wait()] wartet auf das Ende des Tasks, indem es den aktuellen Thread blockiert, und die Eigenschaft [Result] gibt das Ergebnis eines [Task<T>] zurück und blockiert dabei ebenfalls den Thread, wenn der Task nicht beendet ist. Dies sind die Formen des Thread-Wartens aus dem vorherigen Kapitel ([Join]). Sie sollten vermieden werden: Sie haben alle Nachteile blockierender E/A, verpacken Ausnahmen in eine [AggregateException] (Zeile 56) und können in einer grafischen Anwendung einen Deadlock verursachen. Sie sollten den seltenen Fällen vorbehalten bleiben, in denen Sie wissen, dass der Task bereits abgeschlossen ist;
  • Zeile 51: [ContinueWith] hängt an einen Task eine Fortsetzung an – eine Funktion, die ausgeführt wird, wenn der Task abgeschlossen ist. Die Fortsetzung erhält den abgeschlossenen Task und gibt hier eine ganze Zahl zurück: Daraus entsteht ein neuer Task, [Task<int>]. So wurde mit .NET 4.0 asynchroner Code geschrieben, vor [await]; [await] beruht auf einem ähnlichen Mechanismus (Registrierung einer Abfolge, die am Ende des Tasks ausgeführt wird), den der Compiler jedoch sicherer umsetzt. [ContinueWith] wird kaum noch direkt verwendet;
  • Zeilen 54–56: die Booleschen Eigenschaften [IsCompleted] (beendet, gleichgültig wie), [IsCompletedSuccessfully] (erfolgreich beendet), [IsFaulted] (mit einer Ausnahme beendet), [IsCanceled] (abgebrochen) und die Eigenschaft [Exception] vom Typ [AggregateException], die die Ausnahme(n) des Tasks enthält.

Die möglichen Werte der Eigenschaft [Status] (Enumeration [TaskStatus]) lauten wie folgt:

Zustand
Bedeutung
[Created]
Der Task wurde durch einen Konstruktor erzeugt und noch nicht gestartet (Tasks werden selten über [new Task(...)] erzeugt)
[WaitingForActivation]
Der Task wartet auf ein externes Ereignis: das Ende einer Zeitüberschreitung, eine E/A-Operation oder einen anderen Task
[WaitingToRun]
Der Task wartet darauf, dass ein Thread aus dem Pool verfügbar wird
[Running]
Der Task wird gerade von einem Thread ausgeführt
[WaitingForChildrenToComplete]
Der Task ist abgeschlossen, wartet aber auf angehängte „Kind“-Tasks (seltener Fall)
[RanToCompletion]
Der Task wurde erfolgreich abgeschlossen
[Faulted]
Der Task wurde aufgrund einer nicht abgefangenen Ausnahme beendet
[Canceled]
Der Task wurde abgebrochen (siehe den Abschnitt über den Abbruch)

Die letzten drei Zustände sind Endzustände: Ein abgeschlossener Task ändert seinen Zustand nicht mehr.

9.3. Asynchrone Methoden: async und await

9.3.1. Eine asynchrone Methode schreiben

Eine Methode, die [await] enthält, muss mit dem Modifizierer [async] deklariert werden. Sie gibt Folgendes zurück:

  • [Task] , wenn sie kein Ergebnis zurückgibt (das Äquivalent zu [void]);
  • [Task<T>] , wenn sie ein Ergebnis vom Typ [T] zurückgibt: Innerhalb der Methode schreiben Sie [return value;] mit einem Wert vom Typ [T], und der Compiler verpackt ihn im Task.

Per Konvention endet der Name einer Methode, die einen Task zurückgibt, auf [Async]: [ReadAllTextAsync], [ConnectAsync], [MakeCoffeeAsync].

Das Programm [async-04.cs] kocht Kaffee und zählt Zuckerwürfel:

// asynchrone Methoden: async Task, async Task<T> und Ausführungsreihenfolge
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
Display("call of MakeCoffeeAsync");
Task making = MakeCoffeeAsync();
Display("MakeCoffeeAsync has returned control: the program goes on");
Display("call of CountSugarsAsync");
Task<int> counting = CountSugarsAsync(3);
Display("CountSugarsAsync has returned control");
// wir warten jetzt auf die beiden Ergebnisse
await making;
int nbSugars = await counting;
Display($"coffee ready, with {nbSugars} sugar(s)");

// eine asynchrone Methode, die kein Ergebnis zurückgibt: sie gibt einen Task zurück
async Task MakeCoffeeAsync()
{
    Display("  coffee: the machine is heating");
    // beim ersten Warten (await) auf einen nicht abgeschlossenen Task gibt die Methode die Kontrolle an ihren Aufrufer zurück
    await Task.Delay(1000);
    // der Rest wird ausgeführt, wenn die Verzögerung abgelaufen ist
    Display("  coffee: the machine is pouring the coffee");
    await Task.Delay(500);
    Display("  coffee: done");
}

// eine asynchrone Methode, die eine ganze Zahl zurückgibt: sie gibt einen Task<int> zurück
async Task<int> CountSugarsAsync(int count)
{
    for (int i = 1; i <= count; i++)
    {
        await Task.Delay(200);
        Display($"  sugar no. {i}");
    }
    // wir geben ein int zurück, der Compiler verpackt es in den Task<int>
    return count;
}

// Ausgabe mit der seit dem Start verstrichenen Zeit
void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

Ergebnisse:

> dotnet run async-04.cs
    1 ms : call of MakeCoffeeAsync
   29 ms :   coffee: the machine is heating
   33 ms : MakeCoffeeAsync has returned control: the program goes on
   33 ms : call of CountSugarsAsync
   36 ms : CountSugarsAsync has returned control
  237 ms :   sugar no. 1
  436 ms :   sugar no. 2
  636 ms :   sugar no. 3
 1031 ms :   coffee: the machine is pouring the coffee
 1532 ms :   coffee: done
 1532 ms : coffee ready, with 3 sugar(s)

Kommentare:

  • Zeilen 17–25: eine asynchrone Methode ohne Rückgabewert. Sie wird normal, synchron ausgeführt, bis sie auf ihr erstes [await] bei einem nicht abgeschlossenen Task trifft (Zeile 21). An diesem Punkt gibt sie die Kontrolle an ihren Aufrufer zurück und reicht einen nicht abgeschlossenen Task zurück, der sie darstellt; deshalb erscheint Zeile 4 der Ergebnisse unmittelbar nach Zeile 3 und nicht erst eine Sekunde später;
  • Zeile 23: Wenn die Zeitüberschreitung von einer Sekunde verstrichen ist, setzt die Methode ihre Ausführung unmittelbar nach dem [await] fort, mit unversehrten lokalen Variablen, bis zum nächsten [await] oder bis zu ihrem Ende. Wenn sie endet, wechselt der an den Aufrufer zurückgegebene Task in den Zustand [RanToCompletion];
  • Zeilen 29–37: eine asynchrone Methode, die eine ganze Zahl zurückgibt: Ihr Rückgabetyp ist [Task<int>], aber die Anweisung [return] gibt ein [int] zurück;
  • Zeilen 6–9: Das Hauptprogramm ruft beide Methoden auf, ohne auf sie zu warten. Es erhält zwei Tasks und setzt die Ausführung fort. Die beiden Methoden laufen dann „gleichzeitig“ ab: Der Zucker wird gezählt (Zeilen 7–9), während die Maschine aufheizt;
  • Zeilen 12–13: Das Hauptprogramm wartet auf beide Tasks. Der Kaffee ist nach 1,5 Sekunden fertig – der Dauer der längeren der beiden Operationen – und nicht nach 2,1 Sekunden (1,5 + 3 × 0,2).

Wichtig ist: [async] macht eine Methode nicht asynchron: Es erlaubt lediglich die Verwendung von [await] innerhalb der Methode. Eine [async]-Methode, die auf keinen nicht abgeschlossenen Task wartet, wird vollständig synchron ausgeführt (der Compiler gibt tatsächlich eine Warnung für eine [async]-Methode aus, die kein [await] enthält). Es sind die erwarteten Operationen ([Task.Delay], asynchrone E/A), die tatsächlich asynchron sind.

9.3.2. Was der Compiler tut

Wie kann eine Methode mitten in einer Schleife unterbrochen werden, die Kontrolle abgeben und später an derselben Stelle mit denselben Werten der lokalen Variablen fortgesetzt werden? Der Compiler wandelt die [async]-Methode in eine Zustandsmaschine um: eine Klasse (in der optimierten Version des Programms, die im Modus „Release“ kompiliert wird, eine Struktur), deren Felder die lokalen Variablen der Methode sowie eine Zustandsnummer sind, die angibt, wo fortzufahren ist. Für die Methode [CountSugarsAsync] sieht der erzeugte Code in etwa so aus:

// was der Compiler erzeugt (stark vereinfacht)
Task<int> CountSugarsAsync(int count)
{
    var machine = new CountSugarsMachine { count = count, state = 0 };
    machine.Advance();         // führt die Methode bis zum ersten await aus
    return machine.ResultTask; // der Task, den die Zustandsmaschine später abschließen wird
}

class CountSugarsMachine
{
    public int count, i, state;               // die lokalen Variablen werden zu Feldern
    public TaskCompletionSource<int> Source = new();
    public Task<int> ResultTask => Source.Task;

    public void Advance()
    {
        if (state == 0) { i = 1; }             // erster Durchlauf: Beginn der Schleife
        else { Console.WriteLine($"  sugar no. {i}"); i++; }   // Fortsetzung nach dem await
        if (i <= count)
        {
            state = 1;
            // wir bitten darum, am Ende der Verzögerung aufgerufen zu werden, und geben dann die Kontrolle zurück
            Task.Delay(200).GetAwaiter().OnCompleted(Advance);
            return;
        }
        Source.SetResult(count);               // Ende der Methode: der Task ist abgeschlossen
    }
}

Dies folgt demselben Prinzip wie die Callback-Methoden im APM-Modell ([OnCompleted(Advance)] fordert am Ende der Operation einen Callback an), aber der Compiler zerlegt die Methode, sichert die Variablen und behandelt die Ausnahmen. Der Entwickler schreibt dagegen eine Methode, die sich von oben nach unten liest. Den tatsächlich erzeugten Code können Sie mit einem Decompiler wie ILSpy oder auf der Website SharpLab ansehen; er ist deutlich länger, insbesondere weil er den Fall behandelt, dass der erwartete Task bereits abgeschlossen ist (dann läuft die Ausführung ohne Unterbrechung weiter), sowie den Fall von Ausnahmen.

9.3.3. Welcher Thread führt den Rest des Codes aus?

Das Programm [async-05.cs] zeigt die Nummer des Threads an, der jeden Codeabschnitt ausführt:

// Welcher Thread führt den Rest einer Methode nach einem await aus?
Display("start of the program");
Display($"synchronization context: {SynchronizationContext.Current?.GetType().Name ?? "none"}");

// 1 - await eines bereits abgeschlossenen Tasks: keine Unterbrechung, wir bleiben im selben Thread
await Task.CompletedTask;
Display("after await Task.CompletedTask");

// 2 - await eines nicht abgeschlossenen Tasks: der Rest wird von einem Pool-Thread ausgeführt
for (int i = 1; i <= 3; i++)
{
    await Task.Delay(100);
    Display($"after await Task.Delay(100) no. {i}");
}

// 3 - während des Wartens ist der Thread frei: er kann etwas anderes ausführen
Task t1 = WorkAsync("A");
Task t2 = WorkAsync("B");
await Task.WhenAll(t1, t2);
Display($"end of the program, threads created by the pool: {ThreadPool.ThreadCount}");

async Task WorkAsync(string name)
{
    for (int i = 1; i <= 3; i++)
    {
        Display($"  {name}{i} : before await");
        await Task.Delay(100);
    }
}

// Ausgabe mit vorangestellter Nummer des Threads, der sie ausführt
static void Display(string message)
{
    Console.WriteLine($"[thread {Environment.CurrentManagedThreadId,2}] {message}");
}

Ergebnisse:

> dotnet run async-05.cs
[thread  1] start of the program
[thread  1] synchronization context: none
[thread  1] after await Task.CompletedTask
[thread  5] after await Task.Delay(100) no. 1
[thread  5] after await Task.Delay(100) no. 2
[thread  5] after await Task.Delay(100) no. 3
[thread  5]   A1 : before await
[thread  5]   B1 : before await
[thread  6]   A2 : before await
[thread  5]   B2 : before await
[thread  6]   B3 : before await
[thread  5]   A3 : before await
[thread  6] end of the program, threads created by the pool: 2

Kommentare:

  • Zeile 3: [SynchronizationContext.Current] ist der Synchronisationskontext des aktuellen Threads. In einem Konsolenprogramm gibt es keinen (Wert [null]); im Abschnitt über [ConfigureAwait] werden wir die Rolle sehen, die er in grafischen Benutzeroberflächen spielt;
  • Zeile 6: Das Warten auf einen bereits abgeschlossenen Task unterbricht die Methode nicht: Die Ausführung wird sofort im selben Thread fortgesetzt (Thread 1, Zeile 4);
  • Zeilen 10–13: Nach dem Warten auf einen nicht abgeschlossenen Task und ohne Synchronisationskontext wird der Rest der Methode von einem beliebigen Thread aus dem Pool ausgeführt. Thread 1, der Thread des Hauptprogramms, wird nicht mehr verwendet: Während des Wartens hatte er nichts zu tun. In einer asynchronen Methode darf man daher nie davon ausgehen, dass der Code nach einem [await] vom selben Thread ausgeführt wird wie der Code davor;
  • Zeilen 17–19: Zwei Aufrufe der Methode [WorkAsync] laufen gleichzeitig ab. Die sechs Codeblöcke werden von einem oder zwei Threads aus dem Pool ausgeführt (das variiert von Ausführung zu Ausführung), die beim Warten zwischen A und B wechseln: Während der eine wartet, arbeitet der andere. Kein Thread ist A oder B zugeordnet, und während der Wartezeiten ist keiner blockiert;
  • Zeile 20: [ThreadPool.ThreadCount] gibt die Anzahl der Threads zurück, die der Pool derzeit erzeugt hat: nur wenige.

Diese Art, mehrere Operationen gleichzeitig auszuführen, ohne die Anzahl der Threads zu erhöhen, nennt man Nebenläufigkeit. Sie unterscheidet sich vom Parallelismus, bei dem mehrere Berechnungen gleichzeitig auf mehreren Prozessoren ausgeführt werden (wie im vorherigen Kapitel besprochen: [Parallel.For], [Task.Run]). Asynchronität erleichtert die E/A-Nebenläufigkeit; sie macht Berechnungen nicht schneller.

9.3.4. Das asynchrone Hauptprogramm

Die vorherigen Programme verwenden [await] direkt in Top-Level-Anweisungen. Dies ist seit C# 9 möglich: Enthalten Top-Level-Anweisungen ein [await], erzeugt der Compiler eine asynchrone Methode [Main] mit der Signatur [static async Task Main(string[] args)] (oder [Task<int>] , wenn das Programm [return integer;] verwendet).

Sie können diese Methode auch explizit schreiben, was seit C# 7.1 möglich ist. Das zeigt das Programm [async-06.cs]:

// die explizite Form einer asynchronen Main-Methode
namespace Async06;

public static class Program
{
    // Main kann Task oder Task<int> zurückgeben (der Exitcode des Programms)
    public static async Task<int> Main(string[] args)
    {
        // die Anzahl der Sekunden wird als Argument übergeben
        if (args.Length != 1 || !int.TryParse(args[0], out int nbSeconds) || nbSeconds < 0)
        {
            Console.WriteLine("syntax: dotnet run async-06.cs -- nbSeconds");
            return 1;
        }
        for (int i = nbSeconds; i > 0; i--)
        {
            Console.WriteLine($"{i} s left");
            await Task.Delay(1000);
        }
        Console.WriteLine("finished");
        return 0;
    }
}

Ergebnisse, zuerst mit und dann ohne Argument:

1
2
3
4
5
> dotnet run async-06.cs -- 3
3 s left
2 s left
1 s left
finished
> dotnet run async-06.cs
syntax: dotnet run async-06.cs -- nbSeconds

Erläuterungen:

  • Zeile 7: Die Methode [Main] ist asynchron und gibt einen [Task<int>] zurück. Die Ganzzahl ist der Exitcode des Programms (0 bei Erfolg, jeder andere Wert bei einem Fehler), der von einem Skript ausgewertet werden kann ([echo $?] unter Linux, [echo %ERRORLEVEL%] unter Windows);
  • Zeile 10: Das Argument ist die Anzahl der Sekunden für den Countdown. Es wird nach [--] im Befehl [dotnet run async-06.cs -- 3] übergeben;
  • Zeile 18: eine Wartezeit von einer Sekunde, ohne Threads zu blockieren.

Wenn [Main] asynchron ist, ruft die Laufzeitumgebung die Methode auf, nimmt den zurückgegebenen Task entgegen und wartet auf dessen Abschluss, bevor das Programm beendet wird. Dies ist die einzige Stelle, an der ein blockierendes Warten stattfindet, und zwar durch .NET selbst.

9.4. Sequenzielle und nebenläufige Ausführung

9.4.1. Task.WhenAll

Das Kaffeebeispiel hat es gezeigt: Der Zeitpunkt, zu dem eine asynchrone Operation gestartet wird und der Zeitpunkt, zu dem auf sie gewartet wird, können verschieden sein. Die Schreibweise [await MethodAsync()] startet die Operation und wartet sofort auf sie; die Schreibweise [var t = MethodAsync();] mit einem späteren [await t;] erlaubt es, dazwischen weitere Operationen zu starten. Das Programm [async-07.cs] vergleicht beide Vorgehensweisen anhand von drei einsekündigen Operationen:

// sequenzielle und nebenläufige Ausführung von drei Operationen von je einer Sekunde
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - nacheinander: jede Operation wartet auf das Ende der vorherigen
int a = await ReadTemperatureAsync("Angers");
int b = await ReadTemperatureAsync("Brest");
int c = await ReadTemperatureAsync("Colmar");
Console.WriteLine($"in sequence: {a}, {b}, {c} in {stopwatch.ElapsedMilliseconds} ms");

// 2 - nebenläufig: wir starten die drei Operationen und warten dann auf sie
stopwatch.Restart();
Task<int> ta = ReadTemperatureAsync("Angers");
Task<int> tb = ReadTemperatureAsync("Brest");
Task<int> tc = ReadTemperatureAsync("Colmar");
await Task.WhenAll(ta, tb, tc);
Console.WriteLine($"concurrently: {ta.Result}, {tb.Result}, {tc.Result} in {stopwatch.ElapsedMilliseconds} ms");

// 3 - Task.WhenAll auf einer Sammlung von Task<T> liefert direkt das Array der Ergebnisse
stopwatch.Restart();
string[] cities = ["Angers", "Brest", "Colmar", "Dijon", "Évry", "Foix"];
int[] temperatures = await Task.WhenAll(cities.Select(ReadTemperatureAsync));
Console.WriteLine($"{cities.Length} cities: [{string.Join(", ", temperatures)}] in {stopwatch.ElapsedMilliseconds} ms");

// simuliert die Abfrage eines entfernten Dienstes, der in einer Sekunde antwortet
static async Task<int> ReadTemperatureAsync(string city)
{
    await Task.Delay(1000);
    // eine „Temperatur“, abgeleitet vom Namen der Stadt
    return 10 + city.Length;
}

Ergebnisse:

1
2
3
4
> dotnet run async-07.cs
in sequence: 16, 15, 16 in 3007 ms
concurrently: 16, 15, 16 in 1001 ms
6 cities: [16, 15, 16, 15, 14, 14] in 1005 ms

Erläuterungen:

  • Zeilen 7–9: Jede Operation wird gestartet und abgewartet, bevor die nächste beginnt. Der Code blockiert keine Threads, aber die drei Operationen laufen nacheinander ab: 3 Sekunden (Zeile 2). Dies ist der richtige Ansatz, wenn eine Operation das Ergebnis der vorherigen benötigt;
  • Zeilen 14–16: Die drei Operationen werden gestartet, ohne aufeinander zu warten. Sie laufen gleichzeitig;
  • Zeile 17: [Task.WhenAll] gibt einen Task zurück, der abgeschlossen ist, wenn alle ihm übergebenen Tasks beendet sind. Wir warten darauf mit [await]: 1 Sekunde statt 3 (Zeile 3);
  • Zeile 18: Die drei Tasks sind abgeschlossen, daher liefert die Eigenschaft [Result] ihr Ergebnis, ohne zu blockieren. Wir hätten auch [await ta] schreiben können, was das Ergebnis eines abgeschlossenen Tasks sofort zurückgibt;
  • Zeile 23: Wird eine Sammlung von [Task<T>] übergeben, [Task.WhenAll] gibt es einen [Task<T[]>] zurück, dessen Ergebnis das Array der Ergebnisse ist, und zwar in der Reihenfolge der Tasks (nicht in der Reihenfolge, in der sie abgeschlossen wurden). Der LINQ-Ausdruck [cities.Select(ReadTemperatureAsync)] ruft die Methode für jede Stadt auf und erzeugt so sechs gleichzeitig gestartete Tasks. Die sechs Operationen zusammen dauern eine Sekunde.

[Task.WhenAll] ist das asynchrone Gegenstück zu [Task.WaitAll] (verwendet in [async-01.cs]), das auf alle Tasks wartet und dabei den aktuellen Thread blockiert.

9.4.2. Task.WhenAny

[Task.WhenAny] gibt einen Task zurück, der endet, sobald irgendeiner der ihm übergebenen Tasks abgeschlossen ist; sein Ergebnis ist dieser zuerst abgeschlossene Task. Das Programm [async-08.cs] nutzt ihn auf zwei Arten:

// Task.WhenAny: auf den ersten abgeschlossenen Task reagieren
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - wir fragen drei Spiegelserver ab und behalten die erste Antwort
Task<string>[] requests =
[
    QueryAsync("mirror-paris", 800),
    QueryAsync("mirror-lyon", 300),
    QueryAsync("mirror-lille", 600),
];
// WhenAny gibt den ersten abgeschlossenen Task zurück (einen Task<string>)
Task<string> first = await Task.WhenAny(requests);
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : first answer: {await first}");
// die anderen Anfragen laufen weiter: wir warten hier auf sie, um ihre Antworten zu sehen
await Task.WhenAll(requests);
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : all the answers: {string.Join(", ", requests.Select(t => t.Result))}");

// 2 - eine zeitlich begrenzte Operation: wir lassen sie gegen eine Verzögerung „antreten“
stopwatch.Restart();
Task<string> slow = QueryAsync("slow-server", 2000);
Task winner = await Task.WhenAny(slow, Task.Delay(500));
if (winner == slow)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : answer obtained in time: {await slow}");
}
else
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : the slow server did not answer within the 500 ms delay");
}

// simuliert einen Server, der nach [duration] Millisekunden antwortet
static async Task<string> QueryAsync(string server, int duration)
{
    await Task.Delay(duration);
    return $"{server} ({duration} ms)";
}

Ergebnisse:

1
2
3
4
> dotnet run async-08.cs
  309 ms : first answer: mirror-lyon (300 ms)
  803 ms : all the answers: mirror-paris (800 ms), mirror-lyon (300 ms), mirror-lille (600 ms)
  500 ms : the slow server did not answer within the 500 ms delay

Erläuterungen:

  • Zeilen 7–11: Es werden drei Spiegelserver abgefragt; sie enthalten alle dieselben Informationen, antworten aber unterschiedlich schnell. Die drei Tasks werden in einem Array gespeichert, das mit einem Sammlungsausdruck initialisiert wird;
  • Zeile 14: [await Task.WhenAny(requests)] gibt den zuerst abgeschlossenen Task vom Typ [Task<string>] zurück. Um sein Ergebnis zu erhalten, warten wir ihrerseits darauf (Zeile 15): Er ist abgeschlossen, daher liefert [await] die Zeichenkette sofort. Die erste Antwort trifft nach 300 ms ein (Zeile 2);
  • Zeile 17: Die anderen Anfragen werden von [WhenAny] nicht angehalten; sie laufen bis zu ihrem Ende weiter. Um sie zu stoppen, müssten sie abgebrochen werden, was wir im Abschnitt über den Abbruch behandeln. Hier warten wir darauf, dass alle Antworten angezeigt werden;
  • Zeilen 22–24: ein klassischer Einsatz von [WhenAny]: die Wartezeit zu begrenzen, indem man ein „Rennen“ zwischen der Operation und einem Timeout veranstaltet. Gewinnt das Timeout, hat die Operation zu lange gedauert. .NET bietet inzwischen einen direkteren Weg für diesen Fall: die Methode [WaitAsync], die weiter unten behandelt wird.

9.4.3. Task.WhenEach

Häufig möchte man die Ergebnisse mehrerer Operationen verarbeiten, sobald sie vorliegen, ohne auf die langsamste zu warten. Vor .NET 9 schrieb man dafür eine Schleife, die [Task.WhenAny] aufrief, den zurückgegebenen Task verarbeitete und ihn aus der Liste entfernte. Mit .NET 9 wurde die Methode [Task.WhenEach] eingeführt, die die Tasks in der Reihenfolge ihres Abschlusses in Form eines asynchronen Streams zurückgibt, der mit [await foreach] durchlaufen wird (asynchrone Streams werden weiter unten in diesem Kapitel behandelt).

Das Programm [async-09.cs] verarbeitet fünf „Dateien“, deren Verarbeitung jeweils zwischen 100 und 900 ms dauert:

// Task.WhenEach (.NET 9): die Ergebnisse in der Reihenfolge verarbeiten, in der die Tasks enden
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
int[] durations = [900, 300, 700, 100, 500];
// wir starten alle Tasks
List<Task<string>> tasks = durations.Select((duration, i) => ProcessAsync($"file{i}.txt", duration)).ToList();

// await foreach: jeder Task wird geliefert, sobald er abgeschlossen ist
await foreach (Task<string> task in Task.WhenEach(tasks))
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {await task}");
}
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : all the files have been processed");

// simuliert die Verarbeitung einer Datei, die [duration] Millisekunden dauert
static async Task<string> ProcessAsync(string file, int duration)
{
    await Task.Delay(duration);
    return $"{file} processed in {duration} ms";
}

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run async-09.cs
  111 ms : file3.txt processed in 100 ms
  312 ms : file1.txt processed in 300 ms
  509 ms : file4.txt processed in 500 ms
  710 ms : file2.txt processed in 700 ms
  906 ms : file0.txt processed in 900 ms
  906 ms : all the files have been processed

Erläuterungen:

  • Zeile 7: Die fünf Verarbeitungen werden gestartet. Die LINQ-Methode [Select] übergibt der Funktion das Element und seinen Index ([(duration, i)]);
  • Zeilen 10–12: [Task.WhenEach(tasks)] liefert jeden Task sobald er abgeschlossen ist: zuerst Datei 3 (100 ms), zuletzt Datei 0 (900 ms). Die Schleife [await foreach] wartet auf den nächsten Task, ohne Threads zu blockieren. Jeder gelieferte Task ist abgeschlossen: [await task] gibt sein Ergebnis sofort zurück;
  • die gesamte Verarbeitung dauert 900 ms – die Dauer des längsten Verarbeitungsschritts – und jedes Ergebnis wird so früh wie möglich angezeigt.

9.5. Ausnahmen in asynchronem Code

9.5.1. Weitergabe über [await]

Eine in einer asynchronen Methode ausgelöste Ausnahme wird beim Aufruf nicht an den Aufrufer weitergegeben: Sie wird im Task gespeichert, der in den Zustand [Faulted] übergeht. Erst die Anweisung [await] löst sie erneut aus. Das Programm [async-10.cs] untersucht die verschiedenen Fälle:

// Ausnahmen in asynchronem Code

// 1 - await löst die Ausnahme des erwarteten Tasks erneut aus
try
{
    int value = await ReadValueAsync("twelve");
    Console.WriteLine($"value = {value}");
}
catch (FormatException e)
{
    Console.WriteLine($"1 - exception caught: {e.GetType().Name} : {e.Message}");
}

// 2 - der Aufruf einer async-Methode löst keine Ausnahme aus: sie wird im Task gespeichert
// (hier tritt die Ausnahme schon vor dem ersten await der Methode auf)
Task<int> task = ReadValueAsync("");
Console.WriteLine($"2 - after the call: status={task.Status}");
try
{
    await task;
}
catch (ArgumentException e)
{
    Console.WriteLine($"2 - it is the await that throws the exception: {e.GetType().Name} : {e.Message}");
}

// 3 - Task.WhenAll mit mehreren fehlgeschlagenen Tasks
Task<int>[] tasks = [ReadValueAsync("1"), ReadValueAsync("two"), ReadValueAsync("3"), ReadValueAsync("four")];
Task<int[]> all = Task.WhenAll(tasks);
try
{
    int[] values = await all;
}
catch (Exception e)
{
    // await löst nur die erste Ausnahme erneut aus …
    Console.WriteLine($"3 - await rethrows: {e.GetType().Name} : {e.Message}");
    // … aber alle befinden sich in der Eigenschaft Exception des Tasks, vom Typ AggregateException
    AggregateException ae = all.Exception!;
    Console.WriteLine($"3 - {ae.GetType().Name} with {ae.InnerExceptions.Count} exceptions:");
    foreach (Exception inner in ae.InnerExceptions)
    {
        Console.WriteLine($"      {inner.GetType().Name} : {inner.Message}");
    }
    // die erfolgreichen Tasks haben tatsächlich ihr Ergebnis
    foreach (Task<int> t in tasks.Where(t => t.IsCompletedSuccessfully))
    {
        Console.WriteLine($"      successful task, result = {t.Result}");
    }
}

// 4 - die blockierenden Formen verpacken die Ausnahme in eine AggregateException
try
{
    int value = ReadValueAsync("five").Result;
}
catch (AggregateException e)
{
    Console.WriteLine($"4 - Result throws: {e.GetType().Name} containing {e.InnerException?.GetType().Name}");
}

// eine asynchrone Methode, die fehlschlägt, wenn die Zeichenkette keine ganze Zahl ist
static async Task<int> ReadValueAsync(string text)
{
    // sofortige Prüfung des Parameters, vor jedem await
    ArgumentException.ThrowIfNullOrWhiteSpace(text);
    // das Lesen dauert ein wenig
    await Task.Delay(100);
    return int.Parse(text);
}

Ergebnisse:

> dotnet run async-10.cs
1 - exception caught: FormatException : The input string 'twelve' was not in a correct format.
2 - after the call: status=Faulted
2 - it is the await that throws the exception: ArgumentException : The value cannot be an empty string or composed entirely of whitespace. (Parameter 'text')
3 - await rethrows: FormatException : The input string 'two' was not in a correct format.
3 - AggregateException with 2 exceptions:
      FormatException : The input string 'two' was not in a correct format.
      FormatException : The input string 'four' was not in a correct format.
      successful task, result = 1
      successful task, result = 3
4 - Result throws: AggregateException containing FormatException

Erläuterungen:

  • Zeilen 63–69: die getestete Methode. Sie prüft zunächst ihren Parameter ([ArgumentException.ThrowIfNullOrWhiteSpace] löst eine [ArgumentException] aus, wenn die Zeichenkette [null], leer oder nur aus Leerzeichen besteht), wartet 100 ms und konvertiert dann die gesamte Zeichenkette, wobei eine [FormatException] ausgelöst wird, wenn die Zeichenkette keine Zahl ist;
  • Zeilen 3–11: der Standardfall. Die von [int.Parse] nach dem [await] der Methode ausgelöste Ausnahme wird vom [await] des Aufrufers erneut ausgelöst: Ein [try / catch] um das [await] fängt sie ab, genau wie bei einem synchronen Aufruf. Das ist die große Vereinfachung durch [await]: Beim APM-Modell wurde die Ausnahme von [EndXxx] in der Callback-Methode erneut ausgelöst, weit entfernt vom Code, der die Operation gestartet hatte;
  • Zeilen 16–24: Hier wird die Ausnahme schon vor dem ersten [await] in der Methode ausgelöst. Der Aufruf selbst löst jedoch nichts aus: Die Methode [async] gibt einen bereits fehlgeschlagenen Task zurück (Status [Faulted], Zeile 3), und erst das [await] löst die Ausnahme aus. Eine [async]-Methode löst beim Aufruf nie eine Ausnahme aus;
  • Zeilen 28–32: [Task.WhenAll] wartet auf vier Tasks, von denen zwei fehlschlagen. Der Task [all] schlägt dann ebenfalls fehl und enthält beide Ausnahmen. [await] löst jedoch nur eine davon erneut aus, nämlich die erste (Zeile 5): Die Sprachentwickler haben sich dafür entschieden, die übliche Form von [catch] beizubehalten (es wird eine [FormatException] abgefangen, kein Wrapper);
  • Zeilen 39–43: Um alle Ausnahmen einzusehen, konsultieren Sie die Eigenschaft [Exception] des Tasks [all]. Sie hat den Typ [AggregateException], eine Ausnahme, die andere Ausnahmen enthält, die über ihre Eigenschaft [InnerExceptions] zugänglich sind;
  • Zeilen 46–48: Das Fehlschlagen von [WhenAll] verhindert nicht, dass die anderen Tasks erfolgreich sind; ihre Ergebnisse sind verfügbar;
  • Zeilen 52–59: Die blockierenden Formen ([Result], [Wait()]) lösen nicht die Ausnahme selbst erneut aus, sondern eine [AggregateException] , die sie enthält. Das ist ein weiterer Grund, [await] ihnen vorzuziehen.

9.5.2. async void: zu vermeiden

Eine [async]-Methode kann auch als [void] deklariert werden. In diesem Fall gibt sie keinen Task zurück, was zwei gravierende Folgen hat: Der Aufrufer kann nicht wissen, wann sie endet (er kann nicht auf sie warten), und er kann ihre Ausnahmen nicht abfangen. Eine nicht abgefangene Ausnahme in einer [async void]-Methode wird in einem Thread des Pools erneut ausgelöst, wo niemand sie abfangen kann: Sie beendet das Programm. Das Programm [async-11.cs] demonstriert dies:

// warum man keine async-void-Methode schreiben darf

// wir zeigen die Meldung einer unbehandelten Ausnahme an und beenden dann das Programm
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
    var exception = (Exception)e.ExceptionObject;
    Console.WriteLine($"unhandled exception: {exception.GetType().Name} : {exception.Message}");
    Console.WriteLine("the process is going to be stopped");
    Environment.Exit(1);
};

// 1 - eine async-Task-Methode: der Aufrufer kann sie erwarten (await) und ihre Ausnahme abfangen
try
{
    await SaveAsync("a");
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"1 - async Task: exception caught: {e.Message}");
}

// 2 - eine async-void-Methode: der Aufrufer kann sie weder erwarten (await) noch ihre Ausnahme abfangen
try
{
    Save("b");
    Console.WriteLine("2 - async void: the method has returned control, the try saw nothing");
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"2 - async void: exception caught: {e.Message}");
}
// das Programm setzt seine Arbeit fort …
for (int i = 1; i <= 5; i++)
{
    await Task.Delay(100);
    Console.WriteLine($"the program is working ({i})");
}
Console.WriteLine("normal end of the program");

static async Task SaveAsync(string data)
{
    await Task.Delay(200);
    throw new InvalidOperationException($"failure saving [{data}]");
}

// NICHT NACHMACHEN: async void ist Ereignishandlern vorbehalten
static async void Save(string data)
{
    await Task.Delay(200);
    throw new InvalidOperationException($"failure saving [{data}]");
}

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run async-11.cs
1 - async Task: exception caught: failure saving [a]
2 - async void: the method has returned control, the try saw nothing
the program is working (1)
the program is working (2)
unhandled exception: InvalidOperationException : failure saving [b]
the process is going to be stopped

Erläuterungen:

  • Zeilen 4–9: Das Ereignis [AppDomain.CurrentDomain.UnhandledException] wird ausgelöst, wenn eine Ausnahme nirgends abgefangen wird, kurz bevor das System den Prozess beendet. Sein Handler kann diese Beendigung nicht verhindern; wir nutzen ihn hier, um eine eigene Meldung anzuzeigen (anstelle der Stack-Trace-Ausgabe von .NET) und den Prozess anschließend selbst mit [Environment.Exit(1)] zu beenden;
  • Zeilen 15–19: Die Methode [SaveAsync] gibt einen [Task] zurück: Ihre Ausnahme wird normal abgefangen;
  • Zeilen 25–26: Die Methode [Save], die als [async void] deklariert ist, gibt die Kontrolle an ihrem ersten [await] zurück; [try] endet, ohne etwas bemerkt zu haben. 200 ms später löst die Methode ihre Ausnahme in einem Thread des Pools aus: Das Programm wird mitten in der Ausführung abgebrochen (Zeilen 4–7), und die Zeile [normal end of the program] wird nie angezeigt.

Die Regel lautet also: Eine asynchrone Methode gibt immer [Task] oder [Task<T>] zurück, niemals [void]. Die einzige Ausnahme ist ein GUI-Ereignishandler (etwa für einen Klick auf eine Schaltfläche): Die Signatur von Ereignishandlern verlangt [void], daher schreiben wir [private async void CalculateButton_Click(object sender, EventArgs e)]. In diesem Fall werden alle Ausnahmen im Handler mit [try / catch] abgefangen.

Ein verwandter Fehler besteht darin, eine Methode, die einen Task zurückgibt, aufzurufen, ohne auf ihn zu warten ([SaveAsync("c");] ohne [await]): Der Compiler kennzeichnet dies mit einer Warnung (CS4014), weil jede vom Task ausgelöste Ausnahme verloren ginge. Wenn Sie tatsächlich einen Task starten möchten, ohne auf ihn zu warten („Fire-and-forget“), müssen Sie das ignorierte Element ausdrücklich mit [_] angeben: [_ = SaveAsync("c");], und die Methode muss dann ihre eigenen Ausnahmen behandeln.

9.6. Abbruch und Timeouts

9.6.1. CancellationTokenSource und CancellationToken

Eine lang laufende asynchrone Operation muss abbrechbar sein: Der Benutzer hat auf [Cancel] geklickt, ein Client eines Webservers hat die Verbindung getrennt, die Anwendung wurde beendet oder ein Timeout wurde überschritten. .NET verwendet hierfür einen kooperativen Mechanismus mit zwei Objekten:

  • eine [CancellationTokenSource] (Abbruchquelle), die vom Code gehalten wird, der den Abbruch beschließt. Ihre Methode [Cancel()] fordert den Abbruch an; [CancelAfter(delay)] fordert ihn nach einer Zeitspanne automatisch an;
  • ein [CancellationToken] (Abbruchtoken), das über die Eigenschaft [Token] der Quelle bezogen und als Parameter an abbrechbare Operationen übergeben wird. Die Operation prüft das Token ([IsCancellationRequested]) oder lässt es eine Ausnahme auslösen, falls ein Abbruch angefordert wurde ([ThrowIfCancellationRequested()]), und reicht es an die von ihr aufgerufenen Operationen weiter.

Der Mechanismus ist kooperativ: Niemand unterbricht eine Operation gewaltsam (die Methode [Thread.Abort] aus dem Kurs von 2008 ist im aktuellen .NET veraltet: Sie löst lediglich eine [PlatformNotSupportedException] aus); die Operation hält von selbst an, und zwar an einer Stelle, an der sie dies sauber tun kann. Per Konvention endet eine abgebrochene Operation mit dem Auslösen einer [OperationCanceledException], und ihr Task hat den Status [Canceled].

Das Programm [async-12.cs] bricht einen simulierten Download auf drei Arten ab:

// eine asynchrone Operation abbrechen: CancellationTokenSource und CancellationToken
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - eine Abbruchquelle, die sich nach 1,2 Sekunden selbst abbricht
using (var source = new CancellationTokenSource())
{
    source.CancelAfter(TimeSpan.FromSeconds(1.2));
    try
    {
        // das Token der Quelle wird an die Operation übergeben
        await DownloadAsync(10, source.Token);
    }
    catch (OperationCanceledException e)
    {
        Display($"1 - {e.GetType().Name} : {e.Message}");
    }
}

// 2 - eine Berechnung, die selbst regelmäßig prüft, ob sie anhalten muss
stopwatch.Restart();
using (var source = new CancellationTokenSource(TimeSpan.FromMilliseconds(300)))
{
    Task<long> computation = Task.Run(() => Compute(source.Token), source.Token);
    try
    {
        long result = await computation;
        Display($"2 - result: {result}");
    }
    catch (OperationCanceledException e)
    {
        Display($"2 - {e.GetType().Name}, status of the task: {computation.Status}");
    }
}

// 3 - der Abbruch wird vom Programm ausdrücklich mit Cancel() angefordert
stopwatch.Restart();
using (var source = new CancellationTokenSource())
{
    Task download = DownloadAsync(10, source.Token);
    await Task.Delay(700);
    Display("3 - the program requests the cancellation");
    source.Cancel();
    try
    {
        await download;
    }
    catch (OperationCanceledException)
    {
        Display($"3 - download cancelled, IsCanceled={download.IsCanceled}");
    }
}

// simuliert das Herunterladen von [nbBlocks] Datenblöcken (ein Block alle 300 ms)
async Task DownloadAsync(int nbBlocks, CancellationToken token)
{
    for (int i = 1; i <= nbBlocks; i++)
    {
        // Task.Delay akzeptiert ein Token: das Warten endet, sobald der Abbruch angefordert wird
        await Task.Delay(300, token);
        Display($"  block {i}/{nbBlocks} received");
    }
}

// eine lange synchrone Berechnung, die das Token alle 1.000.000 Iterationen prüft
static long Compute(CancellationToken token)
{
    long sum = 0;
    for (long i = 0; i < 100_000_000_000; i++)
    {
        if (i % 1_000_000 == 0)
        {
            // löst eine OperationCanceledException aus, wenn der Abbruch angefordert wurde
            token.ThrowIfCancellationRequested();
        }
        sum += i % 7;
    }
    return sum;
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

Ergebnisse:

> dotnet run async-12.cs
  307 ms :   block 1/10 received
  620 ms :   block 2/10 received
  921 ms :   block 3/10 received
 1211 ms : 1 - TaskCanceledException : A task was canceled.
  304 ms : 2 - OperationCanceledException, status of the task: Canceled
  300 ms :   block 1/10 received
  600 ms :   block 2/10 received
  700 ms : 3 - the program requests the cancellation
  701 ms : 3 - download cancelled, IsCanceled=True

Erläuterungen:

  • Zeilen 56–62: Der simulierte Download erhält alle 300 ms einen Block. Er erhält ein [CancellationToken] als letzten Parameter (das ist die Konvention) und übergibt es an [Task.Delay] (Zeile 61): Wird während des Wartens ein Abbruch angefordert, wird das Warten sofort unterbrochen, und eine [TaskCanceledException] – eine von [OperationCanceledException] abgeleitete Klasse – wird ausgelöst. Fast alle asynchronen Methoden von .NET akzeptieren ein Token: [ReadAllTextAsync], [ConnectAsync], [ToListAsync] …;
  • Zeilen 6–17: Die Quelle wird in einem [using] erzeugt, weil sie einen Timer verwendet, der freigegeben werden muss. [CancelAfter] fordert den Abbruch nach 1,2 Sekunden an: Der Download erhält drei Blöcke und hält dann bei 1.200 ms an (Zeile 5). Wir fangen [OperationCanceledException] ab, die Basisklasse, die alle Abbrüche erfasst;
  • Zeilen 21–33: eine synchrone Berechnung (kein Warten), die abgebrochen werden kann. Die Methode [Compute] (Zeilen 67–79) prüft das Token alle eine Million Iterationen mit [ThrowIfCancellationRequested()], das eine [OperationCanceledException] auslöst, wenn ein Abbruch angefordert wurde. Die Berechnung wird mit [Task.Run] an den Pool delegiert, dem ebenfalls das Token übergeben wird: Der Task endet dann mit dem Status [Canceled] statt mit [Faulted] (Zeile 6). Hier wird die Quelle mit einer Verzögerung erzeugt (Konstruktor [CancellationTokenSource(TimeSpan)]), was [CancelAfter] entspricht;
  • Zeilen 37–51: Die Quelle wird nach 700 ms ausdrücklich mit [Cancel()] abgebrochen. Der Abbruch erfolgt sofort: Das Warten auf den dritten Block wird unterbrochen (Zeilen 9–10).

9.6.2. Das BackgroundWorker-Beispiel neu geschrieben

Der Kurs von 2008 stellte die Klasse [BackgroundWorker] anhand eines Beispiels mit fünf Verarbeitungen von 1 bis 5 Sekunden Dauer vor, von denen Nr. 3 eine Ausnahme auslöste und Nr. 4 abgebrochen wurde. Man musste Methoden für die Ereignisse [DoWork] und [RunWorkerCompleted] abonnieren, den Abbruch aktivieren ([WorkerSupportsCancellation]), in der Arbeitsschleife [CancellationPending] testen und die Eigenschaften [Result] und [Cancel] des Ereignisarguments füllen; außerdem merkte der Kurs an, dass sich bei einer Ausnahme oder einem Abbruch nicht feststellen ließ, welche Verarbeitung betroffen war. [BackgroundWorker] existiert in .NET weiterhin, ist aber für grafische Windows-Forms-Oberflächen gedacht und hat keinen Nutzen mehr: Tasks leisten dasselbe einfacher. Das Programm [async-13.cs] schreibt dieses Beispiel neu:

// das BackgroundWorker-Beispiel des Kurses von 2008, mit Tasks neu geschrieben:
// fünf Verarbeitungen von 1 bis 5 Sekunden, Nr. 3 löst eine Ausnahme aus, Nr. 4 wird abgebrochen
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
using var cancellation = new CancellationTokenSource();
var tasks = new Task<Result>[5];
for (int i = 0; i < tasks.Length; i++)
{
    // nur Verarbeitung Nr. 4 erhält das Token der Abbruchquelle
    CancellationToken token = i == 4 ? cancellation.Token : CancellationToken.None;
    tasks[i] = SleepAsync(i, i + 1, token);
}
// wir brechen Verarbeitung Nr. 4 nach 2,5 Sekunden ab
cancellation.CancelAfter(2500);
Console.WriteLine($"{stopwatch.Elapsed.TotalSeconds,4:F1} s : the {tasks.Length} processings are launched");

// wir verwenden jede Verarbeitung, sobald sie abgeschlossen ist, unabhängig davon, wie sie endet
await foreach (Task<Result> task in Task.WhenEach(tasks))
{
    int number = Array.IndexOf(tasks, task);
    string outcome = task.Status switch
    {
        TaskStatus.RanToCompletion => $"finished: scheduled duration {task.Result.Duration} s, actual duration {task.Result.ActualDuration:F1} s",
        TaskStatus.Faulted => $"encountered the following error: {task.Exception!.InnerException!.Message}",
        TaskStatus.Canceled => "cancelled",
        _ => $"unexpected status {task.Status}",
    };
    Console.WriteLine($"{stopwatch.Elapsed.TotalSeconds,4:F1} s : processing {number} {outcome}");
}

// die Verarbeitung: [duration] Sekunden schlafen, in Scheiben von einer Sekunde
static async Task<Result> SleepAsync(int number, int duration, CancellationToken token)
{
    var start = Stopwatch.GetTimestamp();
    // Ausnahme für Verarbeitung Nr. 3
    if (number == 3)
    {
        throw new InvalidOperationException("test....");
    }
    for (int i = 1; i <= duration; i++)
    {
        await Task.Delay(1000, token);
    }
    // das an den Aufrufer zurückgegebene Ergebnis
    return new Result(duration, Stopwatch.GetElapsedTime(start).TotalSeconds);
}

// das Ergebnis einer Verarbeitung
record Result(int Duration, double ActualDuration);

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run async-13.cs
 0.0 s : the 5 processings are launched
 0.0 s : processing 3 encountered the following error: test....
 1.0 s : processing 0 finished: scheduled duration 1 s, actual duration 1.0 s
 2.0 s : processing 1 finished: scheduled duration 2 s, actual duration 2.0 s
 2.5 s : processing 4 cancelled
 3.0 s : processing 2 finished: scheduled duration 3 s, actual duration 3.0 s

Erläuterungen:

  • Zeilen 33–46: die Verarbeitung. Nr. 3 löst eine Ausnahme aus; die anderen „schlafen“ [duration] Sekunden in Schritten von einer Sekunde mit einem abbrechbaren [Task.Delay] und geben ein Ergebnis zurück – einen [record] –, das die geplante und die tatsächliche Dauer enthält. [Stopwatch.GetTimestamp()] und [Stopwatch.GetElapsedTime(start)] messen eine Dauer, ohne ein [Stopwatch]-Objekt zu erzeugen;
  • Zeilen 8–15: Die fünf Verarbeitungen werden gestartet. Nur Verarbeitung Nr. 4 erhält das Token der Abbruchquelle; die anderen erhalten [CancellationToken.None], ein Token, das nie abgebrochen wird. Verarbeitung Nr. 4 wird nach 2,5 Sekunden abgebrochen, obwohl sie noch 2,5 Sekunden schlafen müsste;
  • Zeilen 19–29: Mit [Task.WhenEach] wird jede Verarbeitung behandelt, sobald sie beendet ist, unabhängig davon, wie sie endete: Wir verwenden nicht [await task], was die Ausnahme auslösen würde, sondern prüfen stattdessen den Status mit einem [switch]-Ausdruck. Die Nummer der Verarbeitung wird anhand ihrer Position im Task-Array ermittelt ([Array.IndexOf]): Das im Kurs von 2008 beschriebene Problem ist damit gelöst;
  • die Ergebnisse zeigen, dass Nr. 3 sofort fehlschlägt, dass Nr. 0, 1 und 2 nach 1, 2 bzw. 3 Sekunden abgeschlossen sind und dass Nr. 4 nach 2,5 Sekunden abgebrochen wird.

9.6.3. Die Wartezeit begrenzen

Das Programm [async-14.cs] bietet zwei sich ergänzende Werkzeuge: die Methode [WaitAsync] und die zugehörigen Abbruchquellen.

// die Dauer eines Wartens begrenzen: WaitAsync und verknüpfte Tokens
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - WaitAsync(TimeSpan): wir warten nicht länger als eine Sekunde
Task<string> slow = QueryAsync("slow-server", 3000, CancellationToken.None);
try
{
    string answer = await slow.WaitAsync(TimeSpan.FromSeconds(1));
    Display($"1 - answer: {answer}");
}
catch (TimeoutException e)
{
    Display($"1 - {e.GetType().Name} : {e.Message}");
}
// Vorsicht: WaitAsync gibt das Warten auf, nicht die Operation, die weiterläuft
Display($"1 - status of the operation: {slow.Status}");

// 2 - um die Operation wirklich zu stoppen, müssen wir ihr ein Abbruch-Token übergeben
stopwatch.Restart();
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(1)))
{
    Task<string> slow2 = QueryAsync("slow-server", 3000, timeout.Token);
    try
    {
        Display($"2 - answer: {await slow2}");
    }
    catch (OperationCanceledException)
    {
        Display($"2 - operation cancelled after one second, status: {slow2.Status}");
    }
}

// 3 - zwei Abbruchursachen kombinieren: eine Verzögerung und eine Anforderung des Aufrufers
stopwatch.Restart();
using var generalStop = new CancellationTokenSource();
await Task.WhenAll(ProcessWithTimeoutAsync("fast", 500, 1000, generalStop.Token),
                   ProcessWithTimeoutAsync("slow", 3000, 1000, generalStop.Token),
                   ProcessWithTimeoutAsync("medium", 1500, 2000, generalStop.Token),
                   StopAfterAsync(1200));

// eine auf [timeout] Millisekunden begrenzte Verarbeitung, die auch vom Aufrufer gestoppt werden kann
async Task ProcessWithTimeoutAsync(string name, int duration, int timeout, CancellationToken stop)
{
    // die verknüpfte Quelle wird abgebrochen, sobald eine der beiden Ursachen eintritt
    using var linked = CancellationTokenSource.CreateLinkedTokenSource(stop);
    linked.CancelAfter(timeout);
    try
    {
        Display($"3 - {await QueryAsync(name, duration, linked.Token)}");
    }
    catch (OperationCanceledException) when (stop.IsCancellationRequested)
    {
        Display($"3 - {name} : stopped at the caller's request");
    }
    catch (OperationCanceledException)
    {
        Display($"3 - {name} : timeout of {timeout} ms exceeded");
    }
}

// der Aufrufer fordert den allgemeinen Stopp nach [duration] Millisekunden an
async Task StopAfterAsync(int duration)
{
    await Task.Delay(duration);
    Display("3 - general stop requested");
    generalStop.Cancel();
}

// simuliert einen Server, der nach [duration] Millisekunden antwortet
static async Task<string> QueryAsync(string server, int duration, CancellationToken token)
{
    await Task.Delay(duration, token);
    return $"{server} answered in {duration} ms";
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

Ergebnisse:

1
2
3
4
5
6
7
8
> dotnet run async-14.cs
 1024 ms : 1 - TimeoutException : The operation has timed out.
 1037 ms : 1 - status of the operation: WaitingForActivation
 1001 ms : 2 - operation cancelled after one second, status: Canceled
  502 ms : 3 - fast answered in 500 ms
 1003 ms : 3 - slow : timeout of 1000 ms exceeded
 1204 ms : 3 - general stop requested
 1204 ms : 3 - medium : stopped at the caller's request

Erläuterungen:

  • Zeile 10: [t.WaitAsync(TimeSpan)] (.NET 6) gibt einen Task zurück, der wie [t] abgeschlossen wird, wenn [t] innerhalb der Zeitbegrenzung abgeschlossen wird, und andernfalls mit einer [TimeoutException] fehlschlägt. Das ist die direkte Umsetzung des „Rennens“ mit [Task.WhenAny] aus dem Programm [async-08.cs]. Eine weitere Überladung, [WaitAsync(CancellationToken)], erlaubt es, das Warten auf einen Task abzubrechen, der kein Token akzeptiert;
  • Zeile 18: [WaitAsync] bricht das Warten ab, nicht die Operation. Die Operation läuft weiter (Status [WaitingForActivation]); sie verbraucht Ressourcen, und ihr Ergebnis geht verloren;
  • Zeilen 20–31: Um die Operation wirklich zu stoppen, müssen Sie ihr nach Ablauf der Frist ein abgebrochenes Token übergeben. Die Operation endet nach 1 Sekunde mit dem Status [Canceled]. Dies ist die bevorzugte Lösung, wann immer die Operation ein Token akzeptiert;
  • Zeilen 44–59: Eine Verarbeitung kann aus mehreren Gründen abgebrochen werden; hier geschieht es aufgrund ihres eigenen Timeouts und einer allgemeinen Stoppanforderung des Aufrufers. [CancellationTokenSource.CreateLinkedTokenSource(stop)] erzeugt eine verknüpfte Quelle: Sie wird abgebrochen, wenn das Token [stop] abgebrochen wird, und sie kann auch selbst abgebrochen werden, in diesem Fall mit [CancelAfter(timeout)]. Um festzustellen, welche der beiden Ursachen eingetreten ist, wird ein Ausnahmefilter [when] (Zeile 53) verwendet: Das erste [catch] greift nur, wenn der Aufrufer die Beendigung angefordert hat;
  • Zeilen 38–41: drei Verarbeitungsschritte und ein allgemeiner Stopp, der bei 1.200 ms angefordert wird. Die Verarbeitung [fast] endet normal; die Verarbeitung [slow] überschreitet ihr Zeitlimit von einer Sekunde; die Verarbeitung [medium], der zwei Sekunden zugestanden wurden, wird durch den allgemeinen Stopp beendet.

9.7. Fortschritt melden: IProgress<T>

Eine lang laufende Operation muss oft ihren Fortschritt melden (Fortschrittsbalken, Prozentangabe). Mit [BackgroundWorker] rief die Verarbeitung [ReportProgress] auf, und die Oberfläche abonnierte das Ereignis [ProgressChanged]. Bei Tasks verwendet man die Schnittstelle [IProgress<T>], die nur eine Methode besitzt:

1
2
3
4
public interface IProgress<in T>
{
    void Report(T value);
}

Die Operation erhält ein [IProgress<T>]-Objekt als Parameter und übergibt ihre Meldungen über [Report] an dieses; sie weiß nicht, wie diese angezeigt werden. .NET stellt die Implementierung [Progress<T>] für grafische Benutzeroberflächen bereit: Sie speichert den Synchronisierungskontext des Threads, der sie erzeugt (des UI-Threads), und führt die Verarbeitung der Meldungen dort aus, sodass die grafischen Komponenten aktualisiert werden können, ohne sich um Threads kümmern zu müssen. Der Kurs von 2008 musste dafür [Invoke] mit einem Delegaten auf den grafischen Komponenten aufrufen, um dasselbe Ergebnis zu erzielen. In einem Konsolenprogramm, das keinen Synchronisierungskontext hat, lässt [Progress<T>] die Meldungen von Threads des Pools verarbeiten, ohne ihre Reihenfolge zu garantieren: Das Programm [async-15.cs] verwendet daher eine eigene Implementierung von [IProgress<T>]. Es simuliert einen Kopiervorgang, den der Benutzer durch Eingabe von [Enter] abbrechen kann:

// den Fortschritt einer Operation mit IProgress<T> melden; der Benutzer kann sie abbrechen
using var cancellation = new CancellationTokenSource();
// ein Hintergrund-Task wartet darauf, dass der Benutzer [Enter] eingibt, um den Abbruch anzufordern
_ = Task.Run(() =>
{
    Console.ReadLine();
    cancellation.Cancel();
});
Console.WriteLine("Copy in progress, type [Enter] to cancel it");

// das Objekt, das die Fortschrittsmeldungen empfängt
IProgress<Advancement> progress = new ConsoleProgress();
try
{
    int nbFiles = await CopyAsync(8, progress, cancellation.Token);
    Console.WriteLine($"Copy finished: {nbFiles} files copied");
}
catch (OperationCanceledException)
{
    Console.WriteLine("Copy cancelled by the user");
}

// die Operation weiß nicht, wie ihr Fortschritt angezeigt wird: sie meldet ihn nur
static async Task<int> CopyAsync(int nbFiles, IProgress<Advancement>? progress, CancellationToken token)
{
    for (int i = 1; i <= nbFiles; i++)
    {
        // das Kopieren einer Datei
        await Task.Delay(300, token);
        // die Fortschrittsmeldung (der Aufrufer wünscht möglicherweise keine: progress ist dann null)
        progress?.Report(new Advancement(100 * i / nbFiles, $"file{i}.dat"));
    }
    return nbFiles;
}

// eine Fortschrittsmeldung
record Advancement(int Percentage, string File);

// die Anzeige der Fortschrittsmeldungen in der Konsole
class ConsoleProgress : IProgress<Advancement>
{
    public void Report(Advancement advancement)
    {
        // ein Balken mit 20 Zeichen
        string bar = new string('#', advancement.Percentage / 5).PadRight(20, '.');
        Console.WriteLine($"[{bar}] {advancement.Percentage,3} % {advancement.File}");
    }
}

Ergebnisse ohne Abbruch:

> dotnet run async-15.cs
Copy in progress, type [Enter] to cancel it
[##..................]  12 % file1.dat
[#####...............]  25 % file2.dat
[#######.............]  37 % file3.dat
[##########..........]  50 % file4.dat
[############........]  62 % file5.dat
[###############.....]  75 % file6.dat
[#################...]  87 % file7.dat
[####################] 100 % file8.dat
Copy finished: 8 files copied

Ergebnisse, wenn der Benutzer [Enter] während des Kopiervorgangs nach eineinhalb Sekunden eingibt:

1
2
3
4
5
6
7
> dotnet run async-15.cs
Copy in progress, type [Enter] to cancel it
[##..................]  12 % file1.dat
[#####...............]  25 % file2.dat
[#######.............]  37 % file3.dat
[##########..........]  50 % file4.dat
Copy cancelled by the user

Erläuterungen:

  • Zeilen 24–33: Die Operation erhält ein [IProgress<Advancement>] und ein Abbruchtoken. Nach jeder Datei meldet sie ihren Fortschritt über ein [Advancement]-Objekt (einen [record] mit dem Prozentwert und dem Dateinamen). Der Parameter ist als nullable deklariert ([IProgress<Advancement>?]) und wird mit dem Operator [?.] verwendet: Ein Aufrufer, der keine Meldungen wünscht, übergibt [null];
  • Zeilen 40–46: Die Konsolenimplementierung von [IProgress<Advancement>] zeigt einen Balken aus 20 Zeichen an;
  • Zeilen 4–7: Ein Task im Pool wartet darauf, dass der Benutzer [Enter] eingibt ([Console.ReadLine] ist ein blockierendes Lesen, daher [Task.Run]: Blockiert wird ein Thread des Pools, nicht das Programm) und fordert dann den Abbruch an. Das Programm wartet nicht darauf, daher der Platzhalter [_]: Am Programmende wird dieser Task aufgegeben;
  • Zeilen 15–20: Das Programm startet den Kopiervorgang und wartet darauf. Ein Abbruch führt zu einer [OperationCanceledException].

9.8. Asynchrone Ein- und Ausgabe

Ein- und Ausgabe ist das eigentliche Wesen der Asynchronität. Die Klassen von .NET bieten für alle ihre Ein- und Ausgabemethoden eine asynchrone Version: Dateien ([File], [FileStream], [StreamReader], [StreamWriter]), Netzwerk ([Socket], [TcpClient], [NetworkStream], [HttpClient], wie in Kapitel 12 besprochen), Datenbanken (ADO.NET und Entity Framework Core, Kapitel 10 und 11). Das Programm [async-16.cs] demonstriert die asynchrone Datei-Ein-/Ausgabe, indem es die Datei mit den Steuerstufen aus dem Beispielverzeichnis liest, [TaxData.txt], die im Programmordner liegt:

1
2
3
4
5
6
7
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

Jede Zeile enthält die Obergrenze der Stufe, den Koeffizienten [coeffR] und den Koeffizienten [coeffN], getrennt durch das Zeichen [:] und mit Dezimalpunkt geschrieben (der Steuertarif ist der Tarif von 2004 für die Einkünfte von 2003, der für diese Übung unverändert beibehalten wird). Das Programm läuft im Ordner [09-async] und sucht seine Dateien im aktuellen Ordner.

// asynchrone Ein- und Ausgabe bei Dateien
using System.Globalization;

const string data = "TaxData.txt";
const string report = "report-16.txt";

// 1 - die gesamte Datei in einer einzigen Operation lesen
string[] lines = await File.ReadAllLinesAsync(data);
Console.WriteLine($"1 - File.ReadAllLinesAsync: {lines.Length} lines");

// 2 - zeilenweises Lesen mit einem StreamReader
var brackets = new List<TaxBracket>();
using (var reader = new StreamReader(data))
{
    string? line;
    // ReadLineAsync gibt am Dateiende null zurück
    while ((line = await reader.ReadLineAsync()) is not null)
    {
        brackets.Add(TaxBracket.Parse(line));
    }
}
Console.WriteLine($"2 - StreamReader.ReadLineAsync: {brackets.Count} brackets, the 2nd is {brackets[1]}");

// 3 - File.ReadLinesAsync gibt einen asynchronen Datenstrom von Zeilen zurück, der mit await foreach durchlaufen wird
int nbBrackets = 0;
await foreach (string line in File.ReadLinesAsync(data))
{
    nbBrackets++;
}
Console.WriteLine($"3 - File.ReadLinesAsync: {nbBrackets} lines");

// 4 - Schreiben mit einem StreamWriter: await using gibt den Stream asynchron frei
await using (var writer = new StreamWriter(report))
{
    await writer.WriteLineAsync("Brackets of the tax scale (exercise: 2004 scale on 2003 income)");
    foreach (var (bracket, i) in brackets.Select((t, i) => (t, i + 1)))
    {
        string limit = bracket.Limit == 0 ? "beyond" : $"up to {bracket.Limit:N0} €";
        await writer.WriteLineAsync($"bracket {i} : {limit,-18} rate {bracket.CoeffR:P1}");
    }
}

// 5 - die gesamte Datei als Zeichenkette lesen
string text = await File.ReadAllTextAsync(report);
Console.Write($"4 and 5 - content of [{report}]:\n{text}");

// 6 - am Dateiende anhängen und anschließend löschen
await File.AppendAllTextAsync(report, "end of the report\n");
Console.WriteLine($"6 - last line: {(await File.ReadAllLinesAsync(report))[^1]}");
File.Delete(report);

// eine Steuerstufe; die Datei verwendet den Dezimalpunkt: wir lesen sie mit der invarianten Kultur
readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN)
{
    public static TaxBracket Parse(string line)
    {
        string[] fields = line.Split(':');
        return new TaxBracket(decimal.Parse(fields[0], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[1], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[2], CultureInfo.InvariantCulture));
    }
}

Ergebnisse:

> dotnet run async-16.cs
1 - File.ReadAllLinesAsync: 7 lines
2 - StreamReader.ReadLineAsync: 7 brackets, the 2nd is TaxBracket { Limit = 8382, CoeffR = 0.068, CoeffN = 291.09 }
3 - File.ReadLinesAsync: 7 lines
4 and 5 - content of [report-16.txt]:
Brackets of the tax scale (exercise: 2004 scale on 2003 income)
bracket 1 : up to 4,962 €      rate 0.0 %
bracket 2 : up to 8,382 €      rate 6.8 %
bracket 3 : up to 14,753 €     rate 19.1 %
bracket 4 : up to 23,888 €     rate 28.3 %
bracket 5 : up to 38,868 €     rate 37.4 %
bracket 6 : up to 47,932 €     rate 42.6 %
bracket 7 : beyond             rate 48.1 %
6 - last line: end of the report

Erläuterungen:

  • Zeile 8: [File.ReadAllLinesAsync] liest die gesamte Datei und gibt einen [Task<string[]>] zurück. Die Lese- und Schreibmethoden der Klasse [File] haben asynchrone Versionen: [ReadAllTextAsync], [ReadAllBytesAsync], [WriteAllTextAsync], [WriteAllLinesAsync], [AppendAllTextAsync] … Sie alle akzeptieren ein Abbruchtoken als letzten Parameter;
  • Zeilen 13–19: zeilenweises Lesen mit einem [StreamReader]. [ReadLineAsync] gibt einen [Task<string?>] zurück, dessen Ergebnis am Dateiende [null] ist. Jede Zeile wird in [TaxBracket] umgewandelt, und zwar von der Methode [Parse] (Zeilen 55–60), die die Zahlen im kulturinvarianten Format liest, damit der Dezimalpunkt auch auf einem französischen Rechner erkannt wird;
  • Zeilen 26–28: [File.ReadLinesAsync] (.NET 7) gibt einen asynchronen Stream von Zeilen zurück ([IAsyncEnumerable<string>]), der mit [await foreach] durchlaufen wird. Anders als [ReadAllLinesAsync] lädt er nicht die gesamte Datei in den Speicher: Er liest die Zeilen bei Bedarf. Dies ist die bevorzugte Methode für große Dateien;
  • Zeilen 33–39: Schreiben mit einem [StreamWriter] und seiner Methode [WriteLineAsync]. [StreamWriter] wird mit [await using] (C# 8) deklariert: Beim Verlassen des Blocks wird er durch seine Methode [DisposeAsync] freigegeben, die seinen Puffer asynchron leert. [await using] wird mit Objekten verwendet, die die Schnittstelle [IAsyncDisposable] implementieren ([StreamWriter], [FileStream], Datenbankverbindungen usw.); [StreamReader], der nur einen einzigen Lesevorgang ausführt, implementiert nur [IDisposable] und verwendet ein gewöhnliches [using];
  • Zeile 36: Die Schleife durchläuft die Tupel (Stufe, Nummer), die von [Select] erzeugt und dekonstruiert werden;
  • Zeilen 44–50: [ReadAllTextAsync] liest die geschriebene Datei erneut ein, [AppendAllTextAsync] fügt ihr eine Zeile hinzu, und anschließend wird die Datei gelöscht. [File.Delete] hat keine asynchrone Version: Das Löschen einer Datei ist ein sehr kurzer Vorgang.

Hinweis: Unter Windows führt ein ohne besondere Optionen geöffneter [FileStream] seine asynchronen Operationen aus, indem er synchrone Lesevorgänge an den Thread-Pool delegiert; für echte asynchrone System-Ein-/Ausgabe öffnen Sie ihn mit der Option [FileOptions.Asynchronous] (oder [useAsync: true]). Die Methoden der Klasse [File] übernehmen dies automatisch. Bei lokalen Dateien ist der Unterschied selten spürbar; bei Netzwerkoperationen ist er es, denn dort ist asynchrone Ein-/Ausgabe immer echte asynchrone Ein-/Ausgabe.

9.9. Asynchrone Streams: IAsyncEnumerable<T>

Eine asynchrone Methode liefert nach einer gewissen Zeit ein Ergebnis. Ein Iterator (eine Methode, die einen [IEnumerable<T>] mit [yield return] zurückgibt) liefert eine Folge von Ergebnissen, die bei Bedarf erzeugt werden. Asynchrone Streams (C# 8) verbinden beides: eine Folge von Werten, bei denen jeweils eine asynchrone Wartezeit erforderlich sein kann, bevor sie erzeugt werden. Sie dienen etwa zum Lesen der Zeilen einer großen Datei, der Zeilen eines SQL-Abfrageergebnisses, von Nachrichten, die über eine Netzwerkverbindung eintreffen, von Sensormesswerten usw. …

  • der Typ ist [IAsyncEnumerable<T>];
  • er wird von einer [async]-Methode erzeugt, die [IAsyncEnumerable<T>] zurückgibt und sowohl [await] als auch [yield return] enthält;
  • er wird mit [await foreach] konsumiert.

Zwei davon sind uns bereits begegnet: [Task.WhenEach] und [File.ReadLinesAsync]. Das Programm [async-17.cs] schreibt einen eigenen:

// asynchrone Datenströme: IAsyncEnumerable<T>, yield return, await foreach
using System.Diagnostics;
using System.Runtime.CompilerServices;

var stopwatch = Stopwatch.StartNew();

// 1 - jeder Wert wird verarbeitet, sobald er erzeugt wird
await foreach (Measure measure in ReadMeasuresAsync("sensor-1", 4))
{
    Display($"1 - received {measure}");
}

// 2 - wir können die Schleife vor dem Ende verlassen: der Produzent stoppt dann ebenfalls
stopwatch.Restart();
await foreach (Measure measure in ReadMeasuresAsync("sensor-2", 100))
{
    Display($"2 - received {measure}");
    if (measure.Value >= 22)
    {
        break;
    }
}

// 3 - Abbruch: WithCancellation übergibt das Token an den mit [EnumeratorCancellation] markierten Parameter
stopwatch.Restart();
using var source = new CancellationTokenSource(TimeSpan.FromMilliseconds(700));
try
{
    await foreach (Measure measure in ReadMeasuresAsync("sensor-3", 100).WithCancellation(source.Token))
    {
        Display($"3 - received {measure}");
    }
}
catch (OperationCanceledException)
{
    Display("3 - reading cancelled");
}

// 4 - LINQ auf asynchronen Datenströmen (System.Linq.AsyncEnumerable, .NET 10)
stopwatch.Restart();
List<double> high = await ReadMeasuresAsync("sensor-4", 6)
    .Where(m => m.Value > 21)
    .Select(m => m.Value)
    .ToListAsync();
Display($"4 - measures above 21: [{string.Join(" ; ", high)}]");

// ein asynchroner Produzent: eine Messung alle 200 ms
static async IAsyncEnumerable<Measure> ReadMeasuresAsync(string sensor, int count,
    [EnumeratorCancellation] CancellationToken token = default)
{
    try
    {
        for (int i = 1; i <= count; i++)
        {
            // Warten auf die nächste Messung
            await Task.Delay(200, token);
            // die Messung wird an den Konsumenten geliefert; der Produzent setzt bei der nächsten Anforderung hier fort
            yield return new Measure(sensor, i, 19.5 + i * 0.75);
        }
    }
    finally
    {
        // wird bei normalem Ende, bei break durch den Konsumenten oder bei Abbruch ausgeführt
        Console.WriteLine($"          {sensor} : end of the production");
    }
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

// eine Messung
record Measure(string Sensor, int Number, double Value)
{
    public override string ToString() => $"{Sensor} no. {Number} : {Value} °C";
}

Ergebnisse:

> dotnet run async-17.cs
  214 ms : 1 - received sensor-1 no. 1 : 20.25 °C
  426 ms : 1 - received sensor-1 no. 2 : 21 °C
  626 ms : 1 - received sensor-1 no. 3 : 21.75 °C
  827 ms : 1 - received sensor-1 no. 4 : 22.5 °C
          sensor-1 : end of the production
  204 ms : 2 - received sensor-2 no. 1 : 20.25 °C
  404 ms : 2 - received sensor-2 no. 2 : 21 °C
  605 ms : 2 - received sensor-2 no. 3 : 21.75 °C
  809 ms : 2 - received sensor-2 no. 4 : 22.5 °C
          sensor-2 : end of the production
  201 ms : 3 - received sensor-3 no. 1 : 20.25 °C
  404 ms : 3 - received sensor-3 no. 2 : 21 °C
  604 ms : 3 - received sensor-3 no. 3 : 21.75 °C
          sensor-3 : end of the production
  703 ms : 3 - reading cancelled
          sensor-4 : end of the production
 1213 ms : 4 - measures above 21: [21.75 ; 22.5 ; 23.25 ; 24]

Erläuterungen:

  • Zeilen 48–64: der Producer. Er wartet 200 ms ([await]) und liefert dann einen Messwert ([yield return]) und so weiter. Bei jedem [yield return] pausiert er, bis der Konsument den nächsten Wert anfordert. Der Block [finally] wird ausgeführt, wenn der Producer anhält, unabhängig vom Grund;
  • Zeile 49: Das Abbruchtoken eines asynchronen Streams ist ein Parameter, der mit dem Attribut [[EnumeratorCancellation]] (Namespace [System.Runtime.CompilerServices]) markiert ist. Er wird auf [default] gesetzt (ein Token, das nie abgebrochen wird), wenn der Aufrufer keines übergibt;
  • Zeilen 7–10: Die Schleife [await foreach] wartet auf jeden Messwert, ohne einen Thread zu blockieren, und verarbeitet ihn, sobald er erzeugt wird: einen alle 200 ms (Zeilen 2–6);
  • Zeilen 13–20: Wenn der Konsument die Schleife mit [break] verlässt, wird der Stream freigegeben (Methode [DisposeAsync], aufgerufen von [await foreach]): Der Producer erzeugt die restlichen 96 Messwerte nicht mehr und führt seinen [finally]-Block aus (Zeile 11);
  • Zeilen 24–36: Die Erweiterungsmethode [WithCancellation] übergibt ein Token an den mit [[EnumeratorCancellation]] markierten Parameter. Das Token wird nach 700 ms abgebrochen: Das Warten auf den 4. Messwert wird unterbrochen; eine [OperationCanceledException] läuft durch den Producer (der seinen [finally]-Block ausführt) und anschließend durch die [await foreach]-Schleife des Konsumenten;
  • Zeilen 41–44: .NET 10 enthält LINQ für asynchrone Streams (Klasse [System.Linq.AsyncEnumerable], zuvor im NuGet-Paket [System.Linq.Async] verfügbar): [Where], [Select], [Take], [FirstAsync], [ToListAsync] … lassen sich auf ein [IAsyncEnumerable<T>] anwenden. Methoden, die einen Stream erzeugen ([Where], [Select]), geben wiederum einen Stream zurück; solche, die einen Wert erzeugen ([ToListAsync], [CountAsync], [FirstAsync]), geben einen Task zurück, auf den gewartet werden muss;
  • Zeile 76: Die Methode [ToString] des [record] [Measure] wird überschrieben, um eine kompaktere Darstellung zu erhalten.

9.10. ValueTask, ConfigureAwait und TaskCompletionSource

9.10.1. ValueTask<T>

Ein Task ist ein Objekt: Jeder Aufruf einer Methode, die einen [Task<T>] zurückgibt, belegt (im Allgemeinen) ein Objekt auf dem Heap, das der Garbage Collector später wieder freigeben muss. Bei Ein-/Ausgabeoperationen, die Millisekunden dauern, ist das vernachlässigbar, nicht aber bei einer Methode, die millionenfach pro Sekunde aufgerufen wird und das Ergebnis meistens bereits kennt (ein Cache, ein bereits gefüllter Puffer). Für diesen Fall bietet .NET die Struktur [ValueTask<T>] an (C# 7, 2017): Sie enthält entweder direkt das Ergebnis (ohne Allokation) oder einen echten Task, wenn die Operation tatsächlich asynchron ist. Das Programm [async-18.cs] verwendet sie für einen Wechselkursdienst mit Cache:

// ValueTask<T>: eine asynchrone Methode, die meistens das Ergebnis bereits hat
using System.Diagnostics;

var service = new RateService();
var stopwatch = Stopwatch.StartNew();
foreach (string code in new[] { "EUR", "USD", "EUR", "EUR", "USD", "GBP", "EUR" })
{
    long start = stopwatch.ElapsedMilliseconds;
    decimal rate = await service.ReadRateAsync(code);
    Console.WriteLine($"{code} : {rate,6} read in {stopwatch.ElapsedMilliseconds - start,3} ms");
}
Console.WriteLine($"server accesses: {service.NbServerAccesses}, cache answers: {service.NbCacheAccesses}");

class RateService
{
    private readonly Dictionary<string, decimal> cache = [];
    public int NbServerAccesses { get; private set; }
    public int NbCacheAccesses { get; private set; }

    // ValueTask<decimal>: keine Task-Allokation, wenn das Ergebnis im Cache liegt
    public ValueTask<decimal> ReadRateAsync(string code)
    {
        if (cache.TryGetValue(code, out decimal rate))
        {
            // schneller und synchroner Pfad: das Ergebnis ist bereits bekannt
            NbCacheAccesses++;
            return ValueTask.FromResult(rate);
        }
        // langsamer und asynchroner Pfad: der Server muss abgefragt werden
        return new ValueTask<decimal>(ReadServerRateAsync(code));
    }

    private async Task<decimal> ReadServerRateAsync(string code)
    {
        NbServerAccesses++;
        // simuliert die Abfrage eines entfernten Servers
        await Task.Delay(300);
        decimal rate = code switch
        {
            "EUR" => 1m,
            "USD" => 1.17m,
            "GBP" => 0.87m,
            _ => throw new ArgumentException($"unknown currency: {code}"),
        };
        cache[code] = rate;
        return rate;
    }
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run async-18.cs
EUR :      1 read in 323 ms
USD :   1.17 read in 301 ms
EUR :      1 read in   0 ms
EUR :      1 read in   0 ms
USD :   1.17 read in   0 ms
GBP :   0.87 read in 301 ms
EUR :      1 read in   0 ms
server accesses: 3, cache answers: 4

Erläuterungen:

  • Zeilen 21–30: Die Methode ist nicht [async]. Befindet sich der Kurs im Cache, gibt sie einen [ValueTask<decimal>] zurück, der das Ergebnis direkt enthält ([ValueTask.FromResult]): Es wird kein Objekt erzeugt. Andernfalls verpackt sie den Task der [async]-Methode – die den Server abfragt – in einen [ValueTask<decimal>];
  • Zeilen 33–45: die simulierte Serverabfrage (300 ms), die das Ergebnis im Cache speichert. Eine [async]-Methode kann auch direkt einen [ValueTask<T>] zurückgeben;
  • Zeile 9: Für den Aufrufer ändert sich nichts: Er wartet mit [await] auf den [ValueTask]. Die Ergebnisse zeigen die 3 Serverzugriffe (je 300 ms) und die 4 sofortigen Antworten aus dem Cache.

[ValueTask<T>] unterliegt Einschränkungen: Auf ihn darf nur ein einziges Mal gewartet werden (kein doppeltes [await] auf denselben [ValueTask], kein gleichzeitiges Warten von mehreren Stellen aus), und er kann nicht direkt an [Task.WhenAll] übergeben werden: Er muss zuvor mit [AsTask()] in einen Task umgewandelt werden. Die Faustregel ist einfach: Verwenden Sie [Task] und [Task<T>] standardmäßig, und [ValueTask] nur in Code, bei dem gemessen wurde, dass er stark belastet ist und häufig synchron abläuft. Am häufigsten begegnet Ihnen [ValueTask] als Rückgabetyp von Methoden aus .NET: [Stream.ReadAsync(Memory<byte>)], [DisposeAsync], [ChannelWriter.WriteAsync] …

9.10.2. ConfigureAwait und der Synchronisierungskontext

Das Programm [async-05.cs] hat gezeigt, dass in der Konsole der Rest einer Methode nach einem [await] von irgendeinem Thread des Pools ausgeführt wird. In einer grafischen Anwendung (Windows Forms, WPF, MAUI) ist das nicht der Fall. Eine grafische Komponente darf nur vom UI-Thread bearbeitet werden: Der Kurs von 2008 musste in seinen Callback-Methoden [listBoxEvts.Invoke(...)] verwenden, damit die Aktualisierung von diesem Thread ausgeführt wurde. Mit [await] ist das nicht mehr nötig: Der Oberflächen-Thread besitzt einen Synchronisierungskontext ([SynchronizationContext.Current] ist nicht [null]), den [await] speichert; nach dem Warten wird der Rest der Methode an diesen Kontext zurückgegeben und somit vom Oberflächen-Thread ausgeführt. Wir können schreiben:

1
2
3
4
5
6
private async void DownloadButton_Click(object sender, EventArgs e)
{
    statusLabel.Text = "downloading…";                     // Oberflächen-Thread
    string page = await client.GetStringAsync(address);     // die Oberfläche bleibt während des Wartens reaktionsfähig
    pageTextBox.Text = page;                                 // zurück im Oberflächen-Thread
}

Diese Rückkehr in den ursprünglichen Kontext hat Kosten und ein Risiko: Blockiert Code den Oberflächen-Thread, während er auf einen Task wartet ([task.Result]), und benötigt dieser Task denselben Thread, um seinen restlichen Code auszuführen, warten beide unendlich lange aufeinander („Deadlock“). Das ist der Hauptgrund für die Regel „kein [.Result]“.

Die Methode [ConfigureAwait(false)] weist [await] an, nicht in den ursprünglichen Kontext zurückzukehren: [await stream.ReadAsync(buffer).ConfigureAwait(false);]. Der restliche Code wird dann von einem Thread des Pools ausgeführt. Die Empfehlungen lauten wie folgt:

  • Im Code einer universell einsetzbaren Bibliothek (die keine grafische Benutzeroberfläche behandelt und nicht weiß, wer sie aufruft) verwenden Sie [ConfigureAwait(false)] bei jedem [await]: Das ist etwas effizienter und verhindert Deadlocks, falls ein unvorsichtiger Aufrufer [.Result] verwendet;
  • im Code von Anwendungen (grafische Benutzeroberfläche, Konsolenprogramm, ASP.NET-Core-Anwendung) wird es nicht geschrieben. Konsolenprogramme und ASP.NET-Core-Anwendungen haben ohnehin keinen Synchronisierungskontext: [ConfigureAwait(false)] macht dort keinen Unterschied.

Die Beispiele dieses Kurses, bei denen es sich um Anwendungen handelt, verwenden [ConfigureAwait] nicht.

9.10.3. TaskCompletionSource<T>: ein Ereignis in einen Task umwandeln

Manchmal muss man eine API verwenden, die das Ende ihrer Operationen über ein Ereignis meldet (das EAP-Modell oder jede Klasse, die Ereignisse veröffentlicht), während der restliche Code mit [await] geschrieben ist. Die Klasse [TaskCompletionSource<T>] erlaubt es, einen Task zu erzeugen, den Sie selbst zum gewünschten Zeitpunkt beenden:

  • ihre Eigenschaft [Task] ist ein unbeendeter [Task<T>], der an den Aufrufer zurückgegeben wird;
  • [SetResult(value)] / [TrySetResult(value)] schließt den Task erfolgreich ab;
  • [SetException(exception)] / [TrySetException(exception)] beendet ihn mit einem Fehler;
  • [SetCanceled()] / [TrySetCanceled()] bricht ihn ab.

Die [TryXxx]-Methoden geben [false] zurück, statt eine Ausnahme auszulösen, wenn der Task bereits abgeschlossen ist. Tatsächlich war es ein [TaskCompletionSource<int>] , den die vereinfachte Zustandsmaschine der oben vorgestellten Methode [CountSugarsAsync] verwendete. Das Programm [async-19.cs] wartet darauf, dass ein Thermometer, das seine Messwerte über ein Ereignis veröffentlicht, eine bestimmte Temperatur erreicht:

// TaskCompletionSource<T>: eine ereignisbasierte API in einen Task umwandeln
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
var thermometer = new Thermometer();
thermometer.Start();

// 1 - wir warten, ohne einen Thread zu blockieren, auf die erste Messung größer oder gleich 21 °C
double measure = await WaitForTemperatureAsync(thermometer, 21, CancellationToken.None);
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : 1 - temperature reached: {measure} °C");

// 2 - dasselbe Warten, auf eine Sekunde begrenzt: der Task wird abgebrochen
using (var timeout = new CancellationTokenSource(1000))
{
    try
    {
        measure = await WaitForTemperatureAsync(thermometer, 30, timeout.Token);
        Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : 2 - temperature reached: {measure} °C");
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : 2 - 30 °C not reached within one second");
    }
}
thermometer.Stop();

// wandelt die MeasureTaken-Ereignisse des Thermometers in einen Task um
static Task<double> WaitForTemperatureAsync(Thermometer thermometer, double threshold, CancellationToken token)
{
    // die Quelle eines Tasks, den wir selbst abschließen
    var source = new TaskCompletionSource<double>(TaskCreationOptions.RunContinuationsAsynchronously);
    // die Registrierung beim Abbruch-Token, die freizugeben ist, wenn der Task abgeschlossen ist
    CancellationTokenRegistration registration = default;
    // der Ereignishandler schließt den Task ab, wenn der Schwellenwert erreicht ist
    void OnMeasure(object? sender, double temperature)
    {
        if (temperature >= threshold && source.TrySetResult(temperature))
        {
            thermometer.MeasureTaken -= OnMeasure;
            registration.Dispose();
        }
    }
    thermometer.MeasureTaken += OnMeasure;
    // eine Abbruchanforderung schließt den Task mit dem Status Canceled ab
    registration = token.Register(() =>
    {
        if (source.TrySetCanceled(token))
        {
            thermometer.MeasureTaken -= OnMeasure;
        }
    });
    // der Task wird sofort zurückgegeben; er wird später abgeschlossen
    return source.Task;
}

// ein Thermometer, das über ein Ereignis alle 200 ms eine Messung veröffentlicht (API „im alten Stil“)
class Thermometer
{
    public event EventHandler<double>? MeasureTaken;
    private Timer? timer;
    private double temperature = 19;

    public void Start()
    {
        timer = new Timer(_ =>
        {
            temperature += 0.5;
            Console.WriteLine($"          measure: {temperature} °C");
            MeasureTaken?.Invoke(this, temperature);
        }, null, 200, 200);
    }

    public void Stop()
    {
        timer?.Dispose();
    }
}

Ergebnisse:

> dotnet run async-19.cs
          measure: 19.5 °C
          measure: 20 °C
          measure: 20.5 °C
          measure: 21 °C
  805 ms : 1 - temperature reached: 21 °C
          measure: 21.5 °C
          measure: 22 °C
          measure: 22.5 °C
          measure: 23 °C
          measure: 23.5 °C
 1812 ms : 2 - 30 °C not reached within one second

Erläuterungen:

  • Zeilen 57–75: Das Thermometer, eine Klasse „alter Schule“: Ein Timer ([System.Threading.Timer], der in regelmäßigen Abständen eine Methode in einem Thread des Pools ausführt) erhöht die Temperatur alle 200 ms um 0,5 °C und veröffentlicht sie über das Ereignis [MeasureTaken] vom Typ [EventHandler<double>] (Ereignisse wurden in Kapitel 7 behandelt);
  • Zeilen 28–53: die Methode, die Ereignisse in einen Task umwandelt. Sie ist nicht [async]: Sie erzeugt eine [TaskCompletionSource<double>], abonniert das Ereignis mit einem Handler und gibt sofort den Task der Quelle zurück, der noch nicht abgeschlossen ist;
  • Zeile 31: Diese Option legt fest, dass der restliche Code, der auf den Task wartet, nicht von dem Thread ausgeführt werden soll, der [TrySetResult] aufruft (hier der Timer-Thread, mitten in der Auslösung des Ereignisses), sondern von einem Thread des Pools. Dies ist in fast allen Fällen die empfohlene Option;
  • Zeilen 35–40: Bei jeder Messung prüft der Handler den Schwellenwert. Ist er erreicht, beendet der Handler den Task mit der Temperatur als Ergebnis, kündigt dann das Abonnement des Ereignisses und gibt die Registrierung beim Abbruchtoken frei;
  • Zeilen 45–47: [token.Register(action)] registriert eine Aktion, die ausgeführt wird, wenn ein Abbruch angefordert wird. Hier bricht sie den Task ab (Status [Canceled]) und kündigt das Abonnement des Handlers. Ohne dies würde ein Task, der auf einen nie erreichten Schwellenwert wartet, nie enden;
  • Zeilen 9–22: Für den Aufrufer ist das Warten auf eine Temperatur eine asynchrone Methode wie jede andere: Auf sie wird mit [await] gewartet, und sie wird mit einem Abbruchtoken zeitlich begrenzt.

[Task.Factory.FromAsync], weiter oben erwähnt, spielt dieselbe Rolle für die APIs des APM-Modells ([BeginXxx] / [EndXxx]).

9.11. Asynchrone Parallelität

9.11.1. Parallel.ForEachAsync

[Task.WhenAll] startet alle Operationen gleichzeitig. Das ist nicht immer wünschenswert: Um 10.000 Webseiten herunterzuladen, möchte man nicht 10.000 gleichzeitige Verbindungen zum selben Server öffnen. Das vorige Kapitel führte [Parallel.ForEach] ein, das die Verarbeitung einer Sammlung auf mehrere Threads verteilt; seine asynchrone Version [Parallel.ForEachAsync] (.NET 6) verarbeitet die Elemente einer Sammlung mit einer asynchronen Funktion und begrenzt dabei die Anzahl gleichzeitiger Operationen. Das Programm [async-20.cs] lädt neun Seiten herunter, höchstens drei gleichzeitig:

// Parallel.ForEachAsync: eine Sammlung mit einer begrenzten Anzahl gleichzeitiger Operationen verarbeiten
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
string[] pages = [.. Enumerable.Range(1, 9).Select(i => $"page{i}.html")];
int inProgress = 0;

// höchstens 3 Downloads gleichzeitig
var options = new ParallelOptions { MaxDegreeOfParallelism = 3 };
await Parallel.ForEachAsync(pages, options, async (page, token) =>
{
    // von den gleichzeitigen Operationen gemeinsam genutzter Zähler: wir ändern ihn atomar
    int n = Interlocked.Increment(ref inProgress);
    Display($"start of {page} ({n} in progress)");
    // der simulierte Download einer Seite
    await Task.Delay(1000, token);
    Interlocked.Decrement(ref inProgress);
    Display($"end of {page}");
});
Display($"the {pages.Length} pages are downloaded");

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms [thread {Environment.CurrentManagedThreadId,2}] : {message}");
}

Ergebnisse:

> dotnet run async-20.cs
   12 ms [thread  4] : start of page1.html (1 in progress)
   12 ms [thread  6] : start of page2.html (2 in progress)
   29 ms [thread  6] : start of page3.html (3 in progress)
 1024 ms [thread  6] : end of page1.html
 1025 ms [thread  6] : start of page4.html (3 in progress)
 1028 ms [thread  4] : end of page3.html
 1028 ms [thread  6] : end of page2.html
 1029 ms [thread  4] : start of page5.html (2 in progress)
 1029 ms [thread  6] : start of page6.html (3 in progress)
 2023 ms [thread  6] : end of page4.html
 2023 ms [thread  6] : start of page7.html (3 in progress)
 2028 ms [thread  6] : end of page6.html
 2028 ms [thread  6] : start of page8.html (3 in progress)
 2030 ms [thread  4] : end of page5.html
 2030 ms [thread  4] : start of page9.html (3 in progress)
 3025 ms [thread  8] : end of page9.html
 3026 ms [thread  8] : end of page7.html
 3025 ms [thread  4] : end of page8.html
 3026 ms [thread  4] : the 9 pages are downloaded

Erläuterungen:

  • Zeile 5: die neun Seitennamen, aufgebaut mit einem Sammlungsausdruck mit dem Spread-Operator [..];
  • Zeile 9: Die Eigenschaft [MaxDegreeOfParallelism] von [ParallelOptions] legt die maximale Anzahl gleichzeitiger Operationen fest (standardmäßig die Anzahl der Prozessoren). Hier kann auch ein Abbruchtoken ([CancellationToken]) gesetzt werden;
  • Zeilen 10–18: [Parallel.ForEachAsync] erhält die Sammlung, die Optionen und eine asynchrone Funktion (ein [async]-Lambda), die für jedes Element mit dem Element und einem Abbruchtoken aufgerufen wird, das an die asynchronen Operationen der Funktion weiterzureichen ist. [Parallel.ForEachAsync] gibt einen Task zurück, der abgeschlossen ist, wenn alle Elemente verarbeitet wurden;
  • Zeilen 13–17: Die Funktionen laufen gleichzeitig auf mehreren Threads: Der Zähler [inProgress], den sie gemeinsam nutzen, wird mit der Klasse [Interlocked] aus dem vorigen Kapitel atomar verändert;
  • Die Ergebnisse zeigen drei Wellen mit je drei Seiten: Sobald eine Seite fertig ist, beginnt eine andere, und die Zahl der laufenden Downloads überschreitet nie 3. Die gesamte Verarbeitung dauert 3 Sekunden statt 9. Wenn zwei Threads nahezu gleichzeitig schreiben, kann die Reihenfolge der Zeilen von einer Ausführung zur nächsten variieren, und eine angezeigte Zeit kann sogar geringfügig früher liegen als die der vorherigen Zeile;
  • nur zwei oder drei Threads haben alle Funktionen ausgeführt: Während der Wartezeiten ist kein Thread beschäftigt.

9.11.2. Producer/Consumer: System.Threading.Channels

Das vorige Kapitel führte das Muster Producer/Consumer anhand der Sammlung [BlockingCollection<T>] ein: Producer-Threads stellen Elemente in eine Warteschlange, Consumer-Threads entnehmen sie; [Take] (oder die Aufzählung [GetConsumingEnumerable]) blockiert einen Consumer, solange die Warteschlange leer ist, während [Add] einen Producer blockiert, solange eine begrenzte Warteschlange voll ist. Diese Wartevorgänge blockieren Threads. Channels im Namespace [System.Threading.Channels] (.NET Core 3.0) bieten denselben Dienst mit asynchronem Warten:

  • [Channel.CreateBounded<T>(capacity)] erzeugt einen begrenzten Channel, [Channel.CreateUnbounded<T>()] erzeugt einen unbegrenzten Channel;
  • die Eigenschaft [Writer] ([ChannelWriter<T>]) wird von Producern verwendet: [WriteAsync] veröffentlicht ein Element (und wartet asynchron, bis Platz frei wird), [TryWrite] versucht, es sofort hinzuzufügen, [Complete] zeigt an, dass keine weiteren Elemente mehr folgen;
  • Die Eigenschaft [Reader] ([ChannelReader<T>]) wird von Consumern verwendet: [ReadAsync] ruft ein Element ab, während [ReadAllAsync] einen asynchronen Stream aller Elemente zurückgibt, der endet, wenn der Channel durch [Complete] geschlossen und leer ist.

Das Programm [async-21.cs] verarbeitet Bestellungen, die alle 50 ms erzeugt werden, mit zwei Consumern, die jeweils 400 ms für die Verarbeitung einer Bestellung benötigen:

// Produzent / Konsumenten mit einem Channel (System.Threading.Channels)
using System.Diagnostics;
using System.Threading.Channels;

var stopwatch = Stopwatch.StartNew();
// ein begrenzter Channel: er enthält höchstens 2 Bestellungen, die auf ihre Verarbeitung warten
Channel<int> channel = Channel.CreateBounded<int>(2);

// der Produzent und zwei Konsumenten arbeiten gleichzeitig
Task producer = ProduceAsync(channel.Writer, 8);
Task consumer1 = ConsumeAsync("C1", channel.Reader);
Task consumer2 = ConsumeAsync("C2", channel.Reader);
await Task.WhenAll(producer, consumer1, consumer2);
Display("all the orders have been processed");

// der Produzent: eine Bestellung alle 50 ms
async Task ProduceAsync(ChannelWriter<int> writer, int nbOrders)
{
    for (int i = 1; i <= nbOrders; i++)
    {
        await Task.Delay(50);
        // TryWrite verwirft die Bestellung sofort, wenn im Channel Platz ist
        if (writer.TryWrite(i))
        {
            Display($"P  : order {i} dropped");
        }
        else
        {
            // Channel voll: WriteAsync wartet (ohne einen Thread zu blockieren), bis ein Platz frei wird
            Display($"P  : channel full, order {i} waits");
            await writer.WriteAsync(i);
            Display($"P  : order {i} dropped");
        }
    }
    // es wird nichts mehr geschrieben: die Konsumenten verlassen ihre Schleife
    writer.Complete();
    Display("P  : end of the production");
}

// ein Konsument: die Verarbeitung einer Bestellung dauert 400 ms
async Task ConsumeAsync(string name, ChannelReader<int> reader)
{
    // ReadAllAsync gibt einen asynchronen Datenstrom zurück, der endet, wenn der Channel geschlossen und leer ist
    await foreach (int order in reader.ReadAllAsync())
    {
        Display($"{name} : processing of order {order}");
        await Task.Delay(400);
    }
    Display($"{name} : no more orders");
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

Ergebnisse:

> dotnet run async-21.cs
   63 ms : C1 : processing of order 1
   63 ms : P  : order 1 dropped
  130 ms : P  : order 2 dropped
  130 ms : C2 : processing of order 2
  181 ms : P  : order 3 dropped
  233 ms : P  : order 4 dropped
  284 ms : P  : channel full, order 5 waits
  479 ms : P  : order 5 dropped
  479 ms : C1 : processing of order 3
  530 ms : P  : channel full, order 6 waits
  530 ms : C2 : processing of order 4
  530 ms : P  : order 6 dropped
  583 ms : P  : channel full, order 7 waits
  879 ms : C1 : processing of order 5
  879 ms : P  : order 7 dropped
  930 ms : P  : channel full, order 8 waits
  930 ms : C2 : processing of order 6
  930 ms : P  : order 8 dropped
  935 ms : P  : end of the production
 1277 ms : C1 : processing of order 7
 1330 ms : C2 : processing of order 8
 1679 ms : C1 : no more orders
 1731 ms : C2 : no more orders
 1731 ms : all the orders have been processed

Erläuterungen:

  • Zeile 7: eine Warteschlange von Ganzzahlen (mit den Bestellnummern), die höchstens 2 ausstehende Bestellungen aufnimmt;
  • Zeilen 10–13: Der Producer und die beiden Consumer sind drei asynchrone Methoden, die gleichzeitig gestartet werden; das Programm wartet, bis alle drei beendet sind;
  • Zeilen 23–31: Der Producer versucht, jede Bestellung mit [TryWrite] einzureichen. Ist der Channel voll, meldet er dies und wartet mit [WriteAsync], bis Platz frei wird: Der Producer wird auf das Tempo der Consumer gedrosselt (Zeilen 8–9), ohne dass ein Thread blockiert wird. Das ist der Vorteil eines begrenzten Channels: Ein zu schneller Producer kann den Speicher nicht füllen;
  • Zeile 36: Die Produktion ist beendet. Die Consumer leeren den Channel und verlassen dann ihre Schleife;
  • Zeilen 44–49: Jeder Consumer verarbeitet den asynchronen Stream [ReadAllAsync]. Eine Bestellung wird nur an einen Consumer ausgeliefert: Die Bestellungen werden je nach Verfügbarkeit auf C1 und C2 verteilt;
  • Wie im vorigen Beispiel können zwei nahezu gleichzeitig angezeigte Zeilen in vertauschter Reihenfolge erscheinen (die angezeigten Zeitstempel sind daher nicht immer aufsteigend).

Channels sind das moderne Werkzeug für das Producer/Consumer-Muster, sowohl zwischen asynchronen Methoden als auch zwischen Threads.

9.12. Zeit: PeriodicTimer und TimeProvider

Zwei neuere Klassen runden die zeitbezogenen Werkzeuge ab:

  • [PeriodicTimer] (.NET 6) ist ein Timer, der mit [await] verwendet wird: Seine Methode [WaitForNextTickAsync] gibt einen Task zurück, der beim nächsten „Tick“ abgeschlossen wird. Anders als [System.Threading.Timer] (verwendet in [async-19.cs]), der eine Callback-Methode in einem Thread des Pools aufruft – möglicherweise, während der vorherige Aufruf noch läuft –, [PeriodicTimer] wird er als einfache Schleife geschrieben und überlappt nie zwei Ausführungen;
  • [TimeProvider] (.NET 8) ist eine abstrakte Klasse, die die Uhr darstellt: die aktuelle Zeit ([GetUtcNow], [GetLocalNow]), die Zeitmessung ([GetTimestamp], [GetElapsedTime]) und die Erzeugung von Timern. [TimeProvider.System] ist die Systemuhr. Eine Klasse, die von der Zeit abhängt, erhält einen [TimeProvider] , statt direkt [DateTime.Now] zu verwenden: Sie kann dann mit einer kontrollierten Uhr getestet werden.

Das Programm [async-22.cs] verwendet beide:

// Zeit: PeriodicTimer und TimeProvider
// 1 - PeriodicTimer: eine Aktion alle 500 ms, nach 2,2 Sekunden gestoppt
TimeProvider clock = TimeProvider.System;
long start = clock.GetTimestamp();
using (var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(500)))
using (var stop = new CancellationTokenSource(TimeSpan.FromSeconds(2.2)))
{
    int nbTicks = 0;
    try
    {
        // WaitForNextTickAsync gibt bei jedem Tick true zurück, false, wenn der Timer durch Dispose gestoppt wird
        while (await timer.WaitForNextTickAsync(stop.Token))
        {
            nbTicks++;
            Console.WriteLine($"{clock.GetElapsedTime(start).TotalMilliseconds,6:F0} ms : tick no. {nbTicks}");
        }
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"{clock.GetElapsedTime(start).TotalMilliseconds,6:F0} ms : timer stopped after {nbTicks} ticks");
    }
}

// 2 - TimeProvider: eine Klasse, die von der Zeit abhängt, erhält ihre Uhr, statt DateTime.Now zu lesen
var morning = new FixedClock(new DateTimeOffset(2026, 10, 3, 9, 30, 0, TimeSpan.Zero));
var evening = new FixedClock(new DateTimeOffset(2026, 10, 3, 19, 45, 0, TimeSpan.Zero));
Console.WriteLine(new Welcome(morning).Greet("Pierre"));
Console.WriteLine(new Welcome(evening).Greet("Pierre"));

// eine Klasse, die von der aktuellen Zeit abhängt
class Welcome(TimeProvider clock)
{
    public string Greet(string name)
    {
        DateTimeOffset now = clock.GetLocalNow();
        string greeting = now.Hour < 18 ? "Hello" : "Good evening";
        return $"[{now:dd/MM/yyyy HH:mm}] {greeting} {name}";
    }
}

// eine angehaltene Uhr für die Tests: sie liefert immer dieselbe Zeit (in Weltzeit)
class FixedClock(DateTimeOffset instant) : TimeProvider
{
    public override DateTimeOffset GetUtcNow() => instant;
    public override TimeZoneInfo LocalTimeZone => TimeZoneInfo.Utc;
}

Ergebnisse:

1
2
3
4
5
6
7
8
> dotnet run async-22.cs
   507 ms : tick no. 1
  1003 ms : tick no. 2
  1505 ms : tick no. 3
  2001 ms : tick no. 4
  2227 ms : timer stopped after 4 ticks
[03/10/2026 09:30] Hello Pierre
[03/10/2026 19:45] Good evening Pierre

Erläuterungen:

  • Zeilen 5–20: ein Timer mit 500 ms und eine Abbruchquelle mit 2,2 Sekunden. [WaitForNextTickAsync(token)] gibt bei jedem Taktimpuls [true] zurück und [false] , wenn der Timer freigegeben wurde ([Dispose]); hier stoppt der Abbruch die Schleife nach 4 Ticks;
  • Zeile 4: [GetTimestamp] und [GetElapsedTime] von [TimeProvider] messen eine Dauer, genau wie die gleichnamigen Methoden von [Stopwatch];
  • Zeilen 31–37: Die Klasse [Welcome] sagt je nach Uhrzeit „Guten Tag“ oder „Guten Abend“. Sie erhält ihre Uhr in ihrem primären Konstruktor, statt sie aus [DateTime.Now] zu lesen: Es handelt sich um eine injizierte Abhängigkeit, genau wie die Schicht [dao] in Kapitel 6 in die Schicht [business] injiziert wird;
  • Zeilen 42–45: Eine stehende Uhr, abgeleitet von [TimeProvider], die die Weltzeit und die Zeitzone überschreibt. Sie erlaubt es, das Verhalten von [Welcome] morgens und abends zu prüfen, ohne bis zum Einbruch der Dunkelheit warten zu müssen. Das NuGet-Paket [Microsoft.Extensions.TimeProvider.Testing] stellt eine umfassendere Testuhr bereit, [FakeTimeProvider], die sich nach Belieben vorstellen lässt, auch für Verzögerungen und Timer ([Task.Delay(TimeSpan, TimeProvider)], [new PeriodicTimer(TimeSpan, TimeProvider)]).

9.13. Anwendung: Steuerberechnung mit asynchroner Ein- und Ausgabe

Das Programm [async-23.cs] vereint mehrere Werkzeuge dieses Kapitels in Bezug auf die Steuerberechnung, die sich durch den gesamten Kurs zieht. Es liest die Steuerstufen aus der Datei [TaxData.txt] (die bereits verwendet wurde) und liest eine Liste von Steuerpflichtigen aus der Datei [taxpayers.txt]:

1
2
3
4
5
6
7
y 2 60000
y 3 60000
n 0 60000
n 2 25000
y 5 120000
x 1 20000
y 1 -5

(jede Zeile enthält: verheiratet [y/n], Anzahl der Kinder, Jahresgehalt), berechnet die Steuer jedes Steuerpflichtigen und schreibt die Ergebnisse in die Datei [results.txt]. Alle Ein- und Ausgabeoperationen sind asynchron, und der gesamte Vorgang ist auf 10 Sekunden begrenzt.

// Anwendung: die Steuerberechnung mit asynchroner Ein- und Ausgabe
// - die Steuerstufen werden aus [TaxData.txt] gelesen, die Steuerpflichtigen aus [taxpayers.txt]
// - die Ergebnisse werden in [results.txt] geschrieben
using System.Globalization;

using var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(10));
try
{
    TaxBracket[] brackets = await LoadBracketsAsync("TaxData.txt", cancellation.Token);
    int nbResults = await CalculateTaxesAsync(brackets, "taxpayers.txt", "results.txt", cancellation.Token);
    Console.WriteLine($"{nbResults} lines written to [results.txt]:");
    Console.Write(await File.ReadAllTextAsync("results.txt", cancellation.Token));
}
catch (OperationCanceledException)
{
    Console.WriteLine("processing abandoned: timeout exceeded");
}
catch (Exception e) when (e is IOException or FormatException)
{
    Console.WriteLine($"error: {e.GetType().Name} : {e.Message}");
}

// liest die Steuerstufen (limit:coeffR:coeffN, Dezimalpunkt)
static async Task<TaxBracket[]> LoadBracketsAsync(string file, CancellationToken token)
{
    string[] lines = await File.ReadAllLinesAsync(file, token);
    return [.. lines.Where(l => l.Trim() != "").Select(TaxBracket.Parse)];
}

// liest die Steuerpflichtigen (verheiratet, Kinder, Gehalt), berechnet ihre Steuer und schreibt die Ergebnisse
static async Task<int> CalculateTaxesAsync(TaxBracket[] brackets, string input, string output, CancellationToken token)
{
    int nbLines = 0;
    await using var writer = new StreamWriter(output);
    await foreach (string line in File.ReadLinesAsync(input, token))
    {
        string[] fields = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
        string result = fields switch
        {
            [var m, var c, var s] when m is "y" or "n" && int.TryParse(c, out int children) && children >= 0
                                       && int.TryParse(s, out int salary) && salary >= 0
                => $"tax = {CalculateTax(brackets, m == "y", children, salary)} €",
            _ => "incorrect line",
        };
        await writer.WriteLineAsync($"{line,-12} : {result}");
        nbLines++;
    }
    return nbLines;
}

// die Steuerberechnung (Tarif von 2004 auf Einkommen von 2003, für die Übung beibehalten)
static int CalculateTax(TaxBracket[] brackets, bool married, int nbChildren, int salary)
{
    decimal shares = married ? nbChildren / 2m + 2 : nbChildren / 2m + 1;
    if (nbChildren >= 3)
    {
        shares += 0.5m;
    }
    decimal income = 0.72m * salary;
    decimal quotient = income / shares;
    // die erste Stufe, deren Grenze das Familienquotient überschreitet, andernfalls die letzte
    TaxBracket bracket = brackets.FirstOrDefault(t => quotient <= t.Limit, brackets[^1]);
    return (int)(bracket.CoeffR * income - bracket.CoeffN * shares);
}

// eine Steuerstufe
readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN)
{
    public static TaxBracket Parse(string line)
    {
        string[] fields = line.Split(':');
        return new TaxBracket(decimal.Parse(fields[0], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[1], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[2], CultureInfo.InvariantCulture));
    }
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run async-23.cs
7 lines written to [results.txt]:
y 2 60000    : tax = 4282 €
y 3 60000    : tax = 2959 €
n 0 60000    : tax = 11519 €
n 2 25000    : tax = 792 €
y 5 120000   : tax = 11109 €
x 1 20000    : incorrect line
y 1 -5       : incorrect line

Erläuterungen:

  • Zeile 6: eine Abbruchquelle, die den gesamten Vorgang auf 10 Sekunden begrenzt. Ihr Token wird an alle asynchronen Methoden übergeben;
  • Zeilen 24–27: das Lesen der Stufen. Der Sammlungsausdruck mit Spread [[.. sequence]] wandelt die LINQ-Sequenz in ein Array um;
  • Zeilen 31–48: die Verarbeitung der Steuerpflichtigen. Die Zeilen werden einzeln über den asynchronen Stream [File.ReadLinesAsync] gelesen, und die Ergebnisse werden mit [WriteLineAsync] in einen [StreamWriter] geschrieben, der durch [await using] freigegeben wird;
  • Zeilen 38–43: Validierung einer Zeile mit einem [switch]-Ausdruck, der ein Listenmuster mit drei Elementen ([[var m, var c, var s]]) und eine [when]-Klausel enthält, die die drei Felder prüft;
  • Zeilen 52–63: die Steuerberechnung. Die LINQ-Methode [FirstOrDefault] mit Standardwert gibt die erste Stufe zurück, deren Grenze größer oder gleich dem Familienquotienten ist, oder die letzte Stufe, falls keine zutrifft (ohne die Daten zu verändern, anders als der Code von 2008);
  • Zeilen 14–20: Mögliche Fehler werden an einer einzigen Stelle im Hauptprogramm behandelt: Überschreitung des Zeitlimits sowie Ein-/Ausgabe- oder Formatfehler (fehlende Datei, falsch eingegebene Zahl), gefiltert durch [when] mit einem [or]-Muster;
  • Die Ergebnisse liefern die Referenzwerte: 4.282 € für ein Ehepaar mit 2 Kindern und einem gemeinsamen Einkommen von 60.000 €; 2.959 € mit 3 Kindern; und 11.519 € für eine alleinstehende Person ohne Kinder.

Die Berechnung selbst ist synchron: Sie führt keine Ein-/Ausgabe durch und dauert einige Mikrosekunden. Es wäre sinnlos – und sogar schädlich –, sie asynchron zu machen. Nur Operationen, die ein Warten beinhalten, werden asynchron gestaltet.

9.14. Die goldenen Regeln

Fassen wir die Regeln der asynchronen Programmierung mit .NET zusammen:

  • async durchgängig: Eine Methode, die auf eine asynchrone Operation wartet, wird selbst asynchron ([async Task]), und ebenso ihre Aufrufer, bis hin zum Einstiegspunkt ([Main] asynchron, Ereignishandler, Controller-Aktion in ASP.NET Core). Das Vermischen von asynchronem Code mit blockierendem Warten hebt die Vorteile der Asynchronität auf;
  • verwenden Sie nicht [.Result], [.Wait()] oder [Task.WaitAll] bei einem unbeendeten Task: Nutzen Sie stattdessen [await], [Task.WhenAll], [Task.WhenAny] oder [Task.WhenEach]. Diese blockierenden Formen frieren einen Thread ein und können in grafischen Anwendungen dauerhafte Deadlocks verursachen;
  • verwenden Sie [Thread.Sleep] nicht in asynchronem Code: Nutzen Sie stattdessen [await Task.Delay(...)];
  • schreiben Sie keine [async void]-Methoden, außer in GUI-Ereignishandlern; eine asynchrone Methode sollte [Task] oder [Task<T>] zurückgeben (in Ausnahmefällen [ValueTask<T>]);
  • der Name einer asynchronen Methode endet auf [Async]: [CalculateTaxesAsync], [ReadRateAsync];
  • eine abbrechbare asynchrone Methode erhält ein [CancellationToken] als letzten Parameter und reicht es an alle asynchronen Operationen weiter, die sie aufruft; eine abgebrochene Operation endet mit einer [OperationCanceledException];
  • [Task.Run] ist Berechnungen vorbehalten, die Sie im Hintergrund ausführen möchten (etwa um zu vermeiden, dass ein GUI-Thread blockiert wird). Verpacken Sie keine synchrone Ein-/Ausgabeoperation in [Task.Run] , um sie „asynchron zu machen“: Verwenden Sie die Version [XxxAsync] der Operation;
  • erst starten, dann warten: Um mehrere unabhängige Operationen gleichzeitig auszuführen, starten Sie alle und warten dann mit [Task.WhenAll] auf sie; um die Anzahl der Operationen zu begrenzen, verwenden Sie [Parallel.ForEachAsync] oder einen Channel;
  • [ConfigureAwait(false)] wird in Bibliotheken verwendet, nicht in Anwendungen;
  • auf einen gestarteten Task muss gewartet werden (oder er wird ausdrücklich mit [_ =] ignoriert, wobei seine Ausnahmen zu behandeln sind): Ein vergessener Task verbirgt seine Ausnahmen und kann durch das Programmende unterbrochen werden.

Die folgende Tabelle fasst die Entsprechungen zwischen der Welt der Threads (vorheriges Kapitel, Kurs von 2008) und der der Tasks zusammen:

Threads, blockierendes Warten
Tasks, asynchrones Warten
[Thread.Sleep(1000)]
[await Task.Delay(1000)]
[thread.Start()] gefolgt von [thread.Join()]
[var t = MethodAsync();] dann [await t]
Auf mehrere Threads warten ([Join] in einer Schleife, [Task.WaitAll])
[await Task.WhenAll(...)]
[Thread.Abort()] (veraltet), [BackgroundWorker.CancelAsync]
[CancellationTokenSource.Cancel()] und [CancellationToken]
[BackgroundWorker.ReportProgress] / [ProgressChanged]
[IProgress<T>.Report]
[BackgroundWorker.RunWorkerCompleted]
Der Code nach [await]
[BeginXxx] / [EndXxx] und Callback-Methoden (APM)
[await XxxAsync(...)]
[Control.Invoke] , um in den Oberflächen-Thread zurückzukehren
[await], das automatisch in den Synchronisierungskontext zurückkehrt
[BlockingCollection<T>] ([Add] / [GetConsumingEnumerable])
[Channel<T>] ([WriteAsync] / [ReadAllAsync])
[System.Threading.Timer]
[PeriodicTimer]

Die folgenden Kapitel wenden diese Regeln an: asynchroner Datenbankzugriff mit ADO.NET (Kapitel 10) und Entity Framework Core (Kapitel 11), asynchroner TCP-Server für mehrere Clients und [HttpClient]-Client (Kapitel 12), ASP.NET-Core-Webdienste und ihre [HttpClient]-Clients (Kapitel 13).