Ereignisbehandlung in systemeigenem C++

In systemeigenem C++-Ereignisbehandlung installierten Sie einen Ereignisquellen- und Ereignisempfänger mithilfe der event_source und event_receiver-Attribute type=nativeerzeugt haben.Diese Attribute ermöglichen die Klasse, auf die sie angewendet werden, um Ereignisse und Behandeln von Ereignissen in einem systemeigenen Code ohne Kontext auszulösen.

Deklarieren von Ereignissen

In einer Ereignisquellen - Klasse verwenden Sie das __event-Schlüsselwort in einer Methodendeklaration, um die Methode als ein Ereignis zu deklarieren.Ersetzen Sie die Methode deklariert, aber nicht definiert. dazu zu generiert einen Compilerfehler, da der Compiler die Methode implizit definiert, wenn er in ein Ereignis ausgeführt wird.Systemeigene Ereignisse können Methoden mit null oder mehr Parameter haben.Der Rückgabetyp kann ungültig oder ein ganzzahliger Typ sein.

Definieren von Ereignishandlern

In einer Ereignisempfänger Klasse definieren Sie Ereignishandler, die Methoden mit Signaturen (Rückgabetypen, Argumente und Aufrufkonventionen), die Übereinstimmung, das sie sind das Ereignis behandelt.

Ereignishandler für Ereignisse haken

Auch in einer Ereignisempfänger Klasse, verwenden Sie die systeminterne Funktion, um __hook-Ereignissen mit Ereignishandlern und __unhook zuzuordnen, um Ereignisse von den Ereignishandlern zu trennen.Sie können mehrere Ereignisse zu verknüpfen oder einem Ereignishandler zu einigen Ereignishandlern für ein Ereignis.

Auslösen-Ereignisse

Um ein Ereignis auszulösen, rufen Sie einfach die Methode deklariert im Ereignisprotokoll als Quelle des Ereignisses Klasse.Wenn Handler an das Ereignis gehakt wurden, werden die Handler aufgerufen.

Eingeboren-C++-Ereigniscode

Im folgenden Beispiel wird gezeigt, wie ein Ereignis in systemeigenem C++ auslöst.Um das Beispiel zu kompilieren und auszuführen, finden Sie in den Kommentaren im Code an.

Beispiel

Code

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

Siehe auch

Referenz

Ereignisbehandlung