81289929-Unidad1-2012

TOPICOS AVANZADOS DE PROGRAMACIÓN ITSL

Ing. María Gpe. Flores Luévanos Página 1

Unidad 1 Eventos

1.1. Tipos de eventos

1.2. Generación y propagación de eventos

1.3. Métodos de control de eventos

1.4. Creación de eventos.



Introducción

En términos sencillos, un delegado es un objeto que puede hacer referencia a un método,

es un tipo de dato definido por el usuario. Así, cuando creas un delegado, estas creando

un objeto que pueda almacenar una referencia a un método. Más aun, el método puede

ser invocado a través de esa referencia. Así, un delegado puede invocar el método al cual

hace referencia.

Una vez que un delegado hace referencia a un método, este puede ser invocado a través

del delegado. Además, el mismo delegado puede utilizarse para invocar diferentes

métodos, simplemente cambiando el método al que hace referencia. La principal ventaja

de un delegado es que te permite especificar la invocación a un método, pero el método

que de hecho se invoca se determina en tiempo de ejecución y no en tiempo de

compilación.

Un tipo delegado se declara utilizando la palabra clave delegate. El formato general de una declaración es el siguiente:

Delegate tipo_ret nombre(lista de parámetros);

¿Por qué Delegados?

En general los delegados son útiles por dos razones principales. La primera, como pronto veras, los delegados soportan eventos. La segunda, los delegados le dan a tu programa un medio para ejecutar métodos en tiempo de ejecución sin necesidad de especificar de qué método se trata en tiempo de compilación. Esta capacidad es muy útil cuando quieres crear una estructura que permita conectar componentes.

Características de los Delegados:

Los delegados tienen visibilidad.

Los delegados se crean con el operador new.

El constructor del delegado espera el nombre del método.

Los delegados pueden guardar más de un método.

La invocación de un delegado provoca la invocación de todos los métodos que almacena.



Ejemplo 1:

delegate double operacion(double parametro1, double parametro2); namespace Delegados2 { class Program { static void Main(string[] args) { // crea delegado delegado MetodoDel MD; string str; DelegadoTest dl = new DelegadoTest(); //crea un delegado usando un metodo de instancia Console.WriteLine("Leer cadena:"); str = Console.ReadLine(); MD = new MetodoDel(dl.ReemplazaEspacios); Console.WriteLine("Cadena resultante reemplaza espacios: "+MD(str)); MD = new MetodoDel(dl.EliminaEspacios); Console.WriteLine("Cadena resultante elimina espacios: " + MD(str)); MD = new MetodoDel(dl.InvierteCadena); Console.WriteLine("Cadena resultante invierte cadena: " + MD(str)); Console.ReadKey();

} } class Ejemplo { public double multiplica(double parametro1, double parametro2) { return parametro1 * parametro2; } public double divide(double parametro1, double parametro2) { return parametro1 /parametro2; } }



Ejemplo 2:

using System; using System.Collections.Generic; using System.Linq; using System.Text; //creacion del delegado delegate string MetodoDel(string srt); namespace Delegados { class Program { static void Main(string[] args) { // crea delegado delegado DelegadoTest dl = new DelegadoTest(); MetodoDel md =dl.ReemplazaEspacios; //crea un delegado usando un metodo de instancia string str; //invoca metodos a traves del delegado Console.WriteLine("Inserta cadena:"); string cad = Console.ReadLine(); str = md(cad); Console.WriteLine("Cadena resultante: "+str); MetodoDel EE = dl.EliminaEspacios; str = EE(cad); Console.WriteLine("Cadena resultante: " + str); MetodoDel IC = dl.InvierteCadena; str = IC(cad); Console.WriteLine("Cadena resultante: " + str); Console.ReadKey(); } } } class DelegadoTest { public string ReemplazaEspacios(string a) { Console.WriteLine("Reemplaza espacios con guiones");



return a.Replace(' ', '-'); } public string EliminaEspacios(string a) { string temp = ""; int i; Console.WriteLine("Elimina Espacios"); for (i = 0; i < a.Length; i++) { if (a[i] != ' ') { temp += a[i]; } } return temp; } public string InvierteCadena(string a) { string temp = ""; int i,j; Console.WriteLine("Invierte Cadena"); for (j = 0, i = a.Length - 1; i >= 0;i--,j++) { temp += a[i]; } return temp; } } }



1.1. Tipos de eventos.

Un evento es, en esencia, la notificación automática de que una acción ha ocurrido. Los

eventos son muy utilizados en el código aplicable al mundo real por que se les utiliza para

representar cosas como los golpes de tecla, clics del ratón, requisiciones para refrescar la

pantalla y los datos de entrantes. Los eventos se construyen sobre la base de los

delegados.

Un evento funciona así: un objeto que tiene interés en un evento registra un controlador

de controladores de eventos están representando por delegados. El controlador de

eventos responde al evento tomando las acciones apropiadas. Por ejemplo, un

controlador de evento para los golpes de teclas puede responder enviando el carácter

asociado con la tecla al monitor.

Los eventos son miembros de una clase y se declaran utilizando la palabra clave event. Su

formato general se muestra a continuación.

Event delegado-evento nombre-evento;

1.2. Generación y propagación de eventos

También llamado burbujeo de eventos, control personalizado, EventBubbler, demuestra

un simple caso de propagación de eventos. EventBubbler es un control compuesto que

contiene cuadros de texto, botones y un control de etiqueta. EventBubbler burbujas de los

eventos de comandos de los botones para el control de contenedor principal (sí mismo) y

expone como eventos de alto nivel.

1.3. Métodos de control de eventos

Cuando una acción sobre un componente genera un evento, se espera que suceda algo,

entendiendo por evento un mensaje que un objeto envía a algún otro objeto.

Componente Manejador de

eventos

Método (Respuesta

al evento)

Evento

Ocurrido



En la figura anterior puede ver que cuando un componente genera un evento, un

manejador de eventos vinculado con el componente se encarga de analizar que evento

ocurrió para responder al mismo ejecutando el método adecuado.

El manejador de eventos, que recibe también el nombre de delegado, es un objeto de la

clase EventHandler del espacio de nombres system que guarda una referencia al método

que responderá a ese evento. Este nombre recibe habitualmente el nombre de

controlador de eventos.

1.4. Creación de eventos.

La siguiente tabla muestra los eventos más comunes.



Siempre que queramos hacer uso de los eventos y delegados en C# deberemos:

1. Declarar el delegado. Para el mejor entendimiento debemos tener en cuenta que

el delegado no es otra cosa que una “clase (tipo de dato) especial”.

2. Declarar el evento de tipo del delegado. Si tenemos en cuenta que el delegado es

una clase, pues el evento es algo como una “propiedad especial” del tipo delegado.

3. Implementar el método X a suscribir. Este método deberá tener la misma “firma”

que el delegado.

4. Por último, para asociar o enlazar un método X al evento, accedemos a la

propiedad del objeto y le “adicionamos” el método. Teniendo en cuenta que el

método X tiene que cumplir con la firma del delegado.

Ejemplo 1:

class Program { static void Main(string[] args) { Salida s = new Salida("hola mundo"); s.ok += new EventHandler(Captura); s.Escribir(); Console.ReadKey(); }



static void Captura(object sender, EventArgs e) { string txt = (string)sender; Console.WriteLine(txt); } } class Salida { private string txt; public event EventHandler ok; public Salida(string texto) { this.txt = texto; } public void Escribir() { Console.WriteLine(txt); ok("Evento capturado", null); } }

81289929-Unidad1-2012

Documents

Transcript of 81289929-Unidad1-2012