Czym są delegaty i zdarzenia?

Question

Accepted Answer

**Delegat** to bezpieczny typ — referencja do metody (jak wskaźnik do funkcji) — umożliwia traktowanie metod jako danych: przechowywanie ich, przekazywanie jako argumenty i wywoływanie. **Zdarzenia** to wzorzec zbudowany na delegatach dla modelu publikuj-subskrybuj (obserwator). Stanowią podstawę dla callbacków, LINQ i programowania sterowanego zdarzeniami w C#. ## Delegaty — metody jako wartości ```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 ``` Delegat przechowuje referencję do metody pasującej do jego sygnatury, umożliwiając przekazywanie metod i dynamiczne ich wywoływanie. ## Wbudowane typy delegatów (używaj tych, a nie niestandardowych) ```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 ``` W nowoczesnym C# zazwyczaj używasz wbudowanych typów **`Func<>`** (zwraca wartość), **`Action<>`** (zwraca void) i `Predicate<>` zamiast deklarować niestandardowe typy delegatów. Lambdy (`x => ...`) tworzą delegaty — podstawę LINQ. ## Zdarzenia — wzorzec publikuj-subskrybuj ```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 (-=) ``` **Zdarzenie** opakowuje delegat, aby zapewnić bezpieczny pub-sub: subskrybenci rejestrują handlery za pomocą `+=`, wydawca wywołuje zdarzenie (`Invoke`), a wszystkie handlery się uruchamiają. Zdarzenia ograniczają kod zewnętrzny do tylko subskrybowania/odsubskrybowania (nie podnoszenia lub czyszczenia) — hermetyzacja dla wzorca obserwatora. ## Dlaczego to ważne Delegaty i zdarzenia są ważnymi funkcjami C# umożliwiającymi traktowanie metod jako danych, callbacki i programowanie sterowane zdarzeniami — zrozumienie ich jest cenne zarówno do ich używania, jak i do zrozumienia, jak wiele funkcji C# i .NET działa. **Delegaty** (bezpieczne typ referencji do metod) są fundamentem: pozwalają metodom być przechowywane, przekazywane i wywoływane dynamicznie, co stanowi podstawę dla **LINQ** (lambdy przekazane do `Where`/`Select` są delegatami), callbacków i programowania w stylu funkcyjnym. Wiedza o używaniu wbudowanych typów delegatów **`Func<>`/`Action<>`/`Predicate<>`** (zamiast deklarowania niestandardowych) to praktyczna, codziennej znajomość, ponieważ pojawiają się wszędzie w framework'u i są sposobem, w jaki przekazujesz zachowanie do LINQ i wielu API. **Zdarzenia** budują się na delegatach, aby bezpiecznie implementować wzorzec publikuj-subskrybuj (obserwator) — to sposób, w jaki C# obsługuje scenariusze sterowane zdarzeniami (zdarzenia UI, powiadomienia, zdecentralizowana komunikacja), z `+=`/`-=` do subskrybowania/odsubskrybowania. Zrozumienie delegatów (szczególnie Func/Action i lamb, podstawy LINQ) i zdarzeń (wzorzec pub-sub dla zdecentralizowanego, sterowanego zdarzeniami kodu) jest ważne do efektywnej pracy z C#, ponieważ te funkcje stanowią podstawę LINQ, callbacków i obsługi zdarzeń, które pojawiają się stale. Opanowanie ich — szczególnie rozpoznawanie, że lambdy są delegatami i jak umożliwiają LINQ i wzorce funkcyjne — to wiedza często stosowana, która odzwierciedla zrozumienie możliwości funkcyjnych C# i modelu sterowanego zdarzeniami, oraz to częsty temat rozmowy kwalifikacyjnej.