Control de eventos en C++ nativo

En el control de eventos de C++ nativo, puede configurar un origen de eventos y un receptor de eventos mediante los atributos event_source y event_receiver, respectivamente, que especifican type=native. Estos atributos permiten a las clases a las que se aplican desencadenar eventos y eventos de control en un contexto nativo, no COM.

Nota:

Los atributos de eventos en C++ nativo no son compatibles con C++ estándar. No se compilan al especificar el modo de conformidad /permissive-.

Declaración de eventos

En una clase de origen de eventos, use la palabra clave __event en una declaración de método para declarar el método como un evento. Asegúrese de declarar el método, pero no lo defina. Si lo hace, genera un error del compilador, ya que este define el método implícitamente cuando se convierte en un evento. Los eventos nativos pueden ser métodos con cero o más parámetros. El tipo de valor devuelto puede ser void o cualquier tipo entero.

Definición de controladores de eventos

Puede definir controladores de eventos en una clase receptora de eventos. Los controladores de eventos son métodos con signaturas (tipos de valor devuelto, convenciones de llamada y argumentos) que coinciden con el evento que van a controlar.

Enlazar controladores de eventos a eventos

También en una clase receptora de eventos, se usa la función intrínseca __hook para asociar eventos a controladores de eventos y __unhook para desasociar eventos de los controladores de eventos. Puede enlazar varios eventos a un controlador de eventos o varios controladores de eventos a un evento.

Desencadenar eventos

Para desencadenar un evento, llame al método declarado como un evento en la clase del origen de eventos. Si se han enlazado controladores al evento, se llamará a los controladores.

Código de evento de C++ nativo

En el ejemplo siguiente se muestra cómo activar un evento en C++ nativo. Para compilar y ejecutar el ejemplo, consulte los comentarios del código. Para compilar el código en el IDE de Visual Studio, compruebe que la opción /permissive- está desactivada.

Ejemplo

Código

// evh_native.cpp
// compile by using: cl /EHsc /W3 evh_native.cpp
#include <stdio.h>

[event_source(native)]
class CSource {
public:
   __event void MyEvent(int nValue);
};

[event_receiver(native)]
class CReceiver {
public:
   void MyHandler1(int nValue) {
      printf_s("MyHandler1 was called with value %d.\n", nValue);
   }

   void MyHandler2(int nValue) {
      printf_s("MyHandler2 was called with value %d.\n", nValue);
   }

   void hookEvent(CSource* pSource) {
      __hook(&CSource::MyEvent, pSource, &CReceiver::MyHandler1);
      __hook(&CSource::MyEvent, pSource, &CReceiver::MyHandler2);
   }

   void unhookEvent(CSource* pSource) {
      __unhook(&CSource::MyEvent, pSource, &CReceiver::MyHandler1);
      __unhook(&CSource::MyEvent, pSource, &CReceiver::MyHandler2);
   }
};

int main() {
   CSource source;
   CReceiver receiver;

   receiver.hookEvent(&source);
   __raise source.MyEvent(123);
   receiver.unhookEvent(&source);
}

Resultados

MyHandler2 was called with value 123.
MyHandler1 was called with value 123.

Consulte también

Control de eventos