Skip to content

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:

public delegate void EventHandler(object? sender, EventArgs e);

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:

static void Display(object? sender, EventArgs e) { ... }

Um ein Objekt vom Typ [EventHandler] zu erstellen, das diese Methode referenziert, können Sie schreiben:

EventHandler handler = new EventHandler(Display);

oder, einfacher:

EventHandler handler = Display;

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:

// die vordefinierten Delegate-Typen von .NET

// 1 - das Delegate EventHandler: void M(object? sender, EventArgs e)
EventHandler handler = new EventHandler(Display);
// Kurzform: Method-Group-Konvertierung
handler = Display;
// Ausführung des Delegates
handler("program", EventArgs.Empty);

// 2 - Func<T1, T2, TResult>: zwei int-Parameter, ein int-Ergebnis
Func<int, int, int> operation = Add;
Console.WriteLine($"operation(2, 3)={operation(2, 3)}");
// Func<TResult>: kein Parameter, ein Ergebnis
Func<string> greet = Greet;
Console.WriteLine($"greet()={greet()}");

// 3 - Action<T>: ein Parameter, kein Ergebnis
Action<string> write = Console.WriteLine;
write("Action<string> executed Console.WriteLine");

// 4 - Predicate<T>: ein Parameter, ein Ergebnis vom Typ bool
Predicate<int> isEven = IsEven;
List<int> numbers = [3, 8, 1, 6, 5, 4];
// FindAll und RemoveAll von List<T> erwarten ein Predicate<T>
Console.WriteLine($"even: {string.Join(" ", numbers.FindAll(isEven))}");
int nbRemoved = numbers.RemoveAll(IsEven);
Console.WriteLine($"{nbRemoved} even numbers removed, remaining: {string.Join(" ", numbers)}");

// 5 - Comparison<T>: zwei Parameter vom Typ T, ein int-Ergebnis
List<string> names = ["Paul", "Mélanie", "Jo", "Sébastien"];
names.Sort(CompareLengths);
Console.WriteLine($"sorted by length: {string.Join(" ", names)}");

// 6 - ein Delegate ist ein Objekt: sein Typ und die Methode, auf die es verweist
Console.WriteLine($"type: {operation.GetType()}");
Console.WriteLine($"method: {operation.Method.Name}, target: {operation.Target?.ToString() ?? "none (static method)"}");

// die von den Delegates referenzierten Methoden
static void Display(object? sender, EventArgs e)
{
    Console.WriteLine($"Display(sender={sender}, e={e.GetType().Name})");
}

static int Add(int n1, int n2) => n1 + n2;

static string Greet() => "Hello";

static bool IsEven(int n) => n % 2 == 0;

static int CompareLengths(string s1, string s2) => s1.Length.CompareTo(s2.Length);

Ergebnisse:

> dotnet run delegates-01.cs
Display(sender=program, e=EventArgs)
operation(2, 3)=5
greet()=Hello
Action<string> executed Console.WriteLine
even: 8 6 4
3 even numbers removed, remaining: 3 1 5
sorted by length: Jo Paul Mélanie Sébastien
type: System.Func`3[System.Int32,System.Int32,System.Int32]
method: <<Main>$>g__Add|0_1, target: none (static method)

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:

public delegate int Operation(int n1, int n2);

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]:

// einen eigenen Delegate-Typ definieren

// wir definieren ein Objekt vom Typ Operation, um Methoden darin zu registrieren
// wir registrieren die statische Methode Increase
Operation op = Calculations.Increase;
// wir führen das Delegate aus
int n = op(4, 7);
Console.WriteLine($"n={n}");

// Erzeugung eines Objekts c1 vom Typ Calculations
var c1 = new Calculations();
// wir registrieren die Methode Add von c1 im Delegate
op = c1.Add;
// Ausführung des Delegate-Objekts
n = op(2, 3);
Console.WriteLine($"n={n}");
// wir registrieren die Methode Subtract von c1 im Delegate
op = c1.Subtract;
n = op(2, 3);
Console.WriteLine($"n={n}");

// Registrierung zweier Methoden im Delegate (Multicast-Delegate)
op = c1.Add;
op += c1.Subtract;
// Ausführung des Delegate-Objekts: wir erhalten das Ergebnis der letzten Methode
n = op(10, 4);
Console.WriteLine($"n={n}");
// die Ergebnisse aller Methoden mit der Aufrufliste
foreach (Operation method in op.GetInvocationList().Cast<Operation>())
{
    Console.WriteLine($"{method.Method.Name} -> {method(10, 4)}");
}
// wir entfernen eine Methode aus dem Delegate: das Ergebnis kann null sein (Typ Operation?)
Operation? rest = op - c1.Subtract;
// wir führen das Delegate aus, wenn es nicht null ist
if (rest is not null)
{
    n = rest(1, 1);
    Console.WriteLine($"n={n}");
}
// wir entfernen die letzte Methode: das Delegate wird null
Operation? empty = rest - c1.Add;
Console.WriteLine($"empty is null: {empty is null}");
// ?.Invoke führt das Delegate nur aus, wenn es nicht null ist
Console.WriteLine($"empty?.Invoke(1, 1)={empty?.Invoke(1, 1)}");

// eine Klasse, deren Methoden die Signatur des Delegates Operation haben
public class Calculations
{
    // zwei Instanzmethoden
    public int Add(int n1, int n2)
    {
        Console.WriteLine($"Add({n1},{n2})");
        return n1 + n2;
    }

    public int Subtract(int n1, int n2)
    {
        Console.WriteLine($"Subtract({n1},{n2})");
        return n1 - n2;
    }

    // eine statische Methode
    public static int Increase(int n1, int n2)
    {
        Console.WriteLine($"Increase({n1},{n2})");
        return n1 + 2 * n2;
    }
}

// Definition eines Delegate-Typs: eine Methodenvorlage
// die zwei Ganzzahlen als Parameter akzeptiert und eine Ganzzahl zurückgibt
public delegate int Operation(int n1, int n2);

Ergebnisse:

> dotnet run delegates-02.cs
Increase(4,7)
n=18
Add(2,3)
n=5
Subtract(2,3)
n=-1
Add(10,4)
Subtract(10,4)
n=6
Add(10,4)
Add -> 14
Subtract(10,4)
Subtract -> 6
Add(1,1)
n=2
empty is null: True
empty?.Invoke(1, 1)=

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:

// von anonymen Methoden zu Lambda-Ausdrücken

// 1 - eine anonyme Methode (C# 2): der Methodenrumpf wird an Ort und Stelle geschrieben
Func<int, int, int> add = delegate (int n1, int n2)
{
    return n1 + n2;
};
Console.WriteLine($"anonymous method: add(2, 3)={add(2, 3)}");

// 2 - dasselbe mit einem Lambda-Ausdruck (C# 3): Parameter => Rumpf
Func<int, int, int> subtract = (int n1, int n2) =>
{
    return n1 - n2;
};
Console.WriteLine($"block-bodied lambda: subtract(2, 3)={subtract(2, 3)}");

// 3 - die Parametertypen werden aus dem Ziel-Delegate-Typ abgeleitet
Func<int, int, int> multiply = (n1, n2) => n1 * n2;
Console.WriteLine($"expression-bodied lambda: multiply(2, 3)={multiply(2, 3)}");

// 4 - ein einziger Parameter: die Klammern sind optional
Func<int, int> square = x => x * x;
Predicate<string> isEmpty = s => s.Length == 0;
Console.WriteLine($"square(7)={square(7)}, isEmpty(\"\")={isEmpty("")}");

// 5 - kein Parameter: leere Klammern
Func<string> greet = () => "Hello";
Action beep = () => Console.WriteLine("beep!");
Console.WriteLine(greet());
beep();

// 6 - ein Blockrumpf mit mehreren Anweisungen
Action<string, int> repeat = (text, times) =>
{
    for (int i = 0; i < times; i++)
    {
        Console.Write(text);
    }
    Console.WriteLine();
};
repeat("ab", 3);

// 7 - ignorierte Parameter (Discards): wir brauchen ihre Werte nicht
EventHandler handler = (_, _) => Console.WriteLine("event received");
handler(null, EventArgs.Empty);

// 8 - ein Lambda, das direkt als Parameter einer Methode übergeben wird
List<int> numbers = [3, 8, 1, 6, 5, 4];
Console.WriteLine($"even: {string.Join(" ", numbers.FindAll(n => n % 2 == 0))}");
numbers.Sort((n1, n2) => n2.CompareTo(n1));
Console.WriteLine($"descending order: {string.Join(" ", numbers)}");

Ergebnisse:

> dotnet run delegates-03.cs
anonymous method: add(2, 3)=5
block-bodied lambda: subtract(2, 3)=-1
expression-bodied lambda: multiply(2, 3)=6
square(7)=49, isEmpty("")=True
Hello
beep!
ababab
event received
even: 8 6 4
descending order: 8 6 5 4 3 1

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:

// mehr zu Lambda-Ausdrücken (C# 9 bis C# 14)

// 1 - natürlicher Typ eines Lambdas (C# 10): var ist möglich, wenn die Parameter typisiert sind
var twice = (int x) => x * 2;
Console.WriteLine($"twice(21)={twice(21)}, type: {Name(twice)}");
var display = (string s) => Console.WriteLine($"[{s}]");
display("Action<string>");
Console.WriteLine($"type of display: {Name(display)}");
// eine Method Group hat ebenfalls einen natürlichen Typ, wenn sie nur eine Überladung hat
var isEven = IsEven;
Console.WriteLine($"isEven(4)={isEven(4)}, type: {Name(isEven)}");

// 2 - expliziter Rückgabetyp (C# 10): nützlich, wenn er sich nicht ableiten lässt
var choose = object (bool b) => b ? 1 : "one";
Console.WriteLine($"choose(true)={choose(true)}, choose(false)={choose(false)}");

// 3 - Parameter mit Standardwert (C# 12)
var greet = (string name, string greeting = "Hello") => $"{greeting} {name}";
Console.WriteLine(greet("Pierre"));
Console.WriteLine(greet("Pierre", "Good evening"));
// ebenso wie params
var sum = (params int[] values) => values.Sum();
Console.WriteLine($"sum()={sum()}, sum(1, 2, 3)={sum(1, 2, 3)}");
// der Typ dieser Lambdas ist ein vom Compiler erzeugtes anonymes Delegate
Console.WriteLine($"type of greet: {Name(greet)}");

// 4 - statisches Lambda (C# 9): es kann keine lokale Variable und kein this verwenden
const int Coefficient = 3;
Func<int, int> triple = static x => x * Coefficient; // eine Konstante ist erlaubt
Console.WriteLine($"triple(5)={triple(5)}");

// 5 - Modifizierer ref / out / in ohne Typ (C# 14)
// der Delegate-Typ Incrementer legt die Typen fest: das Lambda muss sie nicht wiederholen
Incrementer increment = (ref x) => x++;
int counter = 10;
increment(ref counter);
increment(ref counter);
Console.WriteLine($"counter={counter}");
Parser parse = (text, out value) => int.TryParse(text, out value);
Console.WriteLine($"parse(\"12\"): {parse("12", out int v1)} {v1}");
Console.WriteLine($"parse(\"x\"): {parse("x", out int v2)} {v2}");

// lesbarer Name eines Delegate-Typs: Func<Int32, Int32> statt Func`2
static string Name(Delegate d)
{
    Type t = d.GetType();
    if (!t.IsGenericType)
    {
        return t.Name;
    }
    string name = t.Name[..t.Name.IndexOf('`')];
    return $"{name}<{string.Join(", ", t.GetGenericArguments().Select(a => a.Name))}>";
}

static bool IsEven(int n) => n % 2 == 0;

// Delegate-Typen mit ref- und out-Parametern
delegate void Incrementer(ref int x);
delegate bool Parser(string text, out int value);

Ergebnisse:

> dotnet run delegates-04.cs
twice(21)=42, type: Func<Int32, Int32>
[Action<string>]
type of display: Action<String>
isEven(4)=True, type: Func<Int32, Boolean>
choose(true)=1, choose(false)=one
Hello Pierre
Good evening Pierre
sum()=0, sum(1, 2, 3)=6
type of greet: <>f__AnonymousDelegate0<String, String, String>
triple(5)=15
counter=12
parse("12"): True 12
parse("x"): False 0

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:

// Variablenerfassung und Closures

// 1 - ein Lambda kann die es umgebenden lokalen Variablen verwenden
int threshold = 5;
Func<int, bool> exceeds = n => n > threshold;
Console.WriteLine($"threshold={threshold}: exceeds(7)={exceeds(7)}");
// die Variable wird erfasst, nicht ihr Wert: das Lambda sieht die Änderung
threshold = 10;
Console.WriteLine($"threshold={threshold}: exceeds(7)={exceeds(7)}");

// 2 - ein Lambda kann eine erfasste Variable auch ändern
int total = 0;
Action<int> accumulate = n => total += n;
accumulate(3);
accumulate(4);
Console.WriteLine($"total={total}");

// 3 - eine Closure: die erfasste Variable überlebt die Methode, die sie erzeugt hat
Func<int> counterA = CreateCounter();
Func<int> counterB = CreateCounter();
Console.WriteLine($"A: {counterA()} {counterA()} {counterA()}");
Console.WriteLine($"B: {counterB()} {counterB()}");

// 4 - die Erfassungsfalle in einer for-Schleife
List<Action> actions = [];
for (int i = 0; i < 3; i++)
{
    // die drei Lambdas erfassen dieselbe Variable i
    actions.Add(() => Console.Write($"{i} "));
}
Console.Write("for, capture of i: ");
foreach (Action action in actions)
{
    action();
}
Console.WriteLine();

// die Lösung: eine lokale Kopie, bei jedem Schleifendurchlauf neu
actions.Clear();
for (int i = 0; i < 3; i++)
{
    int copy = i;
    actions.Add(() => Console.Write($"{copy} "));
}
Console.Write("for, capture of a copy: ");
actions.ForEach(action => action());
Console.WriteLine();

// foreach (seit C# 5) erzeugt bei jeder Iteration eine neue Variable
actions.Clear();
foreach (int j in new[] { 0, 1, 2 })
{
    actions.Add(() => Console.Write($"{j} "));
}
Console.Write("foreach: ");
actions.ForEach(action => action());
Console.WriteLine();

// eine Methode, die eine Funktion zurückgibt
static Func<int> CreateCounter()
{
    // vom zurückgegebenen Lambda erfasste lokale Variable
    int value = 0;
    return () => ++value;
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run delegates-05.cs
threshold=5: exceeds(7)=True
threshold=10: exceeds(7)=False
total=7
A: 1 2 3
B: 1 2
for, capture of i: 3 3 3 
for, capture of a copy: 0 1 2 
foreach: 0 1 2 

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:

// ein Parameter vom Delegate-Typ

// Ausführung des Delegates Add
Console.WriteLine(Execute(Add, 2, 3));
// Ausführung des Delegates Subtract
Console.WriteLine(Execute(Subtract, 2, 3));
// Ausführung eines Multicast-Delegates
Operation op = Add;
op += Subtract;
Console.WriteLine(Execute(op, 2, 3));
// Ausführung eines Lambdas: keine benannte Methode erforderlich
Console.WriteLine(Execute((n1, n2) => n1 * n2, 2, 3));

// Ausführung eines Delegates
static int Execute(Operation op, int n1, int n2)
{
    return op(n1, n2);
}

// zwei Methoden mit der Signatur des Delegates Operation
static int Add(int n1, int n2)
{
    Console.WriteLine($"Add({n1},{n2})");
    return n1 + n2;
}

static int Subtract(int n1, int n2)
{
    Console.WriteLine($"Subtract({n1},{n2})");
    return n1 - n2;
}

// der Delegate-Typ
delegate int Operation(int n1, int n2);

Ergebnisse:

1
2
3
4
5
6
7
8
9
> dotnet run delegates-06.cs
Add(2,3)
5
Subtract(2,3)
-1
Add(2,3)
Subtract(2,3)
-1
6

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:

// ein Parameter vom Schnittstellentyp

// Ausführung der Operation Add
Console.WriteLine(Execute(new Add(), 2, 3));
// Ausführung der Operation Subtract
Console.WriteLine(Execute(new Subtract(), 2, 3));

// Ausführung der einzigen Methode der Schnittstelle IOperation
static int Execute(IOperation op, int n1, int n2)
{
    return op.Operation(n1, n2);
}

// Schnittstelle IOperation
public interface IOperation
{
    int Operation(int n1, int n2);
}

// Klasse Add
public class Add : IOperation
{
    public int Operation(int n1, int n2)
    {
        Console.WriteLine($"Add({n1},{n2})");
        return n1 + n2;
    }
}

// Klasse Subtract
public class Subtract : IOperation
{
    public int Operation(int n1, int n2)
    {
        Console.WriteLine($"Subtract({n1},{n2})");
        return n1 - n2;
    }
}

Ergebnisse:

1
2
3
4
5
> dotnet run delegates-07.cs
Add(2,3)
5
Subtract(2,3)
-1

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:

int Execute(IOperation op, int n1, int n2)
int Execute(Operation op, int n1, int n2)

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:
delegate void Evt(T1 param1, T2 param2, ...);
  • Die Klasse [C1] definiert ein Feld dieses Delegattyps:
public Evt? Evt1;
  • 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:

public delegate void MyEventHandler(object? sender, EventArgs e);
  • [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:

1
2
3
4
5
public class C1
{
    public event MyEventHandler? Evt1;
    ...
}

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:

public delegate void EventHandler<TEventArgs>(object? sender, TEventArgs e);

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]:

// die vom Ereignis getragene Information
public class TemperatureTooHighEventArgs(decimal temperature) : EventArgs
{
    // Temperatur zum Zeitpunkt des Ereignisses
    public decimal Temperature { get; } = temperature;
    // Zeitpunkt des Ereignisses
    public DateTime Time { get; } = DateTime.Now;
}

// die Klasse, die das Ereignis auslöst
public class Publisher(string name)
{
    // Schwellenwert, der das Ereignis auslöst
    public const decimal Threshold = 19;
    // Name des Herausgebers
    public string Name { get; } = name;
    // das ausgelöste Ereignis
    public event EventHandler<TemperatureTooHighEventArgs>? TemperatureTooHigh;

    // beobachtete Temperatur
    public decimal Temperature
    {
        get;
        set
        {
            field = value;
            if (value > Threshold)
            {
                // wir lösen das Ereignis bei den Abonnenten aus
                OnTemperatureTooHigh(new TemperatureTooHighEventArgs(value));
            }
        }
    }

    // Auslösen des Ereignisses
    protected virtual void OnTemperatureTooHigh(TemperatureTooHighEventArgs e)
    {
        // Senden des Ereignisses an die Abonnenten, falls es welche gibt
        TemperatureTooHigh?.Invoke(this, e);
    }
}

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]:

// eine Klasse, die das Ereignis abonniert
public class Subscriber(string name, int nbAlertsMax)
{
    // Name des Abonnenten
    public string Name { get; } = name;
    // Anzahl der empfangenen Alarme
    private int nbAlerts;

    // Abonnement des Ereignisses eines Herausgebers
    public void Subscribe(Publisher publisher)
    {
        publisher.TemperatureTooHigh += EvtTemperatureTooHigh;
    }

    // Abmeldung
    public void Unsubscribe(Publisher publisher)
    {
        publisher.TemperatureTooHigh -= EvtTemperatureTooHigh;
    }

    // Handler des Ereignisses TemperatureTooHigh
    private void EvtTemperatureTooHigh(object? source, TemperatureTooHighEventArgs e)
    {
        if (source is not Publisher publisher)
        {
            return;
        }
        Console.WriteLine($"Subscriber [{Name}]: the source [{publisher.Name}] reported a temperature too high: [{e.Temperature}]");
        // nach mehr als nbAlertsMax Alarmen meldet sich der Abonnent ab
        nbAlerts++;
        if (nbAlerts == nbAlertsMax)
        {
            Unsubscribe(publisher);
            Console.WriteLine($"Subscriber [{Name}]: unsubscribed after {nbAlerts} alert(s)");
        }
    }
}

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:

// Ereignisbehandlung: ein Herausgeber und Abonnenten

// Erzeugung eines Ereignisherausgebers
var e1 = new Publisher("e");
// Erzeugung zweier Abonnenten, die das Ereignis TemperatureTooHigh von e1 abonniert haben
Subscriber[] subscribers = [new("s0", 3), new("s1", 1)];
foreach (Subscriber subscriber in subscribers)
{
    subscriber.Subscribe(e1);
}
// ein dritter Abonnent: ein Lambda
e1.TemperatureTooHigh += (source, e) => Console.WriteLine($"Log: {e.Temperature} °C at {e.Time:HH:mm:ss}");

// wir lesen die Temperaturen von der Tastatur
while (true)
{
    Console.Write("Temperature (nothing to stop): ");
    string input = Console.ReadLine()?.Trim() ?? "";
    // Ende der Eingabe?
    if (input == "")
    {
        break;
    }
    // ist die Eingabe eine Dezimalzahl?
    if (decimal.TryParse(input, out decimal temperature))
    {
        // korrekte Temperatur - wir speichern sie im Herausgeber
        e1.Temperature = temperature;
    }
    else
    {
        // wir melden den Fehler
        Console.WriteLine("Incorrect temperature");
    }
}

Ergebnisse:

> dotnet run delegates-08.cs
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] reported a temperature too high: [21]
Subscriber [s1]: the source [e] reported a temperature too high: [21]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21 °C at 11:20:25
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22.5
Subscriber [s0]: the source [e] reported a temperature too high: [22.5]
Log: 22.5 °C at 11:20:27
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] reported a temperature too high: [25]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25 °C at 11:20:28
Temperature (nothing to stop): 30
Log: 30 °C at 11:20:28
Temperature (nothing to stop): 

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:

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)

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]:

// Delegates und LINQ

int[] numbers = [3, 8, 1, 6, 5, 4, 9, 2];

// 1 - Where und Select erwarten Delegates vom Typ Func<int, bool> und Func<int, TResult>
Func<int, bool> isEven = n => n % 2 == 0;
var evenSquares = numbers.Where(isEven).Select(n => n * n);
Console.WriteLine($"LINQ: {string.Join(" ", evenSquares)}");

// 2 - unsere eigene Filtermethode, aufgerufen mit einem Lambda, dann mit einer Method Group
Console.WriteLine($"Filter(n > 4): {string.Join(" ", Tools.Filter(numbers, n => n > 4))}");
Console.WriteLine($"Filter(IsOdd): {string.Join(" ", Tools.Filter(numbers, IsOdd))}");

// 3 - die Ausführung ist verzögert: das Prädikat wird erst bei der Iteration aufgerufen
IEnumerable<int> large = Tools.Filter(numbers, n =>
{
    Console.Write($"[test {n}] ");
    return n > 7;
});
Console.WriteLine("the query is defined, nothing has been executed yet");
foreach (int n in large)
{
    Console.Write($"-> {n} ");
}
Console.WriteLine();

// 4 - mit Erweiterungsmembern lassen sich unsere Methoden wie die von LINQ verketten
string[] cities = ["Angers", "Paris", "Lyon", "Nantes", "Aix"];
var result = cities.Filter(v => v.Length <= 5).Transform(v => v.ToUpper());
Console.WriteLine($"extension: {string.Join(" ", result)}");

static bool IsOdd(int n) => n % 2 != 0;

public static class Tools
{
    // filtert eine Sequenz mit einem Prädikat: das Äquivalent von Where
    public static IEnumerable<T> Filter<T>(IEnumerable<T> source, Func<T, bool> predicate)
    {
        foreach (T element in source)
        {
            if (predicate(element))
            {
                // das Element wird an den Aufrufer zurückgegeben; die Iteration wird hier fortgesetzt
                yield return element;
            }
        }
    }
}

public static class Extensions
{
    // Erweiterungsmember (C# 14) von IEnumerable<T>
    extension<T>(IEnumerable<T> source)
    {
        // Filter als Erweiterungsmethode: wir verwenden Tools.Filter wieder
        public IEnumerable<T> Filter(Func<T, bool> predicate) => Tools.Filter(source, predicate);

        // transformiert jedes Element: das Äquivalent von Select
        public IEnumerable<TResult> Transform<TResult>(Func<T, TResult> transformation)
        {
            foreach (T element in source)
            {
                yield return transformation(element);
            }
        }
    }
}

Ergebnisse:

1
2
3
4
5
6
7
> dotnet run delegates-09.cs
LINQ: 64 36 16 4
Filter(n > 4): 8 6 5 9
Filter(IsOdd): 3 1 5 9
the query is defined, nothing has been executed yet
[test 3] [test 8] -> 8 [test 1] [test 6] [test 5] [test 4] [test 9] -> 9 [test 2] 
extension: PARIS LYON AIX

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:

// Ausdrucksbäume
using System.Linq.Expressions;

// dasselbe Lambda, in ein Delegate kompiliert oder als Daten aufbewahrt
Func<int, bool> function = n => n > 5 && n % 2 == 0;
Expression<Func<int, bool>> expression = n => n > 5 && n % 2 == 0;

// ein Delegate wird ausgeführt, aber sein Code ist nicht lesbar
Console.WriteLine($"delegate: {function}");
// ein Ausdrucksbaum kann durchlaufen und angezeigt werden
Console.WriteLine($"expression: {expression}");
Console.WriteLine($"parameter: {expression.Parameters[0].Name}, returned type: {expression.ReturnType.Name}");
Console.WriteLine("tree:");
Display(expression.Body, 1);

// ein Ausdrucksbaum kann in ein Delegate kompiliert und dann ausgeführt werden
Func<int, bool> compiled = expression.Compile();
Console.WriteLine($"compiled(8)={compiled(8)}, compiled(7)={compiled(7)}");

// rekursive Anzeige eines Baumknotens und seiner Kinder
static void Display(Expression node, int level)
{
    string margin = new(' ', 2 * level);
    switch (node)
    {
        case BinaryExpression binary:
            // Operation mit zwei Operanden: &&, >, ==, %...
            Console.WriteLine($"{margin}{binary.NodeType}");
            Display(binary.Left, level + 1);
            Display(binary.Right, level + 1);
            break;
        case ParameterExpression parameter:
            Console.WriteLine($"{margin}Parameter {parameter.Name}");
            break;
        case ConstantExpression constant:
            Console.WriteLine($"{margin}Constant {constant.Value}");
            break;
        default:
            Console.WriteLine($"{margin}{node.NodeType} {node}");
            break;
    }
}

Ergebnisse:

> dotnet run delegates-10.cs
delegate: System.Func`2[System.Int32,System.Boolean]
expression: n => ((n > 5) AndAlso ((n % 2) == 0))
parameter: n, returned type: Boolean
tree:
  AndAlso
    GreaterThan
      Parameter n
      Constant 5
    Equal
      Modulo
        Parameter n
        Constant 2
      Constant 0
compiled(8)=True, compiled(7)=False

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).