O que são delegates e events?

Question

Accepted Answer

Um **delegate** é uma referência type-safe a um método (como um ponteiro de função) — permite tratar métodos como dados: armazená-los, passá-los como argumentos e invocá-los. **Events** são um padrão construído sobre delegates para o modelo publish-subscribe (observer). Eles sustentam callbacks, LINQ e programação orientada a eventos em C#. ## Delegates — métodos como valores ```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 ``` Um delegate mantém uma referência a um método que corresponda sua assinatura, permitindo que métodos sejam passados e invocados dinamicamente. ## Tipos de delegate built-in (use estes, não custom) ```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 ``` Em C# moderno, você geralmente usa os **`Func<>`** built-in (retorna um valor), **`Action<>`** (retorna void) e `Predicate<>` em vez de declarar tipos de delegate customizados. Lambdas (`x => ...`) criam delegates — a base do LINQ. ## Events — o padrão 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 (-=) ``` Um **event** envolve um delegate para oferecer pub-sub seguro: subscribers registram handlers com `+=`, o publisher dispara o event (`Invoke`), e todos os handlers são executados. Events restringem código externo a apenas se inscrever/desinscrever (não disparar ou limpar) — encapsulamento para o padrão observer. ## Por que isso importa Delegates e events são recursos importantes em C# que permitem tratar métodos como dados, callbacks e programação orientada a eventos — e compreendê-los é valioso tanto para usá-los quanto para entender como grande parte de C# e .NET funciona. **Delegates** (referências de método type-safe) são a base: permitem que métodos sejam armazenados, passados e invocados dinamicamente, o que sustenta **LINQ** (lambdas passadas para `Where`/`Select` são delegates), callbacks e programação de estilo funcional. Saber usar os tipos de delegate **`Func<>`/`Action<>`/`Predicate<>`** built-in (em vez de declarar custom) é conhecimento prático e do dia a dia, pois aparecem em todo o framework e são como você passa comportamento para LINQ e muitas APIs. **Events** constroem sobre delegates para implementar o padrão publish-subscribe (observer) com segurança — é como C# trata cenários orientados a eventos (UI events, notificações, comunicação desacoplada), com `+=`/`-=` para se inscrever/desinscrever. Compreender delegates (especialmente Func/Action e lambdas, a base do LINQ) e events (o padrão pub-sub para código desacoplado e orientado a eventos) é importante para trabalhar efetivamente com C#, pois estes recursos sustentam LINQ, callbacks e event handling que aparecem constantemente. Dominar esses conceitos — particularmente reconhecer que lambdas são delegates e como eles permitem LINQ e padrões funcionais — é conhecimento frequentemente aplicado que reflete entendimento das capacidades funcionais e do modelo orientado a eventos de C#, e é um tópico comum em entrevistas.