Eventos (C# y Java)
Actualización: noviembre 2007
Un evento constituye un método para que una clase notifique a los usuarios de un objeto que algo interesante sucede al objeto, como, por ejemplo, que se ha hecho clic en un control de una interfaz gráfica de usuario. Esta notificación se denomina provocar un evento. El objeto que provoca un evento se conoce como el origen o remitente del evento.
A diferencia del control de eventos en Java, que se realiza mediante la implementación de clases de agente de escucha personalizadas, los programadores de C# pueden utilizar delegados para el control de eventos. Un delegado es un tipo que encapsula un método. Una vez que un delegado se inicializa con un método, éste se comporta exactamente como el método y puede invocarse con el operador (). Es similar a un puntero a función de C++, pero posee seguridad de tipos.
El delegado se puede utilizar como cualquier otro método, con parámetros y un valor devuelto, como en este ejemplo:
public delegate int ReturnResult(int x, int y);
Para obtener más información sobre los delegados, vea Delegados (Guía de programación de C#).
Los eventos, al igual que los métodos, tienen una firma que incluye un nombre y una lista de parámetros. Esta firma se define mediante un tipo delegado, por ejemplo:
public delegate void MyEventHandler(object sender, System.EventArgs e);
En la programación de la interfaz de usuario de Windows, es común hacer que el primer parámetro se refiera al origen del evento y que el segundo parámetro sea el objeto que contiene los datos relacionados con el evento. Sin embargo, el lenguaje C# no requiere ni exige este diseño; una firma de evento puede ser la misma que cualquier firma de delegado válida, siempre y cuando devuelva un valor void.
Un evento se puede declarar utilizando la palabra clave event como este ejemplo:
public event MyEventHandler TriggerIt;
Para desencadenar el evento, defina el método que se va a invocar cuando el evento se provoca como en este ejemplo:
public void Trigger()
{
TriggerIt();
}
Para provocar un evento, llame al delegado y pase los parámetros relacionados con el evento. A continuación, el delegado llamará a todos los controladores que se hayan agregado al evento. Cada evento puede tener más de un controlador asignado para recibir el evento. En este caso, el evento llama automáticamente a cada receptor. Provocar un evento requiere sólo una llamada al evento sin tener en cuenta el número de receptores.
Si desea que una clase reciba un evento, suscríbala a ese evento agregándole el delegado mediante el operador +=, por ejemplo:
myEvent.TriggerIt += myEvent.MyMethod;
Para cancelar la suscripción a un evento, quite el delegado del evento utilizando al operador -=, por ejemplo:
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod);
Para obtener más información sobre eventos, vea Eventos (Guía de programación de C#).
.gif "Nota") Nota: |
|---|
En C# 2.0, los delegados pueden encapsular métodos con nombre y métodos anónimos. Para obtener más información sobre los métodos anónimos, vea Métodos anónimos (Guía de programación de C#). |
Ejemplo
Descripción
El ejemplo siguiente define un evento con tres métodos asociados a él. Cuando se desencadena el evento, los métodos se ejecutan. A continuación, se quita un método del evento y se desencadena de nuevo el evento.
Código
// Declare the delegate handler for the event:
public delegate void MyEventHandler();
class TestEvent
{
// Declare the event implemented by MyEventHandler.
public event MyEventHandler TriggerIt;
// Declare a method that triggers the event:
public void Trigger()
{
TriggerIt();
}
// Declare the methods that will be associated with the TriggerIt event.
public void MyMethod1()
{
System.Console.WriteLine("Hello!");
}
public void MyMethod2()
{
System.Console.WriteLine("Hello again!");
}
public void MyMethod3()
{
System.Console.WriteLine("Good-bye!");
}
static void Main()
{
// Create an instance of the TestEvent class.
TestEvent myEvent = new TestEvent();
// Subscribe to the event by associating the handlers with the events:
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod1);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod2);
myEvent.TriggerIt += new MyEventHandler(myEvent.MyMethod3);
// Trigger the event:
myEvent.Trigger();
// Unsuscribe from the the event by removing the handler from the event:
myEvent.TriggerIt -= new MyEventHandler(myEvent.MyMethod2);
System.Console.WriteLine("\"Hello again!\" unsubscribed from the event.");
// Trigger the new event:
myEvent.Trigger();
}
}
Resultado
Hello!
Hello again!
Good-bye!
"Hello again!" unsubscribed from the event.
Hello!
Good-bye!