¿Qué son los delegados y los eventos?

Question

Accepted Answer

Un **delegado** es una referencia type-safe a un método (como un puntero a función) — te permite tratar los métodos como datos: almacenarlos, pasarlos como argumentos e invocarlos. Los **eventos** son un patrón construido sobre delegados para el modelo publish-subscribe (observador). Son la base de callbacks, LINQ y la programación orientada a eventos en C#. ## Delegados — 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 ``` Un delegado contiene una referencia a un método que coincide con su firma, permitiendo que los métodos se pasen y se invoquen dinámicamente. ## Tipos de delegado integrados (usa estos, no personalizados) ```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 ``` En C# moderno, normalmente usas los **`Func<>`** integrados (devuelven un valor), **`Action<>`** (devuelven void), y `Predicate<>` en lugar de declarar tipos de delegado personalizados. Los lambdas (`x => ...`) crean delegados — la base de LINQ. ## Eventos — el patrón 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 **evento** envuelve un delegado para proporcionar pub-sub seguro: los suscriptores registran manejadores con `+=`, el publicador dispara el evento (`Invoke`), y todos los manejadores se ejecutan. Los eventos restringen el código externo solo para suscribirse/desuscribirse (no para disparar o limpiar) — encapsulación para el patrón observador. ## Por qué es importante Los delegados y eventos son características importantes de C# que permiten tratar los métodos como datos, callbacks y programación orientada a eventos — y comprenderlos es valioso tanto para usarlos como para entender cómo funcionan muchas partes de C# y .NET. Los **delegados** (referencias type-safe a métodos) son la base: permiten que los métodos se almacenen, pasen e invoquen dinámicamente, lo que sustenta **LINQ** (los lambdas pasados a `Where`/`Select` son delegados), callbacks y programación de estilo funcional. Saber usar los tipos de delegado **`Func<>`/`Action<>`/`Predicate<>`** integrados (en lugar de declarar personalizados) es conocimiento práctico y cotidiano ya que aparecen en todo el framework y es cómo pasas comportamiento a LINQ y muchas APIs. Los **eventos** se construyen sobre delegados para implementar el patrón publish-subscribe (observador) de forma segura — es cómo C# maneja escenarios orientados a eventos (eventos de UI, notificaciones, comunicación desacoplada), con `+=`/`-=` para suscribirse/desuscribirse. Comprender los delegados (especialmente Func/Action y lambdas, la base de LINQ), y los eventos (el patrón pub-sub para código desacoplado y orientado a eventos) es importante para trabajar efectivamente con C#, ya que estas características sustentan LINQ, callbacks y manejo de eventos que aparecen constantemente. Dominarlos — particularmente reconocer que los lambdas son delegados y cómo permiten LINQ y patrones funcionales — es conocimiento frecuentemente aplicado que refleja comprensión de las capacidades funcionales de C# y su modelo orientado a eventos, y es un tema común en entrevistas.