event palabra clave (C++/CLI and C++/CX)
La event palabra clave declara un evento, que es una notificación a los suscriptores registrados (controladores de eventos) de que se ha producido algo de interés.
Todos los runtimes
C++/CX admite la declaración de un miembro de evento o un bloque de eventos. Un miembro de evento es una forma abreviada para declarar un bloque de eventos. De forma predeterminada, un miembro de evento declara las funciones add, remove, y raise declaradas explícitamente en un bloque de eventos. Para personalizar las funciones de un miembro de evento, declare un bloque de eventos en su lugar y, a continuación, reemplace las funciones que necesite.
Sintaxis
// event data member
modifier event delegate^ event_name;
// event block
modifier event delegate^ event_name
{
modifier return_value add(delegate^ name);
modifier void remove(delegate^ name);
modifier void raise(parameters);
}
Parámetros
modifier
Un modificador que se puede utilizar en la declaración de evento o un método de descriptor de acceso de eventos. Los valores posibles son static y virtual.
delegate
Delegado (delegate), cuya firma debe coincidir con la del controlador de eventos.
event_name
El nombre del evento.
return_value
El valor devuelto del método de descriptor de acceso del evento. Para que sea comprobable, el tipo de valor devuelto debe ser void.
parameters
(opcional) Parámetros para el método raise, que coincide con la firma del parámetro delegate.
Comentarios
Un evento es una asociación entre un delegado y un controlador de eventos. Un controlador de eventos es una función miembro que responde cuando se desencadena el evento. Permite a los clientes de cualquier clase registrar métodos que coincidan con la firma y el tipo de valor devuelto del delegado.
Hay dos tipos de declaraciones de eventos:
miembro de datos de evento
El compilador crea automáticamente almacenamiento para el evento en el formulario de un miembro del tipo delegate y crea funciones miembro internas add, remove, y raise . Un miembro de datos de evento debe declararse dentro de una clase. El tipo de valor devuelto del tipo de valor devuelto del delegado debe coincidir con el tipo de valor devuelto del controlador de eventos.
bloque de eventos
Un bloque de eventos le permite personalizar y declarar explícitamente el comportamiento de los métodos add, remove, y raise.
Puede utilizar operator += y operator -= para agregar y quitar un controlador de eventos, o llamar a los métodos add y remove explícitamente.
event es una palabra clave contextual. Para obtener más información, consulte Palabras clave contextuales.
Windows en tiempo de ejecución
Comentarios
Para obtener más información, consulte Eventos (C++/CX).
Para agregar y luego eliminar un controlador de eventos, guarde la estructura EventRegistrationToken que devuelve la operación add. Luego, en la operación remove, use la estructura EventRegistrationToken guardada para identificar el controlador de eventos para quitar.
Requisitos
Opción del compilador: /ZW
Common Language Runtime
La palabra clave event le permite declarar un evento. Un evento es una forma que tiene una clase para proporcionar notificaciones cuando ocurre algo de interés.
Sintaxis
// event data member
modifier event delegate^ event_name;
// event block
modifier event delegate^ event_name
{
modifier return_value add(delegate^ name);
modifier void remove(delegate^ name);
modifier void raise(parameters);
}
Parámetros
modifier
Un modificador que se puede utilizar en la declaración de evento o un método de descriptor de acceso de eventos. Los valores posibles son static y virtual.
delegate
Delegado (delegate), cuya firma debe coincidir con la del controlador de eventos.
event_name
El nombre del evento.
return_value
El valor devuelto del método de descriptor de acceso del evento. Para que sea comprobable, el tipo de valor devuelto debe ser void.
parameters
(opcional) Parámetros para el método raise, que coincide con la firma del parámetro delegate.
Comentarios
Un evento es una asociación entre un delegado y un controlador de eventos. Un controlador de eventos es una función miembro que responde cuando se desencadena el evento. Permite a los clientes de cualquier clase registrar métodos que coincidan con la firma y el tipo de valor devuelto del delegado subyacente.
El delegado puede tener uno o más métodos asociados. Estos métodos se llaman cuando su código indica que el evento ha ocurrido. Un evento de un programa puede estar disponible para otros programas diseñados para Common Language Runtime de .NET Framework .
Hay dos tipos de declaraciones de eventos:
miembros de datos de eventos
El compilador crea almacenamiento para eventos de miembros de datos como miembro del tipo delegate. Un miembro de datos de evento debe declararse dentro de una clase. También se conoce como un evento trivial. Consulte el ejemplo de código para obtener un ejemplo.
bloques de eventos
Los bloques de eventos le permiten personalizar el comportamiento de add, remove y raise mediante la implementación de métodos add, remove y raise. La firma de los métodos add, remove y raise debe coincidir con la firma del delegado. Los eventos del bloque de eventos no son miembros de datos. Cualquier uso como miembro de datos genera un error del compilador.
El tipo de valor devuelto del controlador de eventos debe coincidir con el del delegado.
En .NET Framework, puede tratar un miembro de datos como si se tratara de un método en sí mismo (es decir, el método Invoke de su delegado correspondiente). Para hacerlo, predefina el tipo de delegado para declarar un miembro de datos de eventos administrados. Por el contrario, un método de evento administrado define implícitamente el delegado administrado correspondiente si aún no está definido. Dispone de un ejemplo de código al final de este artículo.
Al declarar un evento administrado, puede especificar los descriptores de acceso add y remove que se llamarán cuando se agreguen o quiten controladores de eventos mediante los operadores += y -=. Los métodos add, remove y raise se pueden llamar explícitamente.
Se deben seguir los siguientes pasos para crear y usar eventos en Microsoft C++:
Cree o identifique a un delegado (delegate). Si está definiendo su propio evento, también debe asegurarse de que haya un delegado (delegate) para usar con la palabra clave
event. Si el evento está predefinido, en .NET Framework, por ejemplo, entonces los consumidores del evento solo necesitan conocer el nombre del delegado.Cree una clase que contenta:
Un evento creado desde el delegado (delegate).
(Opcional) Un método que compruebe que existe una instancia del delegado (delegate) declarado con la palabra clave
event. De lo contrario, esta lógica debe colocarse en el código que desencadena el evento.Métodos que llaman al evento. Estos métodos pueden ser reemplazos de alguna funcionalidad de la clase base.
Esta clase define el evento.
Defina una o más clases que conecte los métodos con el evento. Cada una de estas clases se asociará a uno o más métodos con el evento de la clase base.
Utilice el evento:
Cree un objeto de la clase que contenga la declaración del evento.
Cree un objeto de la clase que contenga la definición del evento.
Para obtener más información acerca de los eventos C++/CLI, consulte Eventos en una interfaz.
Requisitos
Opción del compilador: /clr
Ejemplos
El siguiente ejemplo de código muestra cómo declarar pares de delegados (delegates), eventos y controladores de eventos. Muestra cómo suscribirse (agregar), invocar y luego cancelar la suscripción (quitar) los controladores de eventos.
// mcppv2_events.cpp
// compile with: /clr
using namespace System;
// declare delegates
delegate void ClickEventHandler(int, double);
delegate void DblClickEventHandler(String^);
// class that defines events
ref class EventSource {
public:
event ClickEventHandler^ OnClick; // declare the event OnClick
event DblClickEventHandler^ OnDblClick; // declare OnDblClick
void FireEvents() {
// raises events
OnClick(7, 3.14159);
OnDblClick("Hello");
}
};
// class that defines methods that will called when event occurs
ref class EventReceiver {
public:
void OnMyClick(int i, double d) {
Console::WriteLine("OnClick: {0}, {1}", i, d);
}
void OnMyDblClick(String^ str) {
Console::WriteLine("OnDblClick: {0}", str);
}
};
int main() {
EventSource ^ MyEventSource = gcnew EventSource();
EventReceiver^ MyEventReceiver = gcnew EventReceiver();
// hook handler to event
MyEventSource->OnClick += gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
MyEventSource->OnDblClick += gcnew DblClickEventHandler(MyEventReceiver, &EventReceiver::OnMyDblClick);
// invoke events
MyEventSource->FireEvents();
// unhook handler to event
MyEventSource->OnClick -= gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
MyEventSource->OnDblClick -= gcnew DblClickEventHandler(MyEventReceiver, &EventReceiver::OnMyDblClick);
}
OnClick: 7, 3.14159
OnDblClick: Hello
El ejemplo de código siguiente se muestra la lógica usada para generar el método raise de un evento trivial. Si el evento tiene uno o varios suscriptores, al llamar al método raise de forma implícita o explícita se llamará al delegado. Si el tipo de valor devuelto de delegado (delegate) no es void y no hay suscriptores de eventos, el método raise devuelve el valor predeterminado para el tipo delegate. Si no hay suscriptores de eventos, la llamada al método raise regresa inmediatamente y no se genera ninguna excepción. Si el tipo de valor devuelto de delegado (delegate) no es void, se devuelve el tipo delegate.
// trivial_events.cpp
// compile with: /clr /c
using namespace System;
public delegate int Del();
public ref struct C {
int i;
event Del^ MyEvent;
void FireEvent() {
i = MyEvent();
}
};
ref struct EventReceiver {
int OnMyClick() { return 0; }
};
int main() {
C c;
c.i = 687;
c.FireEvent();
Console::WriteLine(c.i);
c.i = 688;
EventReceiver^ MyEventReceiver = gcnew EventReceiver();
c.MyEvent += gcnew Del(MyEventReceiver, &EventReceiver::OnMyClick);
Console::WriteLine(c.i);
}
0
688