Gestione degli eventi in C++ nativo

In gestione degli eventi C++ nativa, è stato impostato un'origine eventi e utilizzare un ricevitore di eventi un event_source e event_receiver attributi, rispettivamente, specificando type=native.Questi attributi consentono le classi a cui si applica per generare gli eventi e gestire eventi in un oggetto nativo, il contesto non COM.

Dichiarazione di eventi

in una classe di origine evento, utilizzare __event parola chiave in una dichiarazione di metodo per dichiarare il metodo come evento.Assicurarsi dichiarare il metodo, ma non definirlo; a tale scopo genererà un errore del compilatore, poiché il compilatore definisce il metodo in modo implicito quando viene trasformato un evento.Gli eventi nativi siano metodi con zero o più parametri.Il tipo restituito può essere void o un tipo integrale.

Definizione di gestori degli eventi

In una classe del ricevitore di eventi, definire i gestori eventi, ovvero metodi con firme (tipi restituiti, convenzioni di chiamata e argomenti) che corrispondono l'evento che gestiranno.

Hook dei gestori eventi agli eventi

Inoltre in una classe del ricevitore di eventi, utilizzare la funzione intrinseca __hook per associare gli eventi ai gestori eventi e __unhook per dissociare gli eventi dai gestori eventi.È possibile associare più eventi a un gestore eventi, o a diversi gestori eventi a un evento.

eventi di infornamento

Per generare un evento, è sufficiente chiamare il metodo dichiarato come classe di origine evento dell'.Se i gestori sono stati agganciati all'evento, i gestori verranno chiamati.

Il codice nativo di evento C++

Nell'esempio seguente viene illustrato come generare un evento in C++ nativo.Per compilare ed eseguire l'esempio, fare riferimento ai commenti nel codice.

Esempio

Codice

// 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.

Vedere anche

Riferimenti

Gestione degli eventi