Ce sunt delegații și evenimentele?

Question

Accepted Answer

Un **delegat** este o referință de tip sigur la o metodă (ca un pointer la funcție) — vă permite să tratați metodele ca date: să le stocați, să le transmitiți ca argumente și să le invocați. **Evenimentele** sunt un pattern construit pe delegați pentru modelul publish-subscribe (observer). Ele sunt la baza callback-urilor, LINQ și programării bazate pe evenimente în C#. ## Delegații — metodele ca valori ```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 ``` Un delegat deține o referință la o metodă care corespunde semnăturii sale, permițând metodelor să fie transmise și invocate dinamic. ## Tipuri de delegați încorporați (folosiți acestea, nu versiuni personalizate) ```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 ``` În C# modern, obișnuiți să folosiți tipurile de delegați **`Func<>`** (returnează o valoare), **`Action<>`** (returnează void) și `Predicate<>` în loc să declarați tipuri de delegați personalizate. Expresiile lambda (`x => ...`) creează delegați — baza LINQ. ## Evenimente — pattern-ul publish-subscribe ```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 (-=) ``` Un **eveniment** încapsulează un delegat pentru a oferi pub-sub sigur: abonații înregistrează handlere cu `+=`, publicatorul ridică evenimentul (`Invoke`), și toți handlerii se execută. Evenimentele restricționează codul extern la doar abonare/dezabonare (nu ridicare sau ștergere) — încapsulare pentru pattern-ul observer. ## De ce conteaza Delegații și evenimentele sunt caracteristici importante ale C# care permite tratarea metodelor ca date, callback-uri și programare bazată pe evenimente — și înțelegerea lor este valoroasă atât pentru utilizarea lor, cât și pentru a înțelege cum funcționează o mare parte din C# și .NET. **Delegații** (referințe de tip sigur la metodă) sunt fundamentul: permit metodelor să fie stocate, transmise și invocate dinamic, ceea ce susține **LINQ** (expresiile lambda transmise la `Where`/`Select` sunt delegați), callback-uri și programarea în stil funcțional. Cunoașterea utilizării tipurilor de delegați **`Func<>`/`Action<>`/`Predicate<>`** încorporați (mai degrabă decât declararea versiunilor personalizate) este o cunoaștere practică, zilnică, deoarece apar în întreaga bibliotecă și sunt modul în care transmiteți comportament la LINQ și la mulți API-uri. **Evenimentele** se bazează pe delegați pentru a implementa în siguranță pattern-ul publish-subscribe (observer) — sunt modul în care C# gestionează scenarii bazate pe evenimente (evenimente UI, notificări, comunicare decuplată), cu `+=`/`-=` pentru abonare/dezabonare. Înțelegerea delegaților (mai ales Func/Action și expresiilor lambda, baza LINQ) și evenimentelor (pattern-ul pub-sub pentru cod decuplat, bazat pe evenimente) este importantă pentru lucrul efectiv cu C#, deoarece aceste caracteristici susțin LINQ, callback-urile și gestionarea evenimentelor care apar constant. Stăpânirea lor — în special recunoașterea că expresiile lambda sunt delegați și cum permit LINQ și pattern-uri funcționale — este cunoaștere aplicată frecvent care reflectă înțelegerea capabilităților funcționale și a modelului bazat pe evenimente al C#, și este un subiect comun la interviuri.