Control de eventos en C++ nativo

En el control de eventos de C++ nativo, configurará un receptor del origen de eventos y eventos mediante los atributos de event_source y de event_receiver , respectivamente, especificando type=native.Estos atributos permiten las clases a las que se aplican para desencadenar eventos y eventos de identificador en un natural, contexto distinto de COM.

Declarar eventos

En una clase de origen de eventos, utilice la palabra clave de __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; para hacerlo generará un error del compilador, porque el compilador define el método implícita cuando se crea en un evento.Eventos nativos pueden ser métodos con cero o más parámetros.El tipo de valor devuelto puede ser cualquier entero tipo void o.

Definir controladores de eventos

En una clase de receptor de eventos, se definen los controladores de eventos, que son métodos con firmas (tipos de valor devuelto, convenciones de llamada, y argumentos) que coinciden con el evento que controlará.

Enlazar controladores de eventos a eventos

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

Eventos bounce

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

Código de evento de C++ nativo

El ejemplo siguiente se muestra cómo activar un evento en C++ nativo.Para compilar y ejecutar el ejemplo, vea los comentarios del código.

Ejemplo

Código

// 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);
}

Output

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

Vea también

Referencia

Control de eventos