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:

- 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.
Ergebnisse:
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).
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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:
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:
Ergebnisse:
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]:
Ergebnisse, zuerst mit und dann ohne Argument:
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:
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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.
Ergebnisse:
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:
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:
Ergebnisse ohne Abbruch:
Ergebnisse, wenn der Benutzer [Enter] während des Kopiervorgangs nach eineinhalb Sekunden eingibt:
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:
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.
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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:
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:
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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:
Ergebnisse:
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]:
(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.
Ergebnisse:
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).