Wat zijn delegates en events?

Question

Accepted Answer

Een **delegate** is een type-safe verwijzing naar een methode (zoals een function pointer) — het stelt je in staat methoden als data te behandelen: ze op te slaan, als argumenten door te geven en aan te roepen. **Events** zijn een patroon gebouwd op delegates voor het publish-subscribe (observer) model. Ze liggen ten grondslag aan callbacks, LINQ en event-driven programmering in C#. ## Delegates — methoden als waarden ```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 ``` Een delegate houdt een verwijzing naar een methode die overeenkomt met zijn handtekening, waardoor methoden dynamisch kunnen worden doorgegeven en aangeroepen. ## Built-in delegate types (gebruik deze, niet aangepaste) ```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 modern C# gebruik je meestal de built-in **`Func<>`** (retourneert een waarde), **`Action<>`** (retourneert void) en `Predicate<>` in plaats van aangepaste delegate types te declareren. Lambdas (`x => ...`) creëren delegates — de basis van LINQ. ## Events — het publish-subscribe patroon ```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 (-=) ``` Een **event** verpakt een delegate om veilige pub-sub te bieden: abonnees registreren handlers met `+=`, de uitgever verheft het event (`Invoke`) op en alle handlers worden uitgevoerd. Events beperken externe code tot alleen abonneren/opzeggen (niet verheffen of wissen) — encapsulatie voor het observer patroon. ## Waarom het belangrijk is Delegates en events zijn belangrijke C# features die het mogelijk maken methoden als data te behandelen, callbacks en event-driven programmering — en het begrijpen ervan is waardevol zowel voor het gebruik ervan als voor het begrijpen hoe veel van C# en .NET werkt. **Delegates** (type-safe methode verwijzingen) zijn de basis: ze stellen methoden in staat om op te worden geslagen, doorgegeven en dynamisch aangeroepen, wat **LINQ** ondersteunt (lambdas doorgegeven aan `Where`/`Select` zijn delegates), callbacks en functioneel-stijl programmering. Weten dat je de built-in **`Func<>`/`Action<>`/`Predicate<>`** delegate types moet gebruiken (in plaats van aangepaste te declareren) is praktische, dagelijkse kennis omdat ze overal in het framework verschijnen en hoe je gedrag aan LINQ en veel APIs doorgeeft. **Events** bouwen op delegates voort om het publish-subscribe (observer) patroon veilig te implementeren — dit is hoe C# event-driven scenario's behandelt (UI events, meldingen, ontkoppelde communicatie), met `+=`/`-=` voor abonneren/opzeggen. Begrijpen van delegates (vooral Func/Action en lambdas, de basis van LINQ) en events (het pub-sub patroon voor ontkoppelde, event-driven code) is belangrijk voor effectief werken met C#, omdat deze features LINQ, callbacks en event handling ondersteunen die constant voorkomen. Eronder meester worden — in het bijzonder het erkennen dat lambdas delegates zijn en hoe zij LINQ en functionele patronen mogelijk maken — is frequently-applied kennis die begrip van C#'s functionele mogelijkheden en event-driven model weerspiegelt, en is een veel voorkomend interviewonderwerp.