7. Delegados, lambdas y eventos
En el curso de 2008, este capítulo seguía al de las interfaces gráficas de usuario con Windows Forms: los eventos se presentaban primero en el contexto de los botones y los formularios, y luego los estudiantes aprendían a crear eventos en sus propias clases. El capítulo sobre interfaces gráficas de usuario se ha eliminado de esta versión del curso. Por lo tanto, comenzamos directamente con el concepto que sustenta todo el mecanismo: el delegado, es decir, un objeto que hace referencia a uno o más métodos. Todos los ejemplos son programas de consola.
En los últimos veinte años, los delegados se han convertido en una de las herramientas más utilizadas del lenguaje. Escribirlos se ha vuelto considerablemente más sencillo con las expresiones lambda (C# 3), que ya hemos usado, sin entrar en detalles, con LINQ en el capítulo 5: [Where(n => n > 5)] pasa una lambda (y, por lo tanto, un delegado) al método [Where]. Este capítulo explica qué hay detrás de esta sintaxis. Concluye con los eventos, que también se basan en delegados. Las interfaces gráficas de usuario de .NET (Windows Forms, WPF, .NET MAUI), así como los frameworks web, se basan en este mecanismo: un clic en un botón o la llegada de una solicitud HTTP se señalan a los métodos suscritos.
Los programas de este capítulo son aplicaciones de archivo único ubicadas en la carpeta [07-delegates]. Se ejecutan con [dotnet run delegates-NN.cs].
7.1. Tipos de delegado predefinidos
7.1.1. El concepto de delegado
Un tipo de delegado describe un modelo (también llamado prototipo o firma) de un método: los tipos de sus parámetros y el tipo de su valor de retorno. Una variable de un tipo de delegado puede entonces hacer referencia a cualquier método que se ajuste a este modelo y ejecutarlo.
.NET define numerosos tipos de delegado. El más antiguo es [EventHandler], utilizado por todos los eventos que veremos al final de este capítulo. Se define de la siguiente manera:
La palabra clave [delegate] convierte a [EventHandler] en un tipo de delegado. Este tipo designa un patrón de método:
- cuyo primer parámetro es un objeto de tipo [object?] (el objeto que desencadenó el evento, posiblemente [null]);
- cuyo segundo parámetro es un objeto de tipo [EventArgs] (información sobre el evento);
- que no devuelve ningún resultado ([void]).
Un método que corresponda al modelo definido por [EventHandler] podría ser el siguiente:
Para crear un objeto de tipo [EventHandler] que haga referencia a este método, se puede escribir:
o, de forma más simple:
En esta segunda notación, el nombre del método [Display] (un grupo de métodos, ya que un método puede tener varias sobrecargas) es convertido automáticamente por el compilador en un objeto [EventHandler]: es la conversión de grupo de métodos, posible desde C# 2. El compilador selecciona, entre las sobrecargas de [Display], la que coincide con la firma del delegado. Luego el delegado se ejecuta como un método: [handler("program", EventArgs.Empty)].
7.1.2. Los delegados genéricos Func, Action y Predicate
Antes de los genéricos (C# 2), había que definir un tipo de delegado para cada firma de método. Hoy, el framework proporciona tipos de delegado genéricos que cubren casi todas las necesidades:
Tipo de delegado | Métodos referenciados |
[Action] | Sin parámetros, sin valor de retorno: [void M()] |
[Action<T1, ..., T16>] | De 1 a 16 parámetros, sin resultado: [void M(T1 p1, ...)] |
[Func<TResult>] | Sin parámetros, un resultado: [TResult M()] |
[Func<T1, ..., T16, TResult>] | De 1 a 16 parámetros, un resultado del tipo [TResult] (siempre el último tipo) |
[Predicate<T>] | un parámetro, un resultado booleano: [bool M(T p)] |
[Comparison<T>] | dos parámetros del mismo tipo, un resultado entero: [int M(T x, T y)] |
[Predicate<T>] y [Func<T, bool>] describen la misma firma, pero son dos tipos distintos: [Predicate<T>] data de .NET 2 y es utilizado por los métodos de [List<T>] y [Array] ([FindAll], [RemoveAll], [Exists]…), mientras que LINQ, introducido con .NET 3.5, usa [Func<T, bool>].
El programa [delegates-01.cs] usa estos tipos de delegado:
Resultados:
Comentarios:
- línea 4: creación de un delegado [EventHandler] mediante el operador [new]. Esta era la sintaxis obligatoria en C# 1;
- línea 6: lo mismo con una conversión de grupo de métodos. Esta es la sintaxis estándar en la actualidad;
- línea 8: el delegado se ejecuta como un método. Se ejecuta el método [Display] de la línea 39, con los parámetros pasados al delegado;
- línea 11: [Func<int, int, int>] hace referencia a un método con dos parámetros, [int], y que devuelve un [int] (el último tipo genérico). El método [Add] de la línea 44 es adecuado;
- línea 14: [Func<string>] hace referencia a un método sin parámetros que devuelve una cadena;
- línea 18: [Action<string>] hace referencia a un método con un parámetro, [string], y sin valor de retorno. [Console.WriteLine] tiene muchas sobrecargas; el compilador elige [WriteLine(string)];
- línea 22: un predicado es un método que devuelve un valor booleano. El método [FindAll] de la clase [List<T>] (línea 25) espera un parámetro de tipo [Predicate<T>]: devuelve la lista de elementos para los cuales el predicado devuelve [true]. Línea 26: el nombre del método
[IsEven]se pasa directamente; el compilador lo convierte en*[Predicate<int>]*; - Línea 31: el método [Sort] acepta un delegado [Comparison<T>] que compara dos elementos (con resultado negativo, cero o positivo, como [CompareTo]). Aquí, los nombres se ordenan de forma ascendente por longitud;
- líneas 35–36: un delegado es un objeto. Su tipo, que se muestra en la línea 9 de los resultados, es [System.Func`3[System.Int32,System.Int32,System.Int32]]: el nombre técnico de un tipo genérico con tres parámetros de tipo. Todo tipo de delegado deriva de la clase [System.Delegate], que proporciona, en particular, las propiedades [Method] (el método referenciado) y [Target] (el objeto sobre el que se llama al método, [null] para un método estático);
- el nombre del método, en la línea 10 de la salida, es sorprendente: los métodos de las líneas 39–50 son funciones locales del programa principal (véase el capítulo 3). El compilador las transforma en métodos estáticos de una clase que genera, con un nombre que ningún programa C# puede escribir.
7.2. Definición de tipos de delegado
Los tipos predefinidos suelen ser suficientes, pero es posible definir tipos de delegado propios. La instrucción:
define un tipo llamado [Operation], que representa una plantilla de método que recibe dos enteros y devuelve un entero. En comparación con [Func<int, int, int>], el tipo [Operation] tiene un nombre que describe su propósito, y sus parámetros tienen nombres ([n1], [n2]) que las herramientas de desarrollo muestran.
Una variable [op] de tipo [Operation] se usa para almacenar una lista de métodos que corresponden al modelo [Operation]: esto se denomina delegado multidifusión (multicast).
- Un método de tipo [f] se almacena en la variable [op] mediante [op = new Operation(f)] o, más simplemente, [op = f];
- Para agregar un método [g] a la lista de métodos ya registrados, se escribe [op += g];
- Para quitar un método [h] que ya está registrado, se escribe [op -= h];
- La instrucción [n = op(n1, n2)] ejecuta, en el orden en que fueron registrados, todos los métodos registrados en [op], con los parámetros [n1] y [n2]. El resultado devuelto [n] es el del último método ejecutado.
El curso de 2008 indicaba que no es posible obtener los resultados de todos los métodos. Sí es posible, pero no con una sola llamada: hay que recorrer la lista de métodos devuelta por [GetInvocationList] y llamarlos uno por uno. En la práctica, los métodos registrados en un delegado de multidifusión devuelven casi siempre [void].
Consideremos el ejemplo [delegates-02.cs]:
Resultados:
Comentarios:
- línea 73: definición del tipo de delegado [Operation]. En una aplicación con instrucciones de nivel superior, las declaraciones de tipos (clases, interfaces, delegados, etc.) se colocan después de las instrucciones del programa principal;
- Líneas 48–67: la clase [Calculations] tiene dos métodos de instancia, [Add] y [Subtract], y un método estático, [Increase], los tres con la firma del tipo [Operation];
- línea 5: la variable [op] es de tipo [Operation]. Se le asigna una primera referencia a un método, la del método estático [Calculations.Increase];
- línea 7: se ejecuta el delegado [op] . Se ejecutan todos los métodos referenciados por [op] , con los parámetros pasados a [op]. Aquí, solo se ejecuta el método [Calculations.Increase] ;
- línea 11: se crea una instancia [c1] de la clase [Calculations] ;
- línea 13: el método de instancia [c1.Add] se asigna al delegado [op]. [Increase] era un método estático, [Add] es un método de instancia: no importa. En el segundo caso, el delegado también almacena el objeto [c1] (su propiedad [Target]) sobre el cual se llamará al método;
- Línea 18: se hace lo mismo con el método de instancia [Subtract];
- Líneas 23–24: registramos los dos métodos [Add] y [Subtract] en el delegado [op];
- línea 26: se ejecutan ambos métodos (líneas 8–9 de los resultados). El resultado obtenido, 6, es el de [Subtract], el último método ejecutado;
- líneas 29–31: [GetInvocationList] devuelve la lista de métodos del delegado como un arreglo [Delegate[]]. El método LINQ [Cast<Operation>()] convierte cada uno de sus elementos a [Operation], lo que permite llamarlos uno por uno y recuperar cada resultado;
- Línea 34: se quita el método
[Subtract]del delegado. La notación***[op -= c1.Subtract]equivale a***[op = op - c1.Subtract]***. El resultado del operador [-] es de tipo [Operation?]: si se quita el último método de un delegado, se obtiene [null]*, no un delegado vacío. El compilador, que hace seguimiento de los tipos que admiten valores nulos (véase el capítulo 3), emitiría advertencias si se escribiera [op -= c1.Subtract] seguido de [op(1, 1)]: [CS8601] al asignar un valor potencialmente nulo a la variable que no admite valores nulos [op], y [CS8602] al llamar al método. Por eso almacenamos el resultado en una variable de tipo [Operation?] y lo verificamos antes de ejecutarlo (línea 36); - línea 42: quitamos el último método; el delegado resultante es [null] (línea 17 de los resultados);
- línea 45: un delegado también puede ejecutarse mediante su método [Invoke]: [op(1, 1)] y [op.Invoke(1, 1)] son equivalentes. Con el operador [?.] (C# 6), [empty?.Invoke(1, 1)] ejecuta el delegado solo si no es [null]; de lo contrario, la expresión se evalúa como [null] y no se ejecuta nada. La interpolación de cadenas representa [null] como una cadena vacía. Volveremos a ver esta sintaxis al tratar los eventos.
Un delegado es un objeto inmutable: las operaciones [+] y [-] (y, por lo tanto, [+=] y [-=]) no modifican el delegado existente; crean uno nuevo. Esta propiedad será importante al tratar los eventos.
7.3. Métodos anónimos y expresiones lambda
7.3.1. De los métodos anónimos a las lambdas
En los ejemplos anteriores, cada delegado hace referencia a un método con nombre escrito en otra parte del programa. Para métodos cortos que se usan una sola vez, esto resulta engorroso. C# 2 introdujo los métodos anónimos: el cuerpo del método se escribe justo donde se crea el delegado. C# 3 introdujo una sintaxis aún más concisa, las expresiones lambda, que han reemplazado prácticamente a los métodos anónimos. El programa [delegates-03.cs] muestra las distintas formas:
Resultados:
Comentarios:
- Líneas 4–6: un método anónimo. La palabra clave [delegate] va seguida de la lista de parámetros y del cuerpo del método. El compilador genera un método (con un nombre de su elección) y crea un delegado [Func<int, int, int>] que hace referencia a él. No hay nombre de método ni tipo de retorno: el tipo de retorno se infiere de las instrucciones [return];
- líneas 11–13: lo mismo con una expresión lambda. Se escribe la lista de parámetros, el operador [=>] (que se lee “da” o “tal que”) y luego el cuerpo. Una lambda cuyo cuerpo es un bloque delimitado por llaves es una lambda con cuerpo de bloque (statement lambda);
- Línea 18: faltan los tipos de los parámetros. El compilador los infiere del tipo de delegado de destino [Func<int, int, int>]: [n1] y [n2] son de tipo [int]. El cuerpo se reduce a una expresión, cuyo valor es el resultado de la lambda: es una lambda con cuerpo de expresión (lambda expression). Esta es la forma más común;
- línea 22: con un único parámetro cuyo tipo no se especifica, los paréntesis son opcionales. [x => x * x] se lee “x da x por x”. Línea 23: la misma lambda de un solo parámetro, de tipo [string], devuelve un valor booleano: es un [Predicate<string>];
- Líneas 27–28: sin parámetros, se usan paréntesis vacíos. Una lambda cuyo cuerpo es una llamada a un método ([void]) es adecuada para un delegado ([Action]);
- líneas 33–39: una lambda con cuerpo de bloque puede contener cualquier instrucción: declaraciones, bucles, condicionales, etc.;
- línea 44: el carácter de subrayado [_] denota un parámetro ignorado (descarte, C# 9). Se usa cuando la firma del delegado exige parámetros que la lambda no necesita, lo cual es habitual en los controladores de eventos;
- línea 49: el uso más común de las lambdas es pasarlas directamente como parámetros a un método que espera un delegado. Compárese con [delegates-01.cs]: ya no es necesario escribir un método [IsEven];
- línea 50: una lambda de tipo [Comparison<int>] que invierte la comparación habitual: la lista se ordena de forma descendente.
Repasemos las formas de una expresión lambda:
Forma | Ejemplo |
parámetros con tipo, cuerpo de bloque | [(int a, int b) => { return a + b; }] |
parámetros sin tipo, cuerpo de expresión | [(a, b) => a + b] |
un único parámetro sin tipo | [x => x * x] |
sin parámetros | [() => "Hello"] |
parámetros ignorados | [(_, _) => Console.WriteLine("received")] |
Los parámetros son todos con tipo o todos sin tipo: no se pueden mezclar. En este curso usaremos lambdas en lugar de métodos anónimos, que hoy solo son útiles en casos poco frecuentes.
7.3.2. Más sobre las lambdas
Las versiones recientes de C# han mejorado las lambdas. El programa [delegates-04.cs] muestra estas novedades:
Resultados:
Comentarios:
- Línea 4: hasta C# 9, una lambda no tenía un tipo propio: siempre había que especificar el tipo de delegado de destino ([Func<int, int> twice = x => x * 2]). Desde C# 10, una lambda con parámetros con tipo tiene un tipo natural: aquí, [Func<int, int>], como se muestra en la línea 2 de los resultados. Por lo tanto, podemos escribir [var]. Sin embargo, [var twice = x => x * 2;] es rechazado por el compilador, que no puede inferir el tipo de [x];
- línea 6: el tipo natural de una lambda que no devuelve nada es un [Action<...>];
- línea 10: un grupo de métodos también tiene un tipo natural, siempre que haya un solo método con ese nombre. [var write = Console.WriteLine;] sería rechazado: [WriteLine] tiene unas veinte sobrecargas;
- línea 14: desde C# 10, se puede especificar el tipo de retorno antes de la lista de parámetros. Aquí es necesario: las dos ramas del operador condicional tienen tipos distintos ([int] y [string]), y el compilador no sabría qué tipo de retorno elegir;
- línea 18: a partir de C# 12, los parámetros de las lambdas pueden tener valores predeterminados, igual que los parámetros de los métodos. Las líneas 19–20 llaman a la lambda con y sin el segundo parámetro;
- línea 22: de manera similar, el último parámetro de una lambda puede ser [params];
- línea 25: ni los tipos [Func] ni [Action] pueden representar un parámetro opcional o [params]. El compilador genera entonces un tipo de delegado anónimo, en este caso [<>f__AnonymousDelegate0] (línea 10 de los resultados). Solo puede ser utilizado por [var];
- Línea 29: una lambda declarada como [static] (C# 9) no puede usar las variables locales del método que la contiene ni [this]. Sí puede usar constantes, como [Coefficient] en la línea 28. Veremos en la siguiente sección qué significa “usar una variable local”; la palabra clave [static] garantiza que una lambda no capture ninguna, lo que evita asignaciones de memoria y errores;
- línea 58: un tipo de delegado cuyo parámetro se pasa por referencia ([ref], véase el capítulo 3). Los tipos [Func] y [Action] no admiten parámetros de tipo [ref] o [out]: hay que definir un tipo de delegado propio;
- Línea 34: hasta C# 13, una lambda cuyo parámetro era [ref], [out], o [in] debía indicar explícitamente el tipo de todos sus parámetros, como en [(ref int x) => x++]. A partir de C# 14, basta con el modificador, ya que el tipo se infiere del delegado de destino. Las líneas 36–37 incrementan dos veces la variable [counter];
- línea 39: lo mismo con un parámetro [out]. La lambda pasa su parámetro [out] a [int.TryParse];
- líneas 44–52: una función utilitaria que muestra el nombre de un tipo de delegado genérico en un formato legible ([Func<Int32, Int32>] en lugar de [Func`2]). Ella misma usa una lambda, en la línea 52.
7.3.3. Captura de variables y clausuras
Una lambda puede usar las variables locales del método en el que está escrita. Se dice que captura esas variables. Este mecanismo, muy potente, encierra algunas sorpresas. El programa [delegates-05.cs] las pone de manifiesto:
Resultados:
Comentarios:
- línea 5: la lambda usa la variable local
[threshold]declarada en la línea 4.[threshold]no es un parámetro de la lambda: es una variable capturada; - línea 8: [threshold] se modifica después de crear la lambda. Los resultados (líneas 2–3) muestran que la lambda ve el nuevo valor: [exceeds(7)] devuelve [True] y luego [False]. La lambda no copió el valor de [threshold] en el momento de su creación; comparte la variable misma con el método que la contiene;
- línea 13: una lambda también puede modificar una variable capturada. Después de las dos llamadas de las líneas 14–15, la variable [total] es igual a 7;
- Líneas 60–64: la función [CreateCounter] devuelve una lambda que captura su variable local [value]. Normalmente, una variable local desaparece cuando termina el método. Aquí, la variable [value] sobrevive a [CreateCounter] porque la lambda devuelta todavía la usa. La combinación de la lambda y las variables que captura se denomina clausura (closure). Para implementarlo, el compilador transforma las variables capturadas en campos de un objeto que genera, y la lambda en un método de ese objeto;
- líneas 19–20: cada llamada a [CreateCounter] crea una nueva variable [value] (y, por lo tanto, un nuevo contador) que es independiente de los demás. Los resultados (líneas 5–6) lo confirman;
- líneas 26–29: la trampa clásica. Creamos tres lambdas en un bucle [for], esperando que impriman 0, 1 y 2. Todas imprimen 3 (línea 7 de los resultados). En realidad, el bucle [for] tiene una sola variable, [i], que es compartida por las tres lambdas. Cuando se ejecutan esas lambdas, el bucle ya ha terminado, y [i] es igual a 3;
- Líneas 42–43: la corrección. La variable [copy] se declara dentro del cuerpo del bucle: se crea una nueva variable en cada iteración, y cada lambda captura la suya;
- líneas 51–53: con [foreach], el problema no se presenta. Hasta C# 4, la variable de un bucle [foreach] era única, igual que la de un bucle [for], y este código imprimía 2 2 2. C# 5 cambió esta regla (es uno de los pocos cambios incompatibles con versiones anteriores en la historia del lenguaje): la variable [j] ahora se inicializa de nuevo en cada iteración. El bucle [for] no se ha modificado;
- línea 46: el método [ForEach] de [List<T>] espera un [Action<T>] y lo ejecuta sobre cada elemento. Aquí, cada elemento es a su vez un delegado [Action], que la lambda ejecuta.
La trampa del bucle [for] se presenta principalmente con el procesamiento diferido: una lambda registrada como controlador de eventos o lanzada en otro hilo (capítulo 8) se ejecuta después de que el bucle que la creó ha terminado.
7.4. ¿Delegados o interfaces?
Los conceptos de delegado e interfaz pueden parecer bastante similares, y uno podría preguntarse cuáles son exactamente las diferencias entre ambos. Tomemos el ejemplo [delegates-06.cs], que es similar a [delegates-02.cs]:
Resultados:
En la línea 15, el método [Execute] espera una referencia a un objeto del tipo de delegado [Operation] definido en la línea 34. Esto permite pasar diferentes métodos al método [Execute] (líneas 4, 6, 10 y 12). La última línea incluso le pasa una lambda: no fue necesario escribir un método de multiplicación. Este polimorfismo también puede lograrse mediante una interfaz, como muestra [delegates-07.cs]:
Resultados:
Comentarios:
- líneas 15–17: la interfaz [IOperation] define un método [Operation];
- líneas 21–26 y 31–36: las clases [Add] y [Subtract] implementan la interfaz [IOperation];
- líneas 9–11: el método [Execute], cuyo primer parámetro es del tipo definido por la interfaz [IOperation]. Recibe, sucesivamente, una instancia de la clase [Add] como primer parámetro, seguida de una instancia de la clase [Subtract].
Esto demuestra claramente la naturaleza polimórfica del parámetro de tipo delegado del ejemplo anterior. Al mismo tiempo, ambos ejemplos ponen de relieve las diferencias entre estos dos conceptos. Los tipos de delegado e interfaz son intercambiables:
- si la interfaz tiene un solo método. En efecto, el tipo delegado es un envoltorio de un único método, mientras que una interfaz puede definir varios métodos;
- si no se utiliza la característica de multidifusión (multicast) del delegado. Este concepto de multidifusión no existe en una interfaz.
Si se cumplen estas dos condiciones, puede elegir entre las dos firmas siguientes para el método [Execute]:
La segunda, que utiliza el delegado, es más flexible de usar. En la primera firma, el primer parámetro debe implementar la interfaz [IOperation]: esto obliga a crear una clase que defina el método que se pasará a [Execute]. En el segundo enfoque, sirve cualquier método existente con la firma correcta, y una expresión lambda permite incluso definir ese método directamente en el lugar de la llamada. No se requiere código adicional. Esta flexibilidad explica por qué las bibliotecas modernas (LINQ, programación asíncrona, ASP.NET Core) hacen un uso intensivo de los delegados.
La interfaz recupera la ventaja en cuanto el comportamiento que se debe pasar involucra varios métodos relacionados entre sí, o requiere su propio estado e identidad. Es el caso de la interfaz [ITaxDao] de la capa [dao] del capítulo 6: aunque tiene un solo miembro, sus implementaciones tienen estado (los tramos leídos, el nombre del archivo), son creadas por el contenedor de inyección de dependencias y representan un rol claramente nombrado dentro de la aplicación. Un delegado [Func<TaxBracket[]>] habría bastado técnicamente, pero habría sido mucho menos descriptivo.
7.5. Gestión de eventos
7.5.1. El modelo de eventos de .NET
Los delegados se utilizan para definir eventos. Una clase [C1] puede definir un evento [Evt1] de la siguiente manera:
- Se define un tipo delegado dentro o fuera de la clase [C1]:
- La clase [C1] define un campo de este tipo delegado:
- Cuando una instancia [c1] de la clase [C1] quiere señalar un evento, ejecuta su delegado [Evt1] pasándole los parámetros definidos por el tipo [Evt]. Todos los métodos registrados en el delegado [Evt1] se ejecutan entonces con esos parámetros. Se dice que han sido notificados del evento [Evt1];
- si un objeto [c2] que utiliza el objeto [c1] quiere ser notificado del evento [Evt1] del objeto [c1], registra uno de sus métodos, [c2.M], en el delegado [c1.Evt1]. Su método [c2.M] se ejecutará entonces cada vez que el evento [Evt1] ocurra en el objeto [c1]. También puede cancelar su suscripción cuando ya no desee ser notificado;
- como el delegado [c1.Evt1] puede registrar varios métodos, distintos objetos [ci] pueden registrarse en [c1.Evt1] para ser notificados del evento.
En este escenario, tenemos:
- una clase que señala (también se dice "publica" o "emite") un evento;
- clases que son notificadas de este evento. Se dice que están suscritas al evento;
- un tipo delegado que define la firma de los métodos que serán notificados del evento. Estos métodos se denominan controladores de eventos.
Este es el patrón de diseño Observador (Observer): el emisor no conoce a sus suscriptores; simplemente los notifica.
El framework .NET define una firma estándar para un delegado de evento:
- [sender]: el objeto que desencadenó el evento;
- [e]: un objeto de tipo [EventArgs] o de un tipo derivado, que proporciona información sobre el evento;
- Por convención, el nombre del tipo delegado termina en [EventHandler].
También define una forma estándar de declarar en una clase un evento de tipo [MyEventHandler] :
El campo [Evt1] es del tipo delegado. La palabra clave [event] restringe las operaciones que se pueden realizar sobre él:
- Desde fuera de la clase [C1], solo se permiten las operaciones [+=] y [-=]. Esto impide que otros objetos sobrescriban o eliminen los métodos suscritos (por error, por ejemplo, al escribir [=] en lugar de [+=]). Solo se puede suscribir ([+=]) o cancelar la suscripción ([-=]);
- solo la clase [C1] puede ejecutar el delegado, es decir, desencadenar el evento: [Evt1?.Invoke(this, e)].
Si se intenta, desde fuera de la clase, escribir [c1.Evt1 = null;] o [c1.Evt1(null, EventArgs.Empty);], el compilador responde con: [error CS0070: The event 'C1.Evt1' can only appear on the left hand side of += or -= (except when used from within the type 'C1')].
En lugar de definir un tipo delegado para cada evento, se utiliza el delegado genérico predefinido:
El tipo [TEventArgs] es el del segundo parámetro, el objeto que describe el evento. Con este delegado genérico, la declaración de un evento [X] en una clase [C] sigue el patrón recomendado a continuación:
- definir un tipo [XEventArgs] derivado de [EventArgs] para encapsular la información sobre el evento [X];
- definir un evento de tipo [EventHandler<XEventArgs>] en la clase [C];
- definir en la clase [C] un método protegido y virtual [protected virtual void OnX(XEventArgs e)] destinado a publicar el evento [X] a los suscriptores. Es virtual para que una clase derivada pueda modificar la forma en que se publica el evento.
En 2008, el tipo [TEventArgs] debía derivar de [EventArgs] (restricción [where TEventArgs : EventArgs]). Esta restricción se eliminó en .NET Framework 4.5: cualquier tipo es aceptable, incluido un [record]. Sin embargo, por convención, se sigue derivando de [EventArgs]. Tenga en cuenta que un [record] no puede derivar de [EventArgs]: un [record] solo puede heredar de otro [record] (error: [CS8864: Records may only inherit from object or another record]). Por lo tanto, utilizaremos una clase normal.
7.5.2. Un ejemplo: la temperatura es demasiado alta
Considere el siguiente ejemplo:
- Una clase [Publisher] encapsula una temperatura. Cuando esta temperatura supera cierto umbral, debe desencadenarse un evento. Llamaremos a este evento [TemperatureTooHigh]. La información sobre este evento se encapsulará en un tipo [TemperatureTooHighEventArgs];
- una clase llamada [Subscriber] se suscribe al evento anterior. Cuando es notificada del evento, muestra un mensaje en la consola. A diferencia de la versión de 2008, un suscriptor cancela su suscripción automáticamente tras recibir un número determinado de alertas;
- Un programa de consola crea un emisor y dos suscriptores. Lee temperaturas por teclado y las almacena en el emisor. Si alguna es demasiado alta, el emisor publica el evento [TemperatureTooHigh].
El curso de 2008 distribuía estas clases en cuatro archivos de un proyecto. Las hemos agrupado en la aplicación de un solo archivo [delegates-08.cs], que presentamos en tres partes. Primero, la clase de información del evento y la clase [Publisher]:
Comentarios:
- Líneas 38–43: la clase [TemperatureTooHighEventArgs] deriva de [EventArgs], según la convención. Utiliza un constructor primario (C# 12, véase el capítulo 4): el parámetro [temperature] inicializa la propiedad de solo lectura [Temperature], que representa la temperatura que desencadenó el evento. Hemos agregado la hora del evento, [Time]. La información del evento es de solo lectura: un suscriptor no debe poder modificarla para los suscriptores siguientes;
- línea 50: el umbral de temperatura por encima del cual se publica el evento [TemperatureTooHigh] ;
- línea 52: el emisor tiene un nombre con fines de identificación;
- línea 54: el evento [TemperatureTooHigh], de tipo [EventHandler<TemperatureTooHighEventArgs>]. El tipo acepta valores nulos ([?]): mientras nadie se haya suscrito, el delegado vale [null];
- líneas 57–66: la propiedad [Temperature]. Su descriptor de acceso, [set], desencadena el evento si la temperatura registrada supera el umbral. Utiliza la palabra clave [field] de C# 14 (véase el capítulo 4), que se refiere al campo oculto de una propiedad automática: ya no es necesario declarar un campo privado [temperature] como se requería en 2008;
- Línea 66: la publicación está a cargo del método [OnTemperatureTooHigh], al que se pasa un objeto [TemperatureTooHighEventArgs] que contiene la temperatura que superó el umbral;
- Líneas 72–75: el evento se publica con el propio emisor ([this]) como primer parámetro y el objeto recibido por el método como segundo parámetro. El operador [?.] es esencial: si no hay suscriptores, [TemperatureTooHigh] equivale a [null]. El código de 2008 utilizaba [TemperatureTooHigh(this, evt)], lo que provocaba una [NullReferenceException] si no había suscriptores. La notación [TemperatureTooHigh?.Invoke(this, e)] también es más segura en un programa multihilo (capítulo 8): el delegado se lee una sola vez, luego se verifica y se ejecuta; una cancelación de suscripción simultánea en otro hilo no puede hacer que pase a ser [null] entre la verificación y la llamada.
Esta es la clase [Subscriber]:
Comentarios:
- línea 80: cada suscriptor se identifica mediante un nombre ([Name]) y recibe el número máximo de alertas que acepta ([nbAlertsMax]);
- Líneas 88–90: suscripción al evento de un emisor. El método [EvtTemperatureTooHigh] del suscriptor se registra en el evento: se trata de una conversión de grupo de métodos. En 2008, la suscripción la realizaba el programa principal; aquí es responsabilidad del suscriptor, que debe saber qué método quitar para cancelar la suscripción;
- Líneas 94–96: la cancelación de la suscripción quita el mismo método mediante [-=]. Para el delegado, el método [EvtTemperatureTooHigh] de [s0] y el de [s1] son dos métodos distintos, puesto que no tienen el mismo destino ([Target]): [-=] quita únicamente el del suscriptor correspondiente;
- línea 100: el controlador de eventos. Tiene la firma impuesta por el delegado [EventHandler<TemperatureTooHighEventArgs>]: un [object?] y un [TemperatureTooHighEventArgs]. Es privado: solo el suscriptor puede registrarlo en un emisor;
- Línea 102: el parámetro [source] es de tipo [object?]. El filtrado por patrón verifica que sea efectivamente un [Publisher] y lo almacena en la variable [publisher]. El código de 2008 utilizaba una conversión de tipo a [((Publisher)source).Name];
- línea 106: el controlador muestra el nombre del suscriptor, el nombre del emisor que informó del evento y la temperatura que lo desencadenó;
- líneas 108–111: tras [nbAlertsMax] alertas, el suscriptor cancela su suscripción al emisor. El suscriptor lo hace mientras se publica el evento, desde su propio controlador. Esto es seguro: hemos visto que un delegado es inmutable. [-=] crea un nuevo delegado y lo almacena en el campo del evento, pero la publicación en curso sigue recorriendo la lista anterior.
Por último, este es el programa principal:
Resultados:
Comentarios:
- línea 4: creación del emisor;
- Líneas 6–9: creación de dos suscriptores, [s0] (hasta 3 alertas) y [s1] (1 alerta), que se suscriben al evento [TemperatureTooHigh] del emisor. La expresión de colección [new("s0", 3), new("s1", 1)] utiliza el operador [new] sin tipo (C# 9), ya que el tipo se infiere a partir del tipo del arreglo;
- línea 12: un tercer suscriptor, una lambda, que actúa como registro (log). Los tipos de [source] y [e] se infieren del tipo del evento. No es fácil cancelar la suscripción de una lambda: habría que almacenarla en una variable para quitarla mediante [-=], porque dos lambdas escritas de la misma manera son dos delegados distintos. Por lo tanto, las lambdas se reservan para suscripciones que duran tanto como el emisor;
- Líneas 15–33: bucle de lectura de temperaturas por teclado. [Console.ReadLine()] devuelve [null] si la entrada estándar está cerrada; [?.Trim() ?? ""] trata este caso como una entrada vacía;
- línea 28: si la temperatura introducida es válida, se envía al emisor [e1], que desencadena el evento [TemperatureTooHigh] si es superior a 19 °C.
Los resultados muestran:
- línea 2: 17 °C no supera el umbral: no hay evento;
- líneas 3–7: 21 °C desencadena el evento. Los tres suscriptores son notificados en el orden de sus suscripciones. [s1], que acepta una sola alerta, cancela su suscripción de inmediato, pero eso no impide que el registro (log), que se suscribió después de él, sea notificado;
- líneas 10–12: [s1] ya no es notificado;
- líneas 13–16: [s0] recibe su tercera alerta y cancela a su vez su suscripción;
- línea 17: solo queda el registro.
7.6. Los delegados y LINQ
En el capítulo 5 utilizamos los métodos de LINQ ([Where], [Select], [OrderBy]…) pasándoles lambdas. Ahora sabemos qué son estos parámetros: el método [Where] se declara de la siguiente manera en la clase [System.Linq.Enumerable]:
Su parámetro [predicate] es un delegado [Func<TSource, bool>]: sirve cualquier método o lambda que reciba un elemento y devuelva un booleano. Para comprender a fondo cómo funciona LINQ, escribamos nosotros mismos un método de filtrado. Este es el programa [delegates-09.cs]:
Resultados:
Comentarios:
- Líneas 6–7: la lambda de [Where] se almacena primero en una variable de tipo [Func<int, bool>] para revelar su tipo. [Select], por su parte, recibe un delegado [Func<int, int>] que transforma cada elemento: así se obtienen los cuadrados de los números pares;
- líneas 37–44: nuestro método [Filter]. Es genérico: filtra una secuencia de elementos de cualquier tipo [T], utilizando un predicado de tipo [Func<T, bool>]. Recorre la secuencia y llama al predicado (línea 41) con cada elemento;
- línea 44: la instrucción [yield return] convierte [Filter] en un iterador: el método no construye una lista; devuelve los elementos seleccionados uno por uno, a medida que los solicita el programa que recorre el resultado. Después de cada llamada a [yield return], la ejecución de [Filter] se suspende; se reanuda en el mismo punto cuando se solicita el siguiente elemento;
- Línea 11: llamada a [Filter] con una lambda. El tipo [T] se infiere a partir del arreglo: [int]. En la línea 12 se le pasa un grupo de métodos;
- Líneas 15–18: un predicado "verboso" que imprime cada elemento que prueba. El resultado (líneas 5–6) muestra que crear la consulta no ejecuta nada: el mensaje de la línea 20 se muestra antes de la primera prueba. Solo durante el bucle [foreach] se ejecuta [Filter] , y las pruebas se alternan con las impresiones del bucle. Esta es la ejecución diferida, la misma de las consultas LINQ;
- líneas 53–63: un bloque de miembros de extensión (C# 14, introducido en el capítulo 4) agrega dos métodos al tipo [IEnumerable<T>]: [Filter], que reutiliza [Tools.Filter], y [Transform], el equivalente de [Select]. [Transform] es doblemente genérico: [T] es el tipo de los elementos de la secuencia y [TResult] es el tipo de los elementos producidos por la transformación;
- Línea 29: gracias a los métodos de extensión, nuestros métodos se llaman igual que los métodos de la secuencia y se encadenan igual que los de LINQ: conservamos las ciudades de 5 letras o menos y luego las ponemos en mayúsculas.
Toda la biblioteca LINQ está construida sobre este modelo: métodos de extensión de [IEnumerable<T>] que aceptan delegados y devuelven nuevas secuencias, calculadas bajo demanda mediante iteradores.
7.7. Árboles de expresión
Una expresión lambda puede convertirse en un delegado, como hemos hecho a lo largo de este capítulo. También puede convertirse en un árbol de expresión: en lugar de compilar la lambda en código ejecutable, el compilador genera instrucciones que construyen, en tiempo de ejecución, una estructura de datos que describe la lambda. Para ello, basta con utilizar el tipo [Expression<TDelegate>] del espacio de nombres [System.Linq.Expressions] en lugar del tipo delegado. El programa [delegates-10.cs] compara ambos:
Resultados:
Comentarios:
- línea 2: el espacio de nombres [System.Linq.Expressions] no forma parte de las directivas [using] implícitas;
- Líneas 5–6: la misma lambda se asigna a un delegado [Func<int, bool>] y luego a un árbol de expresión [Expression<Func<int, bool>>];
- línea 9: un delegado solo puede mostrar su tipo; su código está compilado y es ilegible;
- línea 11: un árbol de expresión, en cambio, se puede mostrar. El resultado (línea 3) reproduce la lambda: [AndAlso] es el nombre del operador [&&];
- línea 12: podemos consultar el árbol: sus parámetros, el tipo de su resultado y su cuerpo ([Body]);
- líneas 21–39: un método recursivo que muestra el árbol. Cada nodo es un objeto derivado de la clase [Expression]: [BinaryExpression] para una operación de dos operandos ([&&], [>], [==], [%]), [ParameterExpression] para un parámetro, [ConstantExpression] para una constante. Un [switch], con filtrado por patrón basado en el tipo, trata cada caso. Los resultados (líneas 6–14) muestran la estructura de la expresión [n > 5 && n % 2 == 0];
- línea 17: un árbol de expresión puede compilarse en tiempo de ejecución en un delegado y luego ejecutarse.
¿Para qué sirve esto? Un delegado solo puede ejecutarse dentro del programa. Un árbol de expresión puede analizarse y traducirse a otro lenguaje. Esto es lo que hace Entity Framework Core, que exploraremos en el capítulo 11. Al escribir una consulta LINQ sobre una tabla de base de datos, por ejemplo [context.Brackets.Where(t => t.Limit > 20000)], el método [Where] utilizado no es el de [IEnumerable<T>] sino el de [IQueryable<T>], cuyo parámetro es un [Expression<Func<T, bool>>]. EF Core recorre este árbol, igual que nuestro método [Display], y lo traduce a una cláusula SQL [WHERE limits > 20000] ejecutada por el servidor de base de datos. La misma lambda, escrita de la misma manera, se convierte así en código .NET o en código SQL, según el tipo del parámetro que reciba.
7.8. Conclusión
Puntos clave de este capítulo:
- Un delegado es un objeto que hace referencia a uno o varios métodos con una firma determinada. Los tipos predefinidos [Func<>], [Action<>], y [Predicate<T>] suelen eliminar la necesidad de definir tipos delegados propios;
- las expresiones lambda permiten escribir el método justo donde se crea el delegado. Capturan las variables que las rodean (cuidado con los bucles [for]);
- Un delegado puede reemplazar a una interfaz de un solo método, con mayor flexibilidad;
- un evento es un delegado protegido por la palabra clave [event]: uno se suscribe con [+=], cancela la suscripción con [-=], y solo la clase que lo declara lo desencadena, mediante [Evt?.Invoke(this, e)];
- LINQ se basa en métodos que aceptan delegados, y EF Core se basa en árboles de expresión.
Volveremos a hablar de los delegados en los capítulos siguientes: una tarea ([Task.Run]) ejecuta un delegado en otro hilo (capítulos 8 y 9), y los servicios web de ASP.NET Core asocian lambdas con direcciones HTTP (capítulo 13).