Manipulação de eventos no C++ nativo

Manipulação de eventos de C++ nativa, você configurará um receptor de eventos e a fonte de eventos usando o event_source e event_receiver atributos, respectivamente, especificando type=native.Esses atributos permitem que as classes para o qual são aplicadas para disparar eventos e manipular eventos em um contexto nativo, não COM.

Declarando Eventos

Em uma classe de origem do evento, use o _ _ Event palavra-chave em uma declaração de método para declarar o método como um evento.Certifique-se de declarar o método, mas não definem-lo. Para fazer isso irá gerar um erro do compilador, como o compilador define o método implicitamente quando ela é feita em um evento.Eventos nativos podem ser métodos com zero ou mais parâmetros.O tipo de retorno pode ser anulado ou integrante de qualquer tipo.

Definindo manipuladores de eventos

Em uma classe de receptor de evento, você pode definir manipuladores de eventos, que são os métodos com assinaturas (tipos de retorno, convenções e argumentos de chamada) que correspondem ao evento que manipulará por eles.

Manipuladores de eventos para eventos de gancho

Também em uma classe de receptor de evento, você utilizar a função intrínseca __hook para associar eventos a manipuladores de eventos e __unhook para dissociar eventos de manipuladores de eventos.Você pode conectar vários eventos para um manipulador de eventos ou vários manipuladores de eventos para um evento.

Eventos de acionamento.

Disparar um evento, basta chame o método declarado como um evento de classe de origem além de eventos.Se manipuladores tiverem sido enganchados ao evento, o manipulador será chamado.

Código de evento de C++ nativo

O exemplo a seguir mostra como disparar um evento em C++ nativo.Para compilar e executar o exemplo, consulte os comentários no código.

Exemplo

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

Saída

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

Consulte também

Referência

Manipulação de eventos