Tratamento de eventos em C++ nativo

A manipulação de eventos nativos do C++, você configura um destinatário e um receptor de eventos usando os atributos event_source e event_receiver, respectivamente, especificando type=native. Esses atributos as permitem que as classes às quais eles são aplicados disparem eventos e manipulem eventos em um contexto nativo, e não de COM.

Observação

Os atributos de evento em C++ nativo são incompatíveis com o C++ Standard. Eles não são compilados quando você especifica o modo de conformidade /permissive-.

Declarando eventos

Em uma classe da origem do evento, use a palavra-chave __event em uma declaração do método para declarar o método como um evento. Declare o método, mas não o defina. Se você fizer isso, ele gerará um erro do compilador, pois o compilador define o método implicitamente quando ele é transformado em um evento. Os eventos nativos podem ser métodos com zero ou mais parâmetros. O tipo de retorno pode ser void ou qualquer tipo integral.

Como definir manipuladores de eventos

Em uma classe receptora de eventos, você define manipuladores de eventos. Manipuladores de eventos são métodos com assinaturas (tipos de retorno, convenções de chamada e argumentos) que correspondem ao evento que eles manipularão.

Como vincular manipuladores de eventos a eventos

Também em uma classe de receptor de evento, você usa a função intrínseca __hook para associar eventos a manipuladores de eventos e __unhook para desassociar eventos de manipuladores de eventos. Você pode vincular diversos eventos a um manipulador ou vincular diversos manipuladores a um evento.

Como disparar eventos

Para disparar um evento, chame o método declarado como um evento na classe da origem do evento. Se houver manipuladores vinculados ao evento, eles serão chamados.

Código nativo do evento C++

O exemplo de código a seguir mostra como disparar um evento no C++ nativo. Para compilar e executar o exemplo, consulte os comentários no código. Para criar o código no IDE do Visual Studio, verifique se a opção /permissive- está desativada.

Exemplo

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

Saída

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

Confira também

Manipulação de eventos