Was sind Delegates und Events?

Question

Accepted Answer

Ein **Delegate** ist eine typsichere Referenz auf eine Methode (ähnlich einem Funktionszeiger) — es ermöglicht dir, Methoden als Daten zu behandeln: sie zu speichern, als Argumente zu übergeben und sie aufzurufen. **Events** sind ein auf Delegates aufgebautes Pattern für das Publish-Subscribe- (Observer-) Modell. Sie sind die Grundlage für Callbacks, LINQ und ereignisgesteuerte Programmierung in C#. ## Delegates — Methoden als Werte ```csharp // a delegate type defines a method signature public delegate int Operation(int a, int b); Operation add = (a, b) => a + b; // assign a method/lambda to it Operation multiply = (a, b) => a * b; int result = add(2, 3); // invoke → 5 // pass a delegate as an argument (higher-order function) int Apply(Operation op, int x, int y) => op(x, y); Apply(multiply, 4, 5); // 20 ``` Ein Delegate hält eine Referenz auf eine Methode, die seiner Signatur entspricht, und ermöglicht es, Methoden weiterzugeben und dynamisch aufzurufen. ## Vordefinierte Delegate-Typen (nutze diese, nicht benutzerdefinierte) ```csharp Func add = (a, b) => a + b; // Func — takes args, RETURNS a value Action log = msg => Console.WriteLine(msg); // Action — returns VOID Predicate isPositive = n => n > 0; // Predicate — returns bool // used heavily in LINQ and APIs: list.Where(x => x > 0).Select(x => x * 2); // lambdas are delegates ``` In modernem C# verwendest du normalerweise die vordefinierten **`Func<>`** (gibt einen Wert zurück), **`Action<>`** (gibt void zurück) und `Predicate<>`, anstatt benutzerdefinierte Delegate-Typen zu deklarieren. Lambdas (`x => ...`) erzeugen Delegates — die Basis von LINQ. ## Events — das Publish-Subscribe-Pattern ```csharp public class Button { public event EventHandler Clicked; // an EVENT (based on a delegate) public void Click() => Clicked?.Invoke(this, EventArgs.Empty); // raise it } var button = new Button(); button.Clicked += (sender, e) => Console.WriteLine("clicked!"); // SUBSCRIBE (+=) button.Clicked -= handler; // unsubscribe (-=) ``` Ein **Event** umhüllt einen Delegate, um sicheres Pub-Sub zu ermöglichen: Abonnenten registrieren Handler mit `+=`, der Publisher löst das Event aus (`Invoke`), und alle Handler werden ausgeführt. Events beschränken externen Code darauf, nur zu abonnieren/abzubestellen (nicht auszulösen oder zu löschen) — Kapselung für das Observer-Pattern. ## Warum es wichtig ist Delegates und Events sind wichtige C#-Features, die es ermöglichen, Methoden als Daten zu behandeln, Callbacks zu nutzen und ereignisgesteuerte Programmierung umzusetzen — und ihr Verständnis ist wertvoll sowohl für ihre praktische Anwendung als auch zum Verstehen, wie viel von C# und .NET funktioniert. **Delegates** (typsichere Methodenreferenzen) sind die Grundlage: Sie ermöglichen es, Methoden zu speichern, zu übergeben und dynamisch aufzurufen, was **LINQ** (Lambdas, die an `Where`/`Select` übergeben werden, sind Delegates), Callbacks und funktionale Programmierung ermöglicht. Zu wissen, die vordefinierten **`Func<>`/`Action<>`/`Predicate<>`**-Delegate-Typen zu nutzen (anstatt benutzerdefinierte zu deklarieren), ist praktisches, alltägliches Wissen, da sie überall im Framework vorkommen und die Art sind, wie du Verhalten an LINQ und viele APIs weitergibst. **Events** bauen auf Delegates auf, um das Publish-Subscribe- (Observer-) Pattern sicher umzusetzen — sie sind die Art, wie C# ereignisgesteuerte Szenarien bewältigt (UI-Events, Benachrichtigungen, entkoppelte Kommunikation), mit `+=`/`-=` zum Abonnieren/Abbestellen. Delegates zu verstehen (besonders Func/Action und Lambdas, die Grundlage von LINQ), und Events (das Pub-Sub-Pattern für entkoppelten, ereignisgesteuerten Code) ist wichtig für effektives Arbeiten mit C#, da diese Features LINQ, Callbacks und Event-Handling unterstützen, die ständig vorkommen. Sie zu beherrschen — besonders zu erkennen, dass Lambdas Delegates sind und wie sie LINQ und funktionale Patterns ermöglichen — ist häufig angewendetes Wissen, das Verständnis von C#s funktionalen Fähigkeiten und ereignisgesteuerten Modellen widerspiegelt, und ist ein häufiges Interview-Thema.