Vad är delegates och events?

Question

Accepted Answer

En **delegate** är en typesäker referens till en metod (som en funktionspekare) — den låter dig behandla metoder som data: lagra dem, skicka dem som argument och anropa dem. **Events** är ett mönster byggt på delegates för pub-subscribe-modellen (observer-mönstret). De ligger till grund för callbacks, LINQ och händelsedriven programmering i C#. ## Delegates — metoder som värden ```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 ``` En delegate innehåller en referens till en metod som matchar dess signatur, vilket möjliggör att metoder kan skickas vidare och anropas dynamiskt. ## Inbyggda delegate-typer (använd dessa, inte anpassade) ```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 ``` I modern C# använder du normalt de inbyggda **`Func<>`** (returnerar ett värde), **`Action<>`** (returnerar void) och `Predicate<>` istället för att deklarera anpassade delegate-typer. Lambdas (`x => ...`) skapar delegates — grunden för LINQ. ## Events — pub-subscribe-mönstret ```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 (-=) ``` En **event** kapslar in en delegate för att tillhandahålla säker pub-subscribe: prenumeranter registrerar hanterare med `+=`, utgivaren utlöser eventen (`Invoke`), och alla hanterare körs. Events begränsar extern kod till endast prenumeration/avslutning av prenumeration (inte utlösning eller rensning) — inkapsling för observer-mönstret. ## Varför det är viktigt Delegates och events är viktiga C#-funktioner som möjliggör behandling av metoder som data, callbacks och händelsedriven programmering — och att förstå dem är värdefullt både för att använda dem och för att förstå hur mycket av C# och .NET fungerar. **Delegates** (typesäkra metodreferenser) är grunden: de låter metoder lagras, skickas och anropas dynamiskt, vilket ligger till grund för **LINQ** (lambdas skickade till `Where`/`Select` är delegates), callbacks och funktionell programmering. Att veta att man ska använda de inbyggda **`Func<>`/`Action<>`/`Predicate<>`** delegate-typerna (istället för att deklarera anpassade) är praktisk, daglig kunskap eftersom de förekommer överallt i ramverket och är hur du skickar beteende till LINQ och många API:er. **Events** bygger på delegates för att implementera pub-subscribe-mönstret (observer-mönstret) säkert — de är hur C# hanterar händelsedrivna scenarier (UI-händelser, notifieringar, frikopplad kommunikation), med `+=`/`-=` för prenumeration/avslutning av prenumeration. Att förstå delegates (särskilt Func/Action och lambdas, grunden för LINQ), och events (pub-subscribe-mönstret för frikopplad, händelsedriven kod) är viktigt för att arbeta effektivt med C#, eftersom dessa funktioner ligger till grund för LINQ, callbacks och händelsehantering som förekommer konstant. Att bemästra dem — särskilt att inse att lambdas är delegates och hur de möjliggör LINQ och funktionella mönster — är ofta tillämpad kunskap som återspeglar förståelse för C#:s funktionella möjligheter och händelsedrivna modell, och är ett vanligt intervjuämne.