Control de eventos en C++ nativoEvent handling in native C++

En el control de eventos de C++ nativo, se configura un origen de eventos y un receptor de eventos mediante los atributos event_source y event_receiver , respectivamente, que especifican type = native .In native C++ event handling, you set up an event source and event receiver using the event_source and event_receiver attributes, respectively, specifying type=native. Estos atributos permiten que las clases a las que se aplican desencadenen eventos y controlen eventos en un contexto no COM nativo.These attributes allow the classes they're applied on to fire events and handle events in a native, non-COM context.

Nota

Los atributos de evento en C++ nativo son incompatibles con C++ estándar.Event attributes in native C++ are incompatible with Standard C++. No se compilan cuando se especifica el /permissive- modo de cumplimiento.They don't compile when you specify /permissive- conformance mode.

Declarar eventosDeclaring events

En una clase de origen de eventos, use la __event palabra clave en una declaración de método para declarar el método como un evento.In an event source class, use the __event keyword on a method declaration to declare the method as an event. Asegúrese de declarar el método, pero no lo defina.Make sure to declare the method, but don't define it. Si lo hace, genera un error del compilador, porque el compilador define el método implícitamente cuando se convierte en un evento.If you do, it generates a compiler error, because the compiler defines the method implicitly when it's made into an event. Los eventos nativos pueden ser métodos con cero o más parámetros.Native events can be methods with zero or more parameters. El tipo de valor devuelto puede ser void o cualquier tipo entero.The return type can be void or any integral type.

Definir controladores de eventosDefining event handlers

En una clase de receptor de eventos, se definen los controladores de eventos.In an event receiver class, you define event handlers. Los controladores de eventos son métodos con firmas (tipos de valor devuelto, convenciones de llamada y argumentos) que coinciden con el evento que controlarán.Event handlers are methods with signatures (return types, calling conventions, and arguments) that match the event that they'll handle.

Enlazar controladores de eventos a eventosHooking event handlers to events

Además, 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 desasociar eventos de los controladores de eventos.Also in an event receiver class, you use the intrinsic function __hook to associate events with event handlers and __unhook to disassociate events from event handlers. Puede enlazar varios eventos a un controlador de eventos o varios controladores de eventos a un evento.You can hook several events to an event handler, or several event handlers to an event.

Desencadenar eventosFiring events

Para desencadenar un evento, llame al método declarado como un evento en la clase de origen del evento.To fire an event, call the method declared as an event in the event source class. Si se han enlazado controladores al evento, se llamará a los controladores.If handlers have been hooked to the event, the handlers will be called.

Código de evento de C++ nativoNative C++ event code

En el ejemplo siguiente se muestra cómo activar un evento en C++ nativo.The following example shows how to fire an event in native C++. Para compilar y ejecutar el ejemplo, consulte los comentarios del código.To compile and run the example, refer to the comments in the code. Para compilar el código en el IDE de Visual Studio, compruebe que la opción está desactivada /permissive- .To build the code in the Visual Studio IDE, verify that the /permissive- option is turned off.

EjemploExample

CódigoCode

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

SalidaOutput

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

Vea tambiénSee also

Control de eventosEvent handling