7. Delegates, Lambdas und Ereignisse
Im Kurs von 2008 folgte dieses Kapitel auf das Kapitel über grafische Windows-Forms-Benutzeroberflächen: Ereignisse wurden zunächst im Zusammenhang mit Schaltflächen und Formularen eingeführt, und anschließend lernten die Studierenden, Ereignisse in eigenen Klassen zu erstellen. Das Kapitel über grafische Benutzeroberflächen wurde in dieser Version des Kurses gestrichen. Wir beginnen daher direkt mit dem Konzept, das den gesamten Mechanismus trägt: dem Delegate, also einem Objekt, das eine oder mehrere Methoden referenziert. Alle Beispiele sind Konsolenprogramme.
In den vergangenen zwanzig Jahren sind Delegates zu einem der am häufigsten verwendeten Werkzeuge der Sprache geworden. Ihre Formulierung ist dank Lambda-Ausdrücken (C# 3) erheblich einfacher geworden; diese haben wir bereits – ohne auf Einzelheiten einzugehen – mit LINQ in Kapitel 5 verwendet: [Where(n => n > 5)] übergibt ein Lambda – und damit ein Delegate – an die Methode [Where]. Dieses Kapitel erklärt, was hinter dieser Syntax steckt. Es schließt mit den Ereignissen, die ebenfalls auf Delegates beruhen. Die grafischen Benutzeroberflächen von .NET (Windows Forms, WPF, .NET MAUI) sowie die Web-Frameworks basieren auf diesem Mechanismus: Ein Klick auf eine Schaltfläche oder das Eintreffen einer HTTP-Anfrage wird abonnierten Methoden signalisiert.
Die Programme dieses Kapitels sind Single-File-Anwendungen im Ordner [07-delegates]. Sie werden mit [dotnet run delegates-NN.cs] ausgeführt.
7.1. Vordefinierte Delegate-Typen
7.1.1. Das Konzept des Delegates
Ein Delegate-Typ beschreibt ein Muster (auch Prototyp oder Signatur genannt) einer Methode: die Typen ihrer Parameter und den Typ ihres Rückgabewerts. Eine Variable eines Delegate-Typs kann dann jede Methode referenzieren, die diesem Muster entspricht, und sie ausführen.
Das .NET Framework definiert zahlreiche Delegate-Typen. Der älteste ist [EventHandler], der von allen Ereignissen verwendet wird, die wir am Ende dieses Kapitels besprechen. Er ist wie folgt definiert:
Das Schlüsselwort [delegate] macht [EventHandler] zu einem Delegate-Typ. Dieser Typ bezeichnet ein Methodenmuster:
- dessen erster Parameter ein Objekt vom Typ [object?] ist (das Objekt, das das Ereignis ausgelöst hat, möglicherweise [null]);
- dessen zweiter Parameter ein Objekt vom Typ [EventArgs] ist (Informationen über das Ereignis);
- das kein Ergebnis zurückgibt ([void]).
Eine Methode, die dem durch [EventHandler] definierten Muster entspricht, könnte wie folgt aussehen:
Um ein Objekt vom Typ [EventHandler] zu erstellen, das diese Methode referenziert, können Sie schreiben:
oder, einfacher:
In dieser zweiten Schreibweise wird der Methodenname [Display] (eine Methodengruppe, da eine Methode mehrere Überladungen haben kann) vom Compiler automatisch in ein Objekt [EventHandler] umgewandelt: Dies ist die Methodengruppenkonvertierung, die seit C# 2 möglich ist. Der Compiler wählt unter den Überladungen von [Display] diejenige aus, die zur Signatur des Delegates passt. Das Delegate wird dann wie eine Methode ausgeführt: [handler("program", EventArgs.Empty)].
7.1.2. Die generischen Delegates Func, Action und Predicate
Vor den Generics (C# 2) musste man für jede Methodensignatur einen eigenen Delegate-Typ definieren. Heute stellt das Framework generische Delegate-Typen bereit, die nahezu alle Anforderungen abdecken:
Delegate-Typ | Referenzierte Methoden |
[Action] | Keine Parameter, kein Rückgabewert: [void M()] |
[Action<T1, ..., T16>] | 1 bis 16 Parameter, kein Ergebnis: [void M(T1 p1, ...)] |
[Func<TResult>] | Keine Parameter, ein Ergebnis: [TResult M()] |
[Func<T1, ..., T16, TResult>] | 1 bis 16 Parameter, ein Ergebnis vom Typ [TResult] (stets der letzte Typ) |
[Predicate<T>] | ein Parameter, ein boolesches Ergebnis: [bool M(T p)] |
[Comparison<T>] | zwei Parameter desselben Typs, ein ganzzahliges Ergebnis: [int M(T x, T y)] |
[Predicate<T>] und [Func<T, bool>] beschreiben dieselbe Signatur, sind aber zwei verschiedene Typen: [Predicate<T>] stammt aus .NET 2 und wird von den Methoden von [List<T>] und [Array] ([FindAll], [RemoveAll], [Exists] …) verwendet, während LINQ, das mit .NET 3.5 eingeführt wurde, [Func<T, bool>] verwendet.
Das Programm [delegates-01.cs] verwendet diese Delegate-Typen:
Ergebnisse:
Kommentare:
- Zeile 4: Erstellung eines Delegates [EventHandler] mit dem Operator [new]. In C# 1 war dies die vorgeschriebene Syntax;
- Zeile 6: dasselbe mit einer Methodengruppenkonvertierung. Dies ist heute die übliche Syntax;
- Zeile 8: Das Delegate wird wie eine Methode ausgeführt. Die Methode [Display] aus Zeile 39 wird mit den Parametern ausgeführt, die an das Delegate übergeben wurden;
- Zeile 11: [Func<int, int, int>] verweist auf eine Methode mit zwei Parametern [int], die einen [int] zurückgibt (der letzte generische Typ). Die Methode [Add] in Zeile 44 passt;
- Zeile 14: [Func<string>] verweist auf eine Methode ohne Parameter, die eine Zeichenkette zurückgibt;
- Zeile 18: [Action<string>] verweist auf eine Methode mit einem Parameter [string], ohne Rückgabewert. [Console.WriteLine] hat viele Überladungen; der Compiler wählt [WriteLine(string)];
- Zeile 22: Ein Prädikat ist eine Methode, die einen booleschen Wert zurückgibt. Die Methode [FindAll] der Klasse [List<T>] (Zeile 25) erwartet einen Parameter vom Typ [Predicate<T>]: Sie gibt die Liste der Elemente zurück, für die das Prädikat [true] liefert. Zeile 26: Der Name der Methode
[IsEven]wird direkt übergeben; der Compiler wandelt ihn in*[Predicate<int>]* um; - Zeile 31: Die Methode [Sort] akzeptiert ein Delegate [Comparison<T>] , das zwei Elemente vergleicht (mit negativem, null- oder positivem Ergebnis, wie [CompareTo]). Hier werden die Namen aufsteigend nach Länge sortiert;
- Zeilen 35–36: Ein Delegate ist ein Objekt. Sein Typ, der in Zeile 9 der Ergebnisse angezeigt wird, ist [System.Func`3[System.Int32,System.Int32,System.Int32]]: der technische Name eines generischen Typs mit drei Typparametern. Jeder Delegate-Typ leitet sich von der Klasse [System.Delegate] ab, die insbesondere die Eigenschaften [Method] (die referenzierte Methode) und [Target] bereitstellt (das Objekt, auf dem die Methode aufgerufen wird, [null] bei einer statischen Methode);
- der Name der Methode in Zeile 10 der Ausgabe ist überraschend: Die Methoden in den Zeilen 39–50 sind lokale Funktionen des Hauptprogramms (siehe Kapitel 3). Der Compiler wandelt sie in statische Methoden einer von ihm generierten Klasse um, mit einem Namen, den kein C#-Programm schreiben kann.
7.2. Delegate-Typen definieren
Vordefinierte Typen reichen oft aus, aber Sie können auch eigene Delegate-Typen definieren. Die Anweisung:
definiert einen Typ namens [Operation], der ein Methodenmuster darstellt, das zwei ganze Zahlen entgegennimmt und eine ganze Zahl zurückgibt. Im Vergleich zu [Func<int, int, int>] hat der Typ [Operation] einen Namen, der seinen Zweck beschreibt, und seine Parameter haben Namen ([n1], [n2]), die von den Entwicklungswerkzeugen angezeigt werden.
Eine Variable [op] vom Typ [Operation] dient dazu, eine Liste von Methoden zu speichern, die dem Muster [Operation] entsprechen: Man spricht von einem Multicast-Delegate.
- Eine Methode vom Typ [f] wird in der Variablen [op] gespeichert mit [op = new Operation(f)] oder, einfacher, [op = f] gespeichert;
- Um eine Methode [g] zur Liste der bereits registrierten Methoden hinzuzufügen, schreibt man [op += g];
- Um eine bereits registrierte Methode [h] zu entfernen, schreibt man [op -= h];
- Die Anweisung [n = op(n1, n2)] führt alle in [op] registrierten Methoden in der Reihenfolge ihrer Registrierung mit den Parametern [n1] und [n2] aus. Das zurückgegebene Ergebnis [n] ist das der zuletzt ausgeführten Methode.
Der Kurs von 2008 gab an, dass es nicht möglich sei, die Ergebnisse aller Methoden zu erhalten. Es ist möglich, aber nicht mit einem einzigen Aufruf: Man muss die von [GetInvocationList] zurückgegebene Liste der Methoden durchlaufen und sie einzeln aufrufen. In der Praxis geben in einem Multicast-Delegate registrierte Methoden meistens [void] zurück.
Betrachten Sie das Beispiel [delegates-02.cs]:
Ergebnisse:
Kommentare:
- Zeile 73: Definition des Delegate-Typs [Operation]. In einer Anwendung mit Top-Level-Anweisungen werden Typdeklarationen (Klassen, Schnittstellen, Delegates usw.) nach den Anweisungen des Hauptprogramms platziert;
- Zeilen 48–67: Die Klasse [Calculations] hat zwei Instanzmethoden, [Add] und [Subtract], sowie eine statische Methode, [Increase], die alle drei die Signatur des Typs [Operation] haben;
- Zeile 5: Die Variable [op] hat den Typ [Operation]. Ihr wird eine erste Methodenreferenz zugewiesen, nämlich die der statischen Methode [Calculations.Increase];
- Zeile 7: Das Delegate [op] wird ausgeführt. Alle von [op] referenzierten Methoden werden mit den an [op] übergebenen Parametern ausgeführt. Hier wird nur die Methode [Calculations.Increase] ausgeführt;
- Zeile 11: Eine Instanz [c1] der Klasse [Calculations] wird erstellt;
- Zeile 13: Die Instanzmethode [c1.Add] wird dem Delegate [op] zugewiesen. [Increase] war eine statische Methode, [Add] ist eine Instanzmethode: Das spielt keine Rolle. Im zweiten Fall speichert das Delegate zusätzlich das Objekt [c1] (seine Eigenschaft [Target]), auf dem die Methode aufgerufen wird;
- Zeile 18: Dasselbe für die Instanzmethode [Subtract];
- Zeilen 23–24: Wir registrieren die beiden Methoden [Add] und [Subtract] im Delegate [op];
- Zeile 26: Beide Methoden werden ausgeführt (Zeilen 8–9 der Ergebnisse). Das erhaltene Ergebnis, 6, stammt von [Subtract], der zuletzt ausgeführten Methode;
- Zeilen 29–31: [GetInvocationList] gibt die Liste der Methoden des Delegates als Array [Delegate[]] zurück. Die LINQ-Methode [Cast<Operation>()] wandelt jedes ihrer Elemente in [Operation] um, sodass sie einzeln aufgerufen und ihre Ergebnisse jeweils abgerufen werden können;
- Zeile 34: Die Methode
[Subtract]wird aus dem Delegate entfernt. Die Schreibweise***[op -= c1.Subtract]ist äquivalent zu***[op = op - c1.Subtract]***. Das Ergebnis des Operators [-] hat den Typ [Operation?]: Wenn wir die letzte Methode aus einem Delegate entfernen, erhalten wir [null]*, kein leeres Delegate. Der Compiler, der Nullable-Typen verfolgt (siehe Kapitel 3), würde Warnungen ausgeben, wenn Sie [op -= c1.Subtract] gefolgt von [op(1, 1)] schrieben: [CS8601] bei der Zuweisung eines möglicherweise null-wertigen Werts an die nicht nullbare Variable [op] und [CS8602] beim Aufruf der Methode. Wir speichern das Ergebnis daher in einer Variablen vom Typ [Operation?] und prüfen sie vor der Ausführung (Zeile 36); - Zeile 42: Wir entfernen die letzte Methode; das resultierende Delegate ist [null] (Zeile 17 der Ergebnisse);
- Zeile 45: Ein Delegate kann auch über seine Methode [Invoke] ausgeführt werden: [op(1, 1)] und [op.Invoke(1, 1)] sind äquivalent. Mit dem Operator [?.] (C# 6) führt [empty?.Invoke(1, 1)] das Delegate nur aus, wenn es nicht [null] ist; andernfalls ergibt der Ausdruck [null] , und es wird nichts ausgeführt. Die Zeichenketteninterpolation stellt [null] als leere Zeichenkette dar. Diese Syntax werden wir bei der Behandlung von Ereignissen wiedersehen.
Ein Delegate ist ein unveränderliches Objekt: Die Operationen [+] und [-] (und damit auch [+=] und [-=]) verändern das bestehende Delegate nicht, sondern erzeugen ein neues. Diese Eigenschaft wird bei der Behandlung von Ereignissen wichtig sein.
7.3. Anonyme Methoden und Lambda-Ausdrücke
7.3.1. Von anonymen Methoden zu Lambdas
In den bisherigen Beispielen referenziert jedes Delegate eine benannte Methode, die an anderer Stelle im Programm geschrieben ist. Für kurze Methoden, die nur einmal verwendet werden, ist das umständlich. C# 2 führte anonyme Methoden ein: Der Methodenrumpf wird genau dort geschrieben, wo das Delegate erstellt wird. C# 3 führte eine noch knappere Syntax ein – die Lambda-Ausdrücke –, die anonyme Methoden praktisch verdrängt haben. Das Programm [delegates-03.cs] zeigt die verschiedenen Formen:
Ergebnisse:
Kommentare:
- Zeilen 4–6: eine anonyme Methode. Auf das Schlüsselwort [delegate] folgen die Parameterliste und der Methodenrumpf. Der Compiler generiert eine Methode (mit einem Namen seiner Wahl) und erstellt ein Delegate [Func<int, int, int>] , das sie referenziert. Es gibt weder einen Methodennamen noch einen Rückgabetyp: Der Rückgabetyp wird aus den Anweisungen [return] abgeleitet;
- Zeilen 11–13: dasselbe mit einem Lambda-Ausdruck. Wir schreiben die Parameterliste, den Operator [=>] (gelesen „ergibt“ oder „sodass“) und dann den Rumpf. Ein Lambda, dessen Rumpf ein von geschweiften Klammern umschlossener Block ist, ist ein Lambda mit Blockrumpf (Anweisungs-Lambda);
- Zeile 18: Die Parametertypen fehlen. Der Compiler leitet sie vom Ziel-Delegate-Typ [Func<int, int, int>] ab: [n1] und [n2] haben den Typ [int]. Der Rumpf besteht nur aus einem Ausdruck, dessen Wert das Ergebnis des Lambdas ist: Dies ist ein Lambda mit Ausdrucksrumpf (Lambda-Ausdruck). Dies ist die häufigste Form;
- Zeile 22: Bei einem einzelnen Parameter, dessen Typ nicht angegeben ist, sind die Klammern optional. [x => x * x] wird gelesen „x ergibt x mal x“. Zeile 23: Dasselbe Lambda mit einem einzelnen Parameter vom Typ [string] gibt einen booleschen Wert zurück: Es ist ein [Predicate<string>];
- Zeilen 27–28: Ohne Parameter werden leere Klammern verwendet. Ein Lambda, dessen Rumpf ein Methodenaufruf ([void]) ist, eignet sich für ein Delegate ([Action]);
- Zeilen 33–39: Ein Lambda mit Blockrumpf kann beliebige Anweisungen enthalten: Deklarationen, Schleifen, Tests usw.;
- Zeile 44: Das Unterstrichzeichen [_] bezeichnet einen ignorierten Parameter (Discard, C# 9). Es wird verwendet, wenn die Signatur des Delegates Parameter verlangt, die das Lambda nicht benötigt, was bei Ereignishandlern häufig vorkommt;
- Zeile 49: Die häufigste Verwendung von Lambdas besteht darin, sie direkt als Parameter an eine Methode zu übergeben, die ein Delegate erwartet. Vergleichen Sie mit [delegates-01.cs]: Es ist nicht mehr nötig, eine Methode [IsEven] zu schreiben;
- Zeile 50: ein Lambda vom Typ [Comparison<int>] , das den üblichen Vergleich umkehrt: Die Liste wird absteigend sortiert.
Fassen wir die Formen eines Lambda-Ausdrucks zusammen:
Form | Beispiel |
typisierte Parameter, Blockrumpf | [(int a, int b) => { return a + b; }] |
nicht typisierte Parameter, Ausdrucksrumpf | [(a, b) => a + b] |
ein einzelner nicht typisierter Parameter | [x => x * x] |
keine Parameter | [() => "Hello"] |
ignorierte Parameter | [(_, _) => Console.WriteLine("received")] |
Die Parameter sind entweder alle typisiert oder alle nicht typisiert: Beides zu mischen ist nicht möglich. In diesem Kurs verwenden wir Lambdas statt anonymer Methoden, die heute nur noch in seltenen Fällen nützlich sind.
7.3.2. Mehr zu Lambdas
Neuere Versionen von C# haben Lambdas erweitert. Das Programm [delegates-04.cs] zeigt diese Neuerungen:
Ergebnisse:
Kommentare:
- Zeile 4: Bis C# 9 hatte ein Lambda keinen eigenen Typ: Man musste stets den Ziel-Delegate-Typ angeben ([Func<int, int> twice = x => x * 2]). Seit C# 10 hat ein Lambda mit typisierten Parametern einen natürlichen Typ: hier [Func<int, int>], wie in Zeile 2 der Ergebnisse zu sehen ist. Wir können daher [var] schreiben. [var twice = x => x * 2;] wird jedoch vom Compiler abgelehnt, der den Typ von [x] nicht ableiten kann;
- Zeile 6: Der natürliche Typ eines Lambdas, das nichts zurückgibt, ist ein [Action<...>];
- Zeile 10: Auch eine Methodengruppe hat einen natürlichen Typ, sofern es nur eine Methode mit diesem Namen gibt. [var write = Console.WriteLine;] würde abgelehnt: [WriteLine] hat etwa zwanzig Überladungen;
- Zeile 14: Seit C# 10 können Sie den Rückgabetyp vor der Parameterliste angeben. Das ist hier notwendig: Die beiden Zweige des Bedingungsoperators haben unterschiedliche Typen ([int] und [string]), und der Compiler wüsste nicht, welchen Rückgabetyp er wählen soll;
- Zeile 18: Ab C# 12 können Lambda-Parameter Standardwerte haben, genau wie Methodenparameter. Die Zeilen 19–20 rufen das Lambda mit und ohne den zweiten Parameter auf;
- Zeile 22: Ebenso kann der letzte Parameter eines Lambdas [params] sein;
- Zeile 25: Weder die Typen [Func] noch [Action] können einen optionalen Parameter oder [params] darstellen. Der Compiler generiert dann einen anonymen Delegate-Typ, in diesem Fall [<>f__AnonymousDelegate0] (Zeile 10 der Ergebnisse). Er kann nur von [var] verwendet werden;
- Zeile 29: Ein als [static] deklariertes Lambda (C# 9) kann weder die lokalen Variablen der umgebenden Methode noch [this] verwenden. Es kann Konstanten verwenden, wie [Coefficient] in Zeile 28. Im nächsten Abschnitt sehen wir, was es bedeutet, eine lokale Variable zu „verwenden“; das Schlüsselwort [static] stellt sicher, dass ein Lambda keine erfasst, wodurch Speicherzuweisungen und Fehler vermieden werden;
- Zeile 58: ein Delegate-Typ, dessen Parameter als Referenz übergeben wird ([ref], siehe Kapitel 3). Die Typen [Func] und [Action] erlauben keine Parameter vom Typ [ref] oder [out]: Man muss einen eigenen Delegate-Typ definieren;
- Zeile 34: Bis C# 13 musste ein Lambda, dessen Parameter [ref], [out] oder [in] war, alle seine Parameter explizit typisieren, etwa [(ref int x) => x++]. Ab C# 14 genügt der Modifizierer allein, da der Typ aus dem Ziel-Delegate abgeleitet wird. Die Zeilen 36–37 erhöhen die Variable [counter] zweimal;
- Zeile 39: dasselbe mit einem [out]-Parameter. Das Lambda reicht seinen [out] -Parameter an [int.TryParse] weiter;
- Zeilen 44–52: eine Hilfsfunktion, die den Namen eines generischen Delegate-Typs in lesbarem Format anzeigt ([Func<Int32, Int32>] statt [Func`2]). Sie verwendet selbst ein Lambda, in Zeile 52.
7.3.3. Variablenerfassung und Closures
Ein Lambda kann die lokalen Variablen der Methode verwenden, in der es geschrieben ist. Man sagt, es erfasse diese Variablen. Dieser sehr leistungsfähige Mechanismus birgt einige Überraschungen. Das Programm [delegates-05.cs] macht sie deutlich:
Ergebnisse:
Kommentare:
- Zeile 5: Das Lambda verwendet die lokale Variable
[threshold], die in Zeile 4 deklariert wurde.[threshold]ist kein Parameter des Lambdas: Es ist eine erfasste Variable; - Zeile 8: [threshold] wird nach der Erstellung des Lambdas verändert. Die Ergebnisse (Zeilen 2–3) zeigen, dass das Lambda den neuen Wert sieht: [exceeds(7)] liefert [True] und dann [False]. Das Lambda hat den Wert von [threshold] nicht zum Zeitpunkt seiner Erstellung kopiert; es teilt sich die Variable selbst mit der umgebenden Methode;
- Zeile 13: Ein Lambda kann eine erfasste Variable auch verändern. Nach den beiden Aufrufen in den Zeilen 14–15 ist die Variable [total] gleich 7;
- Zeilen 60–64: Die Funktion [CreateCounter] gibt ein Lambda zurück, das ihre lokale Variable [value] erfasst. Normalerweise verschwindet eine lokale Variable, wenn die Methode endet. Hier überlebt die Variable [value] die Methode [CreateCounter] , weil das zurückgegebene Lambda sie weiterhin verwendet. Die Kombination aus dem Lambda und den von ihm erfassten Variablen wird Closure genannt. Um dies umzusetzen, wandelt der Compiler die erfassten Variablen in Felder eines von ihm generierten Objekts und das Lambda in eine Methode dieses Objekts um;
- Zeilen 19–20: Jeder Aufruf von [CreateCounter] erstellt eine neue Variable [value] – und damit einen neuen Zähler –, die von den anderen unabhängig ist. Die Ergebnisse (Zeilen 5–6) bestätigen dies;
- Zeilen 26–29: die klassische Falle. Wir erstellen drei Lambdas in einer [for]-Schleife und erwarten, dass sie 0, 1 und 2 ausgeben. Alle geben 3 aus (Zeile 7 der Ergebnisse). Tatsächlich hat die Schleife [for] nur eine Variable, [i], die von allen drei Lambdas geteilt wird. Wenn diese Lambdas ausgeführt werden, ist die Schleife bereits beendet, und [i] ist gleich 3;
- Zeilen 42–43: die Korrektur. Die Variable [copy] wird im Schleifenrumpf deklariert: Bei jedem Durchlauf wird eine neue Variable erstellt, und jedes Lambda erfasst seine eigene;
- Zeilen 51–53: Mit [foreach] tritt das Problem nicht auf. Bis C# 4 war die Variable einer Schleife namens [foreach] eindeutig, genau wie die einer Schleife namens [for], und dieser Code gab 2 2 2 aus. C# 5 hat diese Regel geändert (es ist eine der wenigen abwärtsinkompatiblen Änderungen in der Geschichte der Sprache): Die Variable [j] wird nun bei jedem Durchlauf neu initialisiert. Die Schleife [for] wurde nicht geändert;
- Zeile 46: Die Methode [ForEach] von [List<T>] erwartet eine [Action<T>] und führt sie für jedes Element aus. Hier ist jedes Element selbst ein [Action]-Delegate, das das Lambda ausführt.
Die Falle der [for]-Schleife tritt vor allem bei verzögerter Verarbeitung auf: Ein Lambda, das als Ereignishandler registriert oder in einem anderen Thread gestartet wird (Kapitel 8), wird ausgeführt, nachdem die Schleife, die es erstellt hat, bereits beendet ist.
7.4. Delegates oder Schnittstellen?
Die Konzepte Delegate und Schnittstelle können recht ähnlich erscheinen, und man fragt sich, worin genau die Unterschiede zwischen beiden bestehen. Nehmen wir das Beispiel [delegates-06.cs], das [delegates-02.cs] ähnelt:
Ergebnisse:
In Zeile 15 erwartet die Methode [Execute] eine Referenz auf ein Objekt des Delegate-Typs [Operation] , der in Zeile 34 definiert ist. Dadurch können der Methode [Execute] verschiedene Methoden übergeben werden (Zeilen 4, 6, 10 und 12). Die letzte Zeile übergibt ihr sogar ein Lambda: Es war nicht nötig, eine Multiplikationsmethode zu schreiben. Dieser Polymorphismus lässt sich auch mit einer Schnittstelle erreichen, wie [delegates-07.cs] zeigt:
Ergebnisse:
Kommentare:
- Zeilen 15–17: Die Schnittstelle [IOperation] definiert eine Methode [Operation];
- Zeilen 21–26 und 31–36: Die Klassen [Add] und [Subtract] implementieren die Schnittstelle [IOperation];
- Zeilen 9–11: die Methode [Execute], deren erster Parameter den von der Schnittstelle [IOperation] definierten Typ hat. Sie erhält nacheinander eine Instanz der Klasse [Add] als ersten Parameter, gefolgt von einer Instanz der Klasse [Subtract].
Dies zeigt deutlich den polymorphen Charakter des Parameters vom Delegate-Typ aus dem vorherigen Beispiel. Zugleich machen beide Beispiele die Unterschiede zwischen diesen beiden Konzepten deutlich. Delegate- und Schnittstellentypen sind austauschbar:
- wenn die Schnittstelle nur eine Methode enthält. Tatsächlich ist der Delegattyp eine Hülle für genau eine Methode, während eine Schnittstelle mehrere Methoden definieren kann;
- wenn die Multicast-Eigenschaft des Delegaten nicht genutzt wird. Dieses Multicast-Konzept gibt es bei einer Schnittstelle nicht.
Sind diese beiden Bedingungen erfüllt, können Sie für die Methode [Execute] zwischen den folgenden beiden Signaturen wählen:
Die zweite Variante, die den Delegaten verwendet, ist flexibler in der Anwendung. Bei der ersten Signatur muss der erste Parameter die Schnittstelle [IOperation] implementieren: Dazu muss eine Klasse erstellt werden, die die an [Execute] zu übergebende Methode definiert. Bei der zweiten Variante genügt jede vorhandene Methode mit der richtigen Signatur, und ein Lambda-Ausdruck erlaubt es sogar, diese Methode direkt an der Aufrufstelle zu definieren. Zusätzlicher Code ist nicht erforderlich. Diese Flexibilität erklärt, warum moderne Bibliotheken (LINQ, asynchrone Programmierung, ASP.NET Core) ausgiebig Delegaten verwenden.
Die Schnittstelle gewinnt ihren Vorteil zurück, sobald das zu übergebende Verhalten mehrere zusammengehörige Methoden umfasst oder einen eigenen Zustand und eine eigene Identität benötigt. So verhält es sich bei der Schnittstelle [ITaxDao] der Schicht [dao] aus Kapitel 6: Obwohl sie nur ein Mitglied hat, besitzen ihre Implementierungen einen Zustand (die gelesenen Steuerklassen, den Dateinamen), werden vom Dependency-Injection-Container erzeugt und stellen eine klar benannte Rolle innerhalb der Anwendung dar. Ein Delegat [Func<TaxBracket[]>] hätte technisch genügt, wäre aber deutlich weniger aussagekräftig gewesen.
7.5. Ereignisbehandlung
7.5.1. Das Ereignismodell von .NET
Delegaten dienen zur Definition von Ereignissen. Eine Klasse [C1] kann ein Ereignis [Evt1] wie folgt definieren:
- Ein Delegattyp wird innerhalb oder außerhalb der Klasse [C1] definiert:
- Die Klasse [C1] definiert ein Feld dieses Delegattyps:
- Wenn eine Instanz [c1] der Klasse [C1] ein Ereignis signalisieren möchte, führt sie ihren Delegaten [Evt1] aus und übergibt ihm die Parameter, die der Typ [Evt] vorgibt. Alle im Delegaten [Evt1] registrierten Methoden werden dann mit diesen Parametern ausgeführt. Man sagt, sie seien über das Ereignis [Evt1] benachrichtigt worden;
- wenn ein Objekt [c2], das das Objekt [c1] verwendet, über das Ereignis [Evt1] des Objekts [c1] benachrichtigt werden möchte, registriert es eine seiner Methoden, [c2.M], beim Delegaten [c1.Evt1]. Seine Methode [c2.M] wird dann jedes Mal ausgeführt, wenn das Ereignis [Evt1] beim Objekt [c1] eintritt. Es kann sich auch wieder abmelden, wenn es nicht mehr benachrichtigt werden möchte;
- da der Delegat [c1.Evt1] mehrere Methoden registrieren kann, können sich verschiedene Objekte [ci] bei [c1.Evt1] anmelden, um über das Ereignis benachrichtigt zu werden.
In diesem Szenario haben wir:
- eine Klasse, die ein Ereignis signalisiert (man sagt auch „veröffentlicht“ oder „auslöst“);
- Klassen, die über dieses Ereignis benachrichtigt werden. Man sagt, sie abonnieren das Ereignis;
- einen Delegattyp, der die Signatur der Methoden definiert, die über das Ereignis benachrichtigt werden. Diese Methoden heißen Ereignishandler.
Dies ist das Entwurfsmuster Observer: Der Sender kennt seine Abonnenten nicht, er benachrichtigt sie lediglich.
Das .NET-Framework definiert eine Standardsignatur für einen Ereignisdelegaten:
- [sender]: das Objekt, das das Ereignis ausgelöst hat;
- [e]: ein Objekt vom Typ [EventArgs] oder von einem abgeleiteten Typ, das Informationen über das Ereignis liefert;
- Per Konvention endet der Name des Delegattyps auf [EventHandler].
Außerdem definiert es eine Standardschreibweise, um in einer Klasse ein Ereignis vom Typ [MyEventHandler] zu deklarieren:
Das Feld [Evt1] hat den Delegattyp. Das Schlüsselwort [event] schränkt die Operationen ein, die darauf ausgeführt werden können:
- Von außerhalb der Klasse [C1] sind nur die Operationen [+=] und [-=] erlaubt. Dadurch wird verhindert, dass die abonnierten Methoden von anderen Objekten überschrieben oder gelöscht werden (etwa versehentlich durch die Schreibweise [=] statt [+=]). Man kann nur abonnieren ([+=]) oder abbestellen ([-=]);
- nur die Klasse [C1] kann den Delegaten ausführen, das heißt das Ereignis auslösen: [Evt1?.Invoke(this, e)].
Wenn Sie versuchen, außerhalb der Klasse [c1.Evt1 = null;] oder [c1.Evt1(null, EventArgs.Empty);] zu schreiben, antwortet der Compiler mit: [error CS0070: The event 'C1.Evt1' can only appear on the left hand side of += or -= (except when used from within the type 'C1')].
Statt für jedes Ereignis einen eigenen Delegattyp zu definieren, verwendet man den vordefinierten generischen Delegaten:
Der Typ [TEventArgs] ist der des zweiten Parameters, des Objekts, das das Ereignis beschreibt. Mit diesem generischen Delegaten folgt die Deklaration eines Ereignisses [X] in einer Klasse [C] dem folgenden empfohlenen Muster:
- einen von [XEventArgs] abgeleiteten Typ [EventArgs] definieren, der die Informationen zum Ereignis [X] kapselt;
- in der Klasse [EventHandler<XEventArgs>] ein Ereignis vom Typ [C] definieren;
- in der Klasse [C] eine geschützte, virtuelle Methode [protected virtual void OnX(XEventArgs e)] definieren, die das Ereignis [X] an die Abonnenten veröffentlicht. Sie ist virtuell, damit eine abgeleitete Klasse die Art der Veröffentlichung ändern kann.
Im Jahr 2008 musste der Typ [TEventArgs] von [EventArgs] abgeleitet sein (Einschränkung [where TEventArgs : EventArgs]). Diese Einschränkung wurde in .NET Framework 4.5 entfernt: Jeder Typ ist zulässig, auch ein [record]. Per Konvention leitet man jedoch weiterhin von [EventArgs] ab. Beachten Sie, dass ein [record] nicht von [EventArgs] abgeleitet werden kann: Ein [record] kann nur von einem anderen [record] erben (Fehler: [CS8864: Records may only inherit from object or another record]). Wir verwenden daher eine gewöhnliche Klasse.
7.5.2. Ein Beispiel: Die Temperatur ist zu hoch
Betrachten wir das folgende Beispiel:
- Eine Klasse [Publisher] kapselt eine Temperatur. Überschreitet diese Temperatur einen bestimmten Schwellenwert, muss ein Ereignis ausgelöst werden. Wir nennen dieses Ereignis [TemperatureTooHigh]. Die Informationen zu diesem Ereignis werden in einem Typ [TemperatureTooHighEventArgs] gekapselt;
- eine Klasse namens [Subscriber] abonniert das vorherige Ereignis. Wird sie über das Ereignis benachrichtigt, zeigt sie eine Meldung auf der Konsole an. Anders als in der Version von 2008 meldet sich ein Abonnent automatisch ab, nachdem er eine festgelegte Anzahl von Warnungen erhalten hat;
- Ein Konsolenprogramm erzeugt einen Sender und zwei Abonnenten. Es liest Temperaturen über die Tastatur ein und speichert sie im Sender. Ist eine davon zu hoch, veröffentlicht der Sender das Ereignis [TemperatureTooHigh].
Der Kurs von 2008 verteilte diese Klassen auf vier Dateien eines Projekts. Wir haben sie in der Einzeldatei-Anwendung [delegates-08.cs] zusammengefasst, die wir in drei Teilen vorstellen. Zunächst die Klasse für die Ereignisinformationen und die Klasse [Publisher]:
Anmerkungen:
- Zeilen 38–43: Die Klasse [TemperatureTooHighEventArgs] leitet per Konvention von [EventArgs] ab. Sie verwendet einen primären Konstruktor (C# 12, siehe Kapitel 4): Der Parameter [temperature] initialisiert die schreibgeschützte Eigenschaft [Temperature], die die Temperatur darstellt, die das Ereignis ausgelöst hat. Wir haben den Zeitpunkt des Ereignisses hinzugefügt, [Time]. Die Ereignisinformationen sind schreibgeschützt: Ein Abonnent darf sie für nachfolgende Abonnenten nicht verändern können;
- Zeile 50: der Temperaturschwellenwert, ab dem das Ereignis [TemperatureTooHigh] veröffentlicht wird;
- Zeile 52: Der Sender hat zu Identifikationszwecken einen Namen;
- Zeile 54: das Ereignis [TemperatureTooHigh] vom Typ [EventHandler<TemperatureTooHighEventArgs>]. Der Typ ist nullable ([?]): Solange sich niemand angemeldet hat, ist der Delegat auf [null] gesetzt;
- Zeilen 57–66: die Eigenschaft [Temperature]. Ihr Accessor [set] löst das Ereignis aus, wenn die gespeicherte Temperatur den Schwellenwert überschreitet. Er verwendet das C#-14-Schlüsselwort [field] (siehe Kapitel 4), das auf das verborgene Feld einer automatischen Eigenschaft verweist: Es ist nicht mehr nötig, ein privates Feld [temperature] zu deklarieren, wie es 2008 erforderlich war;
- Zeile 66: Die Veröffentlichung übernimmt die Methode [OnTemperatureTooHigh], der ein Objekt [TemperatureTooHighEventArgs] mit der Temperatur übergeben wird, die den Schwellenwert überschritten hat;
- Zeilen 72–75: Das Ereignis wird mit dem Sender selbst ([this]) als erstem Parameter und dem von der Methode empfangenen Objekt als zweitem Parameter veröffentlicht. Der Operator [?.] ist unerlässlich: Gibt es keine Abonnenten, ist [TemperatureTooHigh] gleichbedeutend mit [null]. Der Code von 2008 verwendete [TemperatureTooHigh(this, evt)], was bei fehlenden Abonnenten eine [NullReferenceException] auslöste. Die Schreibweise [TemperatureTooHigh?.Invoke(this, e)] ist außerdem in einem Multithreading-Programm sicherer (Kapitel 8): Der Delegat wird nur einmal gelesen, dann geprüft und ausgeführt; eine gleichzeitige Abmeldung in einem anderen Thread kann nicht dazu führen, dass er zwischen Prüfung und Aufruf [null] wird.
Hier ist die Klasse [Subscriber]:
Anmerkungen:
- Zeile 80: Jeder Abonnent wird durch einen Namen ([Name]) identifiziert und erhält die maximale Anzahl an Warnungen, die er akzeptiert ([nbAlertsMax]);
- Zeilen 88–90: Abonnieren des Ereignisses eines Senders. Die Methode [EvtTemperatureTooHigh] des Abonnenten wird im Ereignis registriert: Dies ist eine Methodengruppenkonvertierung. 2008 übernahm das Hauptprogramm das Abonnieren; hier ist es Aufgabe des Abonnenten, der wissen muss, welche Methode er zum Abbestellen entfernen muss;
- Zeilen 94–96: Beim Abbestellen wird dieselbe Methode mit [-=] entfernt. Für den Delegaten sind die Methode [EvtTemperatureTooHigh] von [s0] und die von [s1] zwei verschiedene Methoden, da sie nicht dasselbe Ziel ([Target]) haben: [-=] entfernt nur die des betreffenden Abonnenten;
- Zeile 100: der Ereignishandler. Er hat die vom Delegaten [EventHandler<TemperatureTooHighEventArgs>] vorgegebene Signatur: ein [object?] und ein [TemperatureTooHighEventArgs]. Er ist privat: Nur der Abonnent kann ihn bei einem Sender registrieren;
- Zeile 102: Der Parameter [source] hat den Typ [object?]. Der Musterfilter prüft, dass es sich tatsächlich um einen [Publisher] handelt, und speichert ihn in der Variablen [publisher]. Der Code von 2008 verwendete eine Typumwandlung nach [((Publisher)source).Name];
- Zeile 106: Der Handler zeigt den Namen des Abonnenten, den Namen des Senders, der das Ereignis gemeldet hat, und die Temperatur an, die es ausgelöst hat;
- Zeilen 108–111: Nach [nbAlertsMax] Warnungen meldet sich der Abonnent beim Sender ab. Der Abonnent tut dies während der Veröffentlichung des Ereignisses aus seinem eigenen Handler heraus. Das ist unbedenklich: Wir haben gesehen, dass ein Delegat unveränderlich ist. [-=] erzeugt einen neuen Delegaten und speichert ihn im Ereignisfeld, aber die laufende Veröffentlichung durchläuft weiterhin die alte Liste.
Hier schließlich das Hauptprogramm:
Ergebnisse:
Anmerkungen:
- Zeile 4: Erzeugung des Senders;
- Zeilen 6–9: Erzeugung zweier Abonnenten, [s0] (bis zu 3 Warnungen) und [s1] (1 Warnung), die das Ereignis [TemperatureTooHigh] des Senders abonnieren. Der Sammlungsausdruck [new("s0", 3), new("s1", 1)] verwendet den untypisierten Operator [new] (C# 9), da sich der Typ aus dem Typ des Arrays ergibt;
- Zeile 12: ein dritter Abonnent, ein Lambda, das als Protokoll dient. Die Typen von [source] und [e] werden aus dem Ereignistyp abgeleitet. Ein Lambda lässt sich nicht ohne Weiteres abbestellen: Es müsste in einer Variablen gespeichert werden, um mit [-=] entfernt werden zu können, denn zwei gleich geschriebene Lambdas sind zwei verschiedene Delegaten. Lambdas sind daher Abonnements vorbehalten, die so lange bestehen wie der Sender;
- Zeilen 15–33: Schleife zur Eingabe von Temperaturen über die Tastatur. [Console.ReadLine()] liefert [null] zurück, wenn die Standardeingabe geschlossen ist; [?.Trim() ?? ""] behandelt diesen Fall als leere Eingabe;
- Zeile 28: Ist die eingegebene Temperatur gültig, wird sie an den Sender [e1] übergeben, der das Ereignis [TemperatureTooHigh] auslöst, wenn sie größer als 19 °C ist.
Die Ergebnisse zeigen:
- Zeile 2: 17 °C überschreiten den Schwellenwert nicht: kein Ereignis;
- Zeilen 3–7: 21 °C lösen das Ereignis aus. Die drei Abonnenten werden in der Reihenfolge ihrer Anmeldung benachrichtigt. [s1], der nur eine Warnung akzeptiert, meldet sich sofort ab, das hindert aber das Protokoll – das sich nach ihm angemeldet hat – nicht daran, benachrichtigt zu werden;
- Zeilen 10–12: [s1] wird nicht mehr benachrichtigt;
- Zeilen 13–16: [s0] erhält seine dritte Warnung und meldet sich seinerseits ab;
- Zeile 17: Nur das Protokoll bleibt übrig.
7.6. Delegaten und LINQ
In Kapitel 5 haben wir die Methoden von LINQ ([Where], [Select], [OrderBy] …) verwendet und ihnen Lambdas übergeben. Wir wissen jetzt, worum es sich bei diesen Parametern handelt: Die Methode [Where] ist in der Klasse [System.Linq.Enumerable] wie folgt deklariert:
Ihr Parameter [predicate] ist ein Delegat [Func<TSource, bool>]: Jede Methode und jedes Lambda, das ein Element entgegennimmt und einen booleschen Wert zurückgibt, ist zulässig. Um die Funktionsweise von LINQ vollständig zu verstehen, schreiben wir selbst eine Filtermethode. Dies ist das Programm [delegates-09.cs]:
Ergebnisse:
Anmerkungen:
- Zeilen 6–7: Das Lambda von [Where] wird zunächst in einer Variablen vom Typ [Func<int, bool>] gespeichert, um seinen Typ sichtbar zu machen. [Select]erhält seinerseits einen Delegaten [Func<int, int>] , der jedes Element umwandelt: Das ergibt die Quadrate der geraden Zahlen;
- Zeilen 37–44: unsere Methode [Filter]. Sie ist generisch: Sie filtert eine Folge von Elementen beliebigen Typs [T] mithilfe eines Prädikats vom Typ [Func<T, bool>]. Sie durchläuft die Folge und ruft für jedes Element das Prädikat auf (Zeile 41);
- Zeile 44: Die Anweisung [yield return] macht [Filter] zu einem Iterator: Die Methode erstellt keine Liste, sondern liefert die ausgewählten Elemente nacheinander, so wie das Programm sie beim Durchlaufen des Ergebnisses anfordert. Nach jedem Aufruf von [yield return] wird die Ausführung von [Filter] angehalten; sie wird an derselben Stelle fortgesetzt, wenn das nächste Element angefordert wird;
- Zeile 11: Aufruf von [Filter] mit einem Lambda. Der Typ [T] wird aus dem Array abgeleitet: [int]. In Zeile 12 wird ihr eine Methodengruppe übergeben;
- Zeilen 15–18: ein ausführliches Prädikat, das jedes geprüfte Element ausgibt. Das Ergebnis (Zeilen 5–6) zeigt, dass das Erstellen der Abfrage nichts ausführt: Die Meldung in Zeile 20 erscheint vor dem ersten Test. Erst während der [foreach]-Schleife wird [Filter] ausgeführt, und die Tests wechseln sich mit den Ausgaben der Schleife ab. Dies ist die verzögerte Ausführung, dieselbe wie bei LINQ-Abfragen;
- Zeilen 53–63: Ein Block mit Erweiterungsmembern (C# 14, eingeführt in Kapitel 4) fügt dem Typ [IEnumerable<T>] zwei Methoden hinzu: [Filter], die [Tools.Filter] wiederverwendet, und [Transform], das Äquivalent zu [Select]. [Transform] ist doppelt generisch: [T] ist der Typ der Elemente der Folge und [TResult] der Typ der Elemente, die die Transformation erzeugt;
- Zeile 29: Dank der Erweiterungsmethoden werden unsere Methoden genauso aufgerufen wie die Methoden der Folge und lassen sich genauso verketten wie die von LINQ: Wir behalten die Städte mit höchstens 5 Buchstaben und schreiben sie anschließend groß.
Die gesamte LINQ-Bibliothek beruht auf diesem Modell: Erweiterungsmethoden von [IEnumerable<T>] , die Delegaten annehmen und neue Folgen zurückgeben, die von Iteratoren bei Bedarf berechnet werden.
7.7. Ausdrucksbäume
Ein Lambda-Ausdruck kann in einen Delegaten umgewandelt werden, wie wir es in diesem ganzen Kapitel getan haben. Er kann auch in einen Ausdrucksbaum umgewandelt werden: Statt das Lambda in ausführbaren Code zu kompilieren, erzeugt der Compiler Anweisungen, die zur Laufzeit eine Datenstruktur aufbauen, die das Lambda beschreibt. Dazu verwendet man einfach den Typ [Expression<TDelegate>] aus dem Namensraum [System.Linq.Expressions] anstelle des Delegattyps. Das Programm [delegates-10.cs] vergleicht beide:
Ergebnisse:
Anmerkungen:
- Zeile 2: Der Namensraum [System.Linq.Expressions] gehört nicht zu den impliziten [using]-Direktiven;
- Zeilen 5–6: Dasselbe Lambda wird einem Delegaten [Func<int, bool>] und anschließend einem Ausdrucksbaum [Expression<Func<int, bool>>] zugewiesen;
- Zeile 9: Ein Delegat kann nur seinen Typ anzeigen; sein Code ist kompiliert und nicht lesbar;
- Zeile 11: Ein Ausdrucksbaum hingegen kann angezeigt werden. Das Ergebnis (Zeile 3) gibt das Lambda wieder: [AndAlso] ist der Name des Operators [&&];
- Zeile 12: Wir können den Baum abfragen: seine Parameter, den Typ seines Ergebnisses und seinen Rumpf ([Body]);
- Zeilen 21–39: eine rekursive Methode, die den Baum anzeigt. Jeder Knoten ist ein Objekt, das von der Klasse [Expression] abgeleitet ist: [BinaryExpression] für eine Operation mit zwei Operanden ([&&], [>], [==], [%]), [ParameterExpression] für einen Parameter, [ConstantExpression] für eine Konstante. Ein [switch] mit Musterfilterung nach Typ behandelt jeden Fall. Die Ergebnisse (Zeilen 6–14) zeigen die Struktur des Ausdrucks [n > 5 && n % 2 == 0];
- Zeile 17: Ein Ausdrucksbaum kann zur Laufzeit in einen Delegaten kompiliert und anschließend ausgeführt werden.
Wozu dient das? Ein Delegat kann nur innerhalb des Programms ausgeführt werden. Ein Ausdrucksbaum kann analysiert und in eine andere Sprache übersetzt werden. Genau das tut Entity Framework Core, mit dem wir uns in Kapitel 11 beschäftigen werden. Schreibt man eine LINQ-Abfrage auf eine Datenbanktabelle, zum Beispiel [context.Brackets.Where(t => t.Limit > 20000)], so ist die verwendete Methode [Where] nicht die von [IEnumerable<T>] , sondern die von [IQueryable<T>], deren Parameter ein [Expression<Func<T, bool>>] ist. EF Core durchläuft diesen Baum, genau wie unsere Methode [Display], und übersetzt ihn in eine SQL-Klausel [WHERE limits > 20000], die vom Datenbankserver ausgeführt wird. Dasselbe, gleich geschriebene Lambda wird also je nach Typ des Parameters, den es erhält, entweder zu .NET-Code oder zu SQL-Code.
7.8. Fazit
Die wichtigsten Punkte dieses Kapitels:
- Ein Delegat ist ein Objekt, das auf eine oder mehrere Methoden mit einer bestimmten Signatur verweist. Die vordefinierten Typen [Func<>], [Action<>] und [Predicate<T>] machen die Definition eigener Delegattypen in der Regel überflüssig;
- Lambda-Ausdrücke erlauben es, die Methode direkt an der Stelle zu schreiben, an der der Delegat erzeugt wird. Sie erfassen die Variablen ihrer Umgebung (Vorsicht bei [for]-Schleifen);
- Ein Delegat kann eine Schnittstelle mit nur einer Methode ersetzen und bietet dabei mehr Flexibilität;
- ein Ereignis ist ein durch das Schlüsselwort [event] geschützter Delegat: Man abonniert es mit [+=], bestellt es mit [-=] ab, und nur die Klasse, die es deklariert, löst es aus, und zwar mit [Evt?.Invoke(this, e)];
- LINQ beruht auf Methoden, die Delegaten annehmen, und EF Core beruht auf Ausdrucksbäumen.
Auf Delegaten kommen wir in den folgenden Kapiteln zurück: Ein Task ([Task.Run]) führt einen Delegaten in einem anderen Thread aus (Kapitel 8 und 9), und die ASP.NET-Core-Webdienste verknüpfen Lambdas mit HTTP-Adressen (Kapitel 13).