Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

Delegates y eventos Delegates Un delegate es muy similar a un puntero a función de C++, es una estructura de datos que referencia a un método estático o a un método de instancia de un objeto. Existen algunas diferencias: - Un puntero a función de C++ sólo puede referenciar funciones estáticas. - Un delegate no sólo referencia al punto de entrada del método, sino también a la instancia del objeto al que pertenece el método. El sentido de los delegates es permitir que un método pueda recibir como parámetro un puntero a otro método. Es más, no es necesario conocer en tiempo de compilación el método concreto que se pasa como parámetro: puede asignarse en tiempo de ejecución, lo cual ofrece una gran flexibilidad a la hora de programar. El tipo base de todos los delegates es la clase System.Delegate,que quiere decir que un delegate es una instancia de la clase System.Delegate (o una derivada). Los delegates no necesitan saber la clase de objeto al cual referencian. Lo que necesitan saber es la definición del método al que referencian.

Declaración de Delegates. Una declaración de un delegate define un tipo de referencia que extiende la clase System.Delegate y que puede utilizarse para encapsular un método con una definición determinada.. La sintaxis de la declaración es: declaración-delegate: atributosopc modificadores-del-delegateopc delegate identificador(lista-parámetros-formalesopc ) ; modificadores-del-delegate: modificador-del-delegate modificadores-del-delegate modificador-del-delegate modificador-del-delegate: new public protected internal private

Por ejemplo: delegate int MiDelegate();

Un ejemplo más detallado es el siguiente: delegate int MiDelegate(int x);

1/11

tipo-resultado

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

class MiClase { MiDelegate d = new MiDelegate(Cuadrado); static float Cuadrado(float x) { return x * x; } static int Cuadrado(int x) { return x * x; } }

Utilización de Delegates. Una instancia de tipo delegate encapsula un método, también llamado “entidad invocable”. En el caso de métodos estáticos, una entidad invocable consta únicamente del método. En el caso de métodos de instancia, una entidad invocable consta de una instancia de la clase del método y un método de tal instancia. Un ejemplo de utilización de instancias de tipo delegate es: using System; // declaración del delegate delegate int MiDelegate(); public class MiClase { public int MetodoInstancia () { Console.WriteLine("Hola desde el método de instancia."); return 0; } static public int MetodoEstatico () { Console.WriteLine("Hola desde el método estático."); return 0; } } public class Aplicacion { static void Main (string[] args) { MiClase p = new MiClase(); // Asociar el delegate al método de instancia: MiDelegate d = new MiDelegate(p.MetodoInstancia); // Invocación al método de instancia a través del delegate: d(); // Asociar el delegate al método estático: d = new MiDelegate(MiClase.MetodoEstatico); // Invocación al método estático a través del delegate: d(); } }

2/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

La salida de este programa es el de la figura 8.1:

Figura 8.1

Delegates Multicast. Un delegate de tipo multicast puede asociarse a más de un método, de modo que invocando al delegate una sola vez, todos los métodos a los que está asociado sean invocados secuencialmente. Un delegate referencia realmente una lista de métodos a la que es posible añadir o quitar métodos utilizando los operadores +, +=, - y -=. Para ilustrar esto puede modificarse el método Main() del ejemplo anterior: static void Main (string[] args) { MiClase p = new MiClase(); // Asociar el delegate al método de instancia: MiDelegate d = new MiDelegate(p.MetodoInstancia); // Asociar el delegate al método estático, se utiliza //el operador + para que se añada el método estático //a la lista de métodos apuntados por el delegate d: d += new MiDelegate(MiClase.MetodoEstatico); // Invocación //delegate:

de

ambos

d(); }

Obsérvese que sólo se invoca una vez el delegate d(). El resultado se representa en la figura 8.2:

3/11

métodos

a

través

del

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

Figura 8.2

Existe una clase específica para este tipo de delegates multicast llamada System.MulticastDelegate, la cual deriva de System.Delegate y está en el assembly Mscorlib (Mscorlib.dll). La clase Delegate soporta una lista de métodos siempre que todos devuelvan el mismo tipo de datos, pero en una lista de varios métodos esto no tiene porqué ser así. Cuando el compilador detecta que un delegate devuelve void crea una instancia de MulticastDelegate en lugar de una de Delegate.

4/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

Eventos. En su sentido más concreto, un evento es un campo o propiedad de una clase o estructura. El tipo del evento es delegate, lo cual quiere decir que puede referenciar a una lista de métodos. Lo interesante de los eventos es que son utilizados por la clase a la que pertenecen para notificar que algo ha sucedido a otras clases.

El modelo de eventos en el entorno .NET El modelo de eventos .NET se basa en los conceptos de productor o fuente de eventos y consumidor o manejador de eventos.

Figura 8.3. Modelo de eventos en el entorno .NET El productor o fuente puede generar uno o varios eventos diferentes. El consumidor o manejador se suscribe a uno o varios eventos del productor para que se le notifique cuando un evento suceda. Para poder implementar el mecanismo de suscripción a eventos se utilizan los delegates. El productor tiene tantas instancias de tipo delegate como eventos pueda producir. Cuando un consumidor quiere suscribirse a un evento concreto ha de añadir a la lista de métodos del delegate correspondiente la referencia a un método (del consumidor) que será el que se invoque a través del delegate cuando se de el evento. Al método cuya referencia se pasa al delegate se llama método manejador del evento.

El productor o fuente del evento. La clase que se comporta como fuente de eventos se caracteriza por tener un miembro de tipo event, el cual se construye a partir de un tipo delegate. Este miembro de tipo event es el que va a referenciar a la lista de métodos manejadores del evento. Un ejemplo de clase fuente o productor de eventos puede es:

5/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

//Delegate que será utilizado como tipo base del evento MiRefME public delegate void ReferenciaManejadoresEventos (object fuente, ArgumentosEvento eventArgs); //Clase productora o fuente del evento MiRefME public class MiFuenteEventos { //MiRefME es el evento, su tipo está determinado por el delegate //ReferenciaManejadoresEventos public event ReferenciaManejadoresEventos MiRefME; //Este método será llamado por los consumidores de eventos //para suscribirse al evento public void AñadirManejador (MiManejadorEventos manejador) { //Añade a la lista de métodos manejadores la referencia al //método ManejadorMiFuenteEventos, el cual ha de existir //en el objeto manejador y será el método del consumidor //al que se llame cuando se de el evento MiRefME this.MiRefME += new ReferenciaManejadoresEventos (manejador.ManejadorMiFuenteEventos); } //Este método será llamado cuando se desee lanzar el evento public void LanzarEvento () { //A través de MiRefME se invoca a todos los métodos //manejadores registrados en la lista referenciada por //MiRefME. this.MiRefME (this,new ArgumentosEvento ("MiFuenteEventos")); } }

El elemento primordial de esta clase es public event ReferenciaManejadoresEventos MiRefME;

al cual pueden suscribirse los consumidores o manejadores de eventos y a través del cual pueden ser invocados. El resto, es decir, los métodos de la clase, han sido creados para facilitar el manejo del evento. Es importante notar que la estructura de los métodos manejadores, cuyas referencias se añadirán a la lista de MiRefME, es determinada por el delegate: public

delegate

void

ReferenciaManejadoresEventos (object fuente, ArgumentosEvento eventArgs);

en este ejemplo como puede verse, al invocar a los métodos manejadores del evento se le pasan dos argumentos (que es el caso más común): • fuente representa la clase del objeto que ha generado el evento. • eventArgs representa los argumentos del evento.

6/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

Los argumentos del evento. Cuando se notifica un evento a un consumidor, se transmite al consumidor o manejador cierta información relativa al evento. Piense en un evento “pulsación de tecla” que se notifique a un formulario. Un dato interesante es el código de la tecla pulsada. A esta información relativa al evento se le llama argumentos del evento y lo normal es que sea un objeto de una clase derivada de la clase System.EventArgs. Siguiendo el ejemplo anterior: //Al notificar que ha sucedido un evento, lo más común //es que se desee dar alguna información más. //Esto puede hacerse utilizando una clase derivada de EventArgs //en la que se indiquen los argumentos del evento. public class ArgumentosEvento : EventArgs { public string fuenteEvento; public ArgumentosEvento (string fuenteEvento) { this.fuenteEvento = fuenteEvento; } }

El consumidor del evento. El consumidor del evento es un objeto al que se le avisa o notifica que el evento ha ocurrido. Dicho objeto realiza una acción de respuesta a ese evento (por ejemplo, la clase Formulario puede querer ser avisada de un evento pulsación de tecla para mostrar el código de la tecla en una caja de texto). Para poder realizar la acción de respuesta, la clase consumidora del evento ha de poseer un método que será invocado cuando se de el evento y cuyo código provocará la respuesta. Siguiendo con el ejemplo anterior, la clase consumidora o manejadora puede ser: //Una clase manejadora del evento MiRefME ha de disponer del método //ManejadorMiFuenteEventos public class MiManejadorEventos { public void ManejadorMiFuenteEventos (object fuente, ArgumentosEvento eventArgs) { System.Console .WriteLine ("Se ha lanzado un evento"); System.Console.WriteLine ("El origen es: " + eventArgs.fuenteEvento); } }

El método ManejadorMiFuenteEventos es el que deberá ser invocado cuando se dé el evento. Para ello ha de estar referenciado por la lista del evento MiRefME (obsérvese que los argumentos que espera son los que indica el delegate ReferenciaManejadoresEventos.

7/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

Suscripción al evento. Una vez se dispone de las clases productora o fuente y consumidora o manejadora es posible crear objetos de ambas y conectarlos entre sí. Al mecanismo de conexión entre manejador y fuente se le llama “suscripción” y consiste en añadir la referencia al método manejador del evento a la lista de referencias del evento (MiRefME). Siguiendo con el ejemplo anterior: public class Aplicacion { public static void Main(string [] args) { MiFuenteEventos MFE = new MiFuenteEventos (); MiManejadorEventos MME = new MiManejadorEventos (); //Suscripción al evento MFE.AñadirManejador (MME); ... ...

Al pasarle la referencia al objeto MME (MiManejadorEventos) al método AñadirManejador de la fuente de eventos, se añade la referencia al método ManejadorMiFuenteEventos en la lista de manejadores del evento. A partir de ahora, cada vez que se de el evento MiRefME, se llamará al método ManejadorMiFuenteEventos del objeto MME. Es importante tener en cuenta que el modelo de eventos es un patrón de comportamiento que se ha diseñado para manejar la interacción del usuario con el sistema en las aplicaciones gráficas (aunque no es su única aplicación). De este modo puede comprenderse que un caso ejemplo es que un objeto Formulario desee suscribir un método OnClick() al evento click de un objeto de la clase Button. Así, cuando el usuario pulse el objeto de la clase Button se dará el evento click y se llamará al método OnClick() del objeto Formulario.

Lanzamiento del evento. Cuando ocurre el evento ha de invocarse a todos los métodos manejadores suscritos al evento. En el caso de una aplicación gráfica esta situación puede corresponder a una pulsación con el ratón por parte del usuario sobre un botón. En este caso, el S.O. es el encargado de lanzar el evento, es decir, llamar al método OnClick() del objeto Formulario suscrito al evento click sobre el botón. En el ejemplo que se está siguiendo un modo de lanzar el evento es: MFE.LanzarEvento ();

Con lo que la clase aplicación puede quedar como sigue: public class Aplicacion { public static void Main(string [] args) { MiFuenteEventos MFE = new MiFuenteEventos (); MiManejadorEventos MME = new MiManejadorEventos (); //Suscripción al evento

8/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

MFE.AñadirManejador (MME); System.Console.WriteLine ("Si desea lanzar el evento pulse Enter"); System.Console.ReadLine(); //Lanzamiento del evento MFE.LanzarEvento (); } }

En este caso el evento es lanzado explícitamente cuando el usuario pulsa ENTER.

El ejemplo completo. El resultado de unir el código comentado es: using System; //Al notificar que ha sucedido un evento, lo más común //es que se desee dar alguna información más. //Esto puede hacerse utilizando una clase derivada de EventArgs //en la que se indiquen los argumentos del evento. public class ArgumentosEvento : EventArgs { public string fuenteEvento; public ArgumentosEvento (string fuenteEvento) { this.fuenteEvento = fuenteEvento; } } //Delegate que será utilizado como tipo base del evento MiRefME public delegate void ReferenciaManejadoresEventos (object fuente, ArgumentosEvento eventArgs); //Clase productora o fuente del evento MiRefME public class MiFuenteEventos { //MiRefME es el evento, su tipo está determinado por el delegate //ReferenciaManejadoresEventos public event ReferenciaManejadoresEventos MiRefME; //Este método será llamado por los consumidores de eventos //para suscribirse al evento public void AñadirManejador (MiManejadorEventos manejador) { //Añade a la lista de métodos manejadores la referencia al //método ManejadorMiFuenteEventos, el cual ha de existir //en el objeto manejador y será el método del consumidor //al que se llame cuando se de el evento MiRefME this.MiRefME += new ReferenciaManejadoresEventos (manejador.ManejadorMiFuenteEventos); } //Este método será llamado cuando se desee lanzar el evento public void LanzarEvento () {

9/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

//A través de MiRefME se invoca a todos los métodos //manejadores registrados en la lista referenciada por //MiRefME. this.MiRefME (this,new ArgumentosEvento ("MiFuenteEventos")); } } //Una clase manejadora del evento MiRefME ha de disponer del método //ManejadorMiFuenteEventos public class MiManejadorEventos { public void ManejadorMiFuenteEventos (object fuente, ArgumentosEvento eventArgs) { System.Console .WriteLine ("Se ha lanzado un evento"); System.Console.WriteLine ("El origen es: " + eventArgs.fuenteEvento); } } public class Aplicacion { public static void Main(string [] args) { MiFuenteEventos MFE = new MiFuenteEventos (); MiManejadorEventos MME = new MiManejadorEventos (); //Suscripción al evento MFE.AñadirManejador (MME); System.Console.WriteLine ("Si desea lanzar el evento pulse Enter"); System.Console.ReadLine(); //Lanzamiento del evento MFE.LanzarEvento (); } }

Al ejecutarlo se mostrará la siguiente pantalla:

Figura 8.4 10/11

Marco Besteiro y Miguel Rodríguez

Delegates y Eventos

Si se pulsa la tecla ENTER se lanzará el evento:

Figura 8.5

11/11