Obsługa zdarzeń w natywnym kodzie C++

  • Artykuł

W natywnej obsłudze zdarzeń języka C++ należy skonfigurować źródło zdarzeń i odbiornik zdarzeń przy użyciu atrybutów event_source i event_receiver , odpowiednio type=nativeokreślając wartość . Te atrybuty umożliwiają stosowanie klas do wyzwalania zdarzeń i obsługi zdarzeń w natywnym kontekście innych niż COM.

Uwaga

Atrybuty zdarzeń w natywnym języku C++ są niezgodne z językiem Standard C++. Nie są one kompilowane podczas określania /permissive- trybu zgodności.

Deklarowanie zdarzeń

W klasie źródła zdarzeń użyj __event słowa kluczowego w deklaracji metody, aby zadeklarować metodę jako zdarzenie. Pamiętaj, aby zadeklarować metodę, ale nie zdefiniuj jej. Jeśli tak, generuje błąd kompilatora, ponieważ kompilator definiuje metodę niejawnie podczas tworzenia zdarzenia. Zdarzenia natywne mogą być metodami z zerowymi lub większą większa większa liczba parametrów. Typ zwracany może być void lub dowolny typ całkowity.

Definiowanie programów obsługi zdarzeń

W klasie odbiorcy zdarzeń definiuje się programy obsługi zdarzeń. Programy obsługi zdarzeń to metody z podpisami (typy zwracane, konwencje wywoływania i argumenty), które odpowiadają zdarzeniu, które będą obsługiwane.

Podłączanie programów obsługi zdarzeń do zdarzeń

Ponadto w klasie odbiorcy zdarzeń funkcja wewnętrzna __hook służy do kojarzenia zdarzeń z procedurami obsługi zdarzeń i __unhook usuwanie skojarzenia zdarzeń z programów obsługi zdarzeń. Można podłączyć kilka zdarzeń do programu obsługi zdarzeń lub kilka programów obsługi zdarzeń do zdarzenia.

Wyzwalanie zdarzeń

Aby uruchomić zdarzenie, wywołaj metodę zadeklarowaną jako zdarzenie w klasie źródła zdarzeń. Jeśli programy obsługi zostały podłączone do zdarzenia, zostaną wywołane programy obsługi.

Kod zdarzenia natywnego języka C++

W poniższym przykładzie pokazano, jak uruchomić zdarzenie w natywnym języku C++. Aby skompilować i uruchomić przykład, zobacz komentarze w kodzie. Aby skompilować kod w środowisku IDE programu Visual Studio, sprawdź, czy /permissive- opcja jest wyłączona.

Przykład

Kod

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

Wynik

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

Zobacz też

Obsługa zdarzeń