Hvad er delegates og events?

Question

Accepted Answer

En **delegate** er en type-sikker reference til en metode (som en funktionspointer) — den lader dig behandle metoder som data: lagre dem, sende dem som argumenter og påkalde dem. **Events** er et mønster bygget på delegates til publish-subscribe (observer) modellen. De er grundlaget for callbacks, LINQ og event-driven programmering i C#. ## Delegates — metoder som værdier ```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 holder en reference til en metode, der matcher dens signatur, hvilket gør det muligt at sende metoder rundt og påkalde dem dynamisk. ## Indbyggede delegate-typer (brug disse, ikke brugerdefinerede) ```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 moderne C# bruger du normalt de indbyggede **`Func<>`** (returnerer en værdi), **`Action<>`** (returnerer void) og `Predicate<>` i stedet for at deklarere brugerdefinerede delegate-typer. Lambdaer (`x => ...`) opretter delegates — grundlaget for LINQ. ## Events — publish-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** omslutter en delegate for at give sikker pub-sub: subscribers registrerer handlers med `+=`, publisheren hæver eventen (`Invoke`), og alle handlers køres. Events begrænser ekstern kode til kun at kunne abonnere/framelde sig (ikke at hæve eller rydde) — indkapsling for observer-mønstret. ## Hvorfor det betyder noget Delegates og events er vigtige C#-funktioner, der gør det muligt at behandle metoder som data, callbacks og event-driven programmering — og at forstå dem er værdifuldt både for at bruge dem og for at forstå, hvordan meget af C# og .NET fungerer. **Delegates** (type-sikre metodereference) er grundlaget: de lader metoder blive gemt, sendt og påkaldt dynamisk, hvilket er grundlaget for **LINQ** (lambdaer sendt til `Where`/`Select` er delegates), callbacks og funktionel-stil programmering. At vide, at man skal bruge de indbyggede **`Func<>`/`Action<>`/`Predicate<>`** delegate-typer (i stedet for at deklarere brugerdefinerede) er praktisk, daglig viden, da de optræder overalt i frameworket og er hvordan du sender adfærd til LINQ og mange API'er. **Events** bygger på delegates for at implementere publish-subscribe (observer) mønstret sikkert — de er hvordan C# håndterer event-driven scenarier (UI-events, notifikationer, afkoblet kommunikation), med `+=`/`-=` til at abonnere/framelde sig. At forstå delegates (især Func/Action og lambdaer, grundlaget for LINQ) og events (pub-sub mønstret for afkoblet, event-driven kode) er vigtigt for at arbejde effektivt med C#, da disse funktioner er grundlaget for LINQ, callbacks og event-håndtering, der optræder konstant. At mestre dem — især at genkende, at lambdaer er delegates og hvordan de gør LINQ og funktionelle mønstre mulige — er hyppigt anvendt viden, der afspejler forståelse af C#'s funktionelle muligheder og event-driven model, og er et almindeligt interviewemne.