Hva er delegater og events?

Question

Accepted Answer

En **delegat** er en type-sikker referanse til en metode (som en funksjonshenvisning) — den lar deg behandle metoder som data: lagre dem, send dem som argumenter, og kall dem. **Events** er et mønster bygget på delegater for publish-subscribe-modellen (observer-mønsteret). De er grunnlaget for callbacks, LINQ og event-drevet programmering i C#. ## Delegater — metoder som verdier ```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 delegat holder en referanse til en metode som samsvarer med signaturen, noe som gjør det mulig å sende metoder rundt og kalle dem dynamisk. ## Innebygde delegattyper (bruk disse, ikke egendefinerte) ```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# bruker du vanligvis de innebygde **`Func<>`** (returnerer en verdi), **`Action<>`** (returnerer void), og `Predicate<>` i stedet for å deklarere egendefinerte delegattyper. Lambdaer (`x => ...`) oppretter delegater — grunnlaget for LINQ. ## Events — publish-subscribe-mønsteret ```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 delegat for å gi sikker pub-sub: abonnenter registrerer håndterere med `+=`, utgiver hever eventen (`Invoke`), og alle håndterere kjøres. Events begrenser ekstern kode til kun å abonnere/avslutte abonnement (ikke å heve eller tømme) — innkapsling for observer-mønsteret. ## Hvorfor det er viktig Delegater og events er viktige C#-funksjoner som muliggjør behandling av metoder som data, callbacks og event-drevet programmering — og forståelsen av dem er verdifull både for å bruke dem og for å forstå hvordan mye av C# og .NET fungerer. **Delegater** (type-sikre metodreferanser) er grunnlaget: de lar metoder lagres, sendes og kalles dynamisk, noe som danner grunnlaget for **LINQ** (lambdaer sendt til `Where`/`Select` er delegater), callbacks og funksjonell programmering. Det er viktig å vite at du bør bruke de innebygde **`Func<>`/`Action<>`/`Predicate<>`** delegattypene (i stedet for å deklarere egendefinerte) — det er praktisk, daglig kunnskap siden de vises gjennomgående i rammeverket og er hvordan du sender oppførsel til LINQ og mange APIer. **Events** bygger på delegater for å implementere publish-subscribe-mønsteret (observer-mønsteret) sikkert — det er hvordan C# håndterer event-drevne scenarier (UI-hendelser, varsler, uavhengig kommunikasjon), med `+=`/`-=` for å abonnere/avslutte abonnement. Forståelse av delegater (spesielt Func/Action og lambdaer, grunnlaget for LINQ), og events (pub-sub-mønsteret for uavhengig, event-drevet kode) er viktig for å arbeide effektivt med C#, siden disse funksjonene danner grunnlaget for LINQ, callbacks og event-håndtering som vises konstant. Mestring av dem — spesielt å gjenkjenne at lambdaer er delegater og hvordan de muliggjør LINQ og funksjonelle mønstre — er hyppig brukt kunnskap som gjenspeiler forståelse av C#s funksjonelle evner og event-drevet modell, og er et vanlig emne i intervjuer.