event Schlüsselwort (C++/CLI und C++/CX)

Das event Schlüsselwort deklariert ein Ereignis, bei dem es sich um eine Benachrichtigung an registrierte Abonnenten (Ereignishandler) handelt, die von Interesse sind.

Alle Laufzeiten

C++/CX unterstützt das Deklarieren eines Ereignismembers oder eines Ereignisblocks. Ein Ereignismember ist die Kurzschreibweise für das Deklarieren eines Event-Blocks. Standardmäßig deklariert ein Ereignismember die Funktionen add, remove und raise, die explizit in einem Event-Block deklariert werden. Um die Funktionen in einem Ereignismember anzupassen, deklarieren Sie stattdessen einen Event-Block und überschreiben Sie dann die Funktionen, die Sie benötigen.

Syntax

// event data member
modifier event delegate^ event_name;

// event block
modifier event delegate^ event_name
{
   modifier return_value add(delegate^ name);
   modifier void remove(delegate^ name);
   modifier void raise(parameters);
}

Parameter

modifier
Ein Modifizierer, der entweder für die Ereignisdeklaration oder eine Ereigniszugriffsmethode verwendet werden kann. Mögliche Werte sind static und virtual.

delegate
Der Delegat, mit dessen Signatur der Ereignishandler übereinstimmen muss.

event_name
Der Name des Ereignisses.

return_value
Der Rückgabewert der Ereigniszugriffsmethode. Um überprüfbar zu sein, muss der Rückgabetyp sein void.

parameters
(Optional) Parameter für die raise-Methode, die mit der Signatur des Parameters delegate übereinstimmen.

Hinweise

Ein Ereignis ist eine Zuordnung zwischen einem Delegaten und einem Ereignishandler. Ein Ereignishandler ist eine Memberfunktion, die antwortet, wenn das Ereignis ausgelöst wird. Es ermöglicht Clients von jeder Klasse, Methoden zu registrieren, die der Signatur entsprechen, und den Rückgabetyp des Delegaten.

Es gibt zwei Arten von Ereignisdeklarationen:

event data member (Ereignisdatenmember)
Der Compiler erstellt automatisch Speicherplatz für das Ereignis in Form eines Members des Delegattyps und erstellt interne Memberfunktionen add, remove und raise. Ein Ereignisdatenmember muss innerhalb einer Klasse deklariert werden. Der Rückgabetyp des Rückgabetyps des Delegaten muss dem Rückgabetyp des Ereignishandlers entsprechen.

event block (Ereignisblock)
Ein Event-Block ermöglicht es Ihnen, das Verhalten der Methoden add, remove und raise explizit zu deklarieren und anzupassen.

Sie können einen Ereignishandler verwenden operator += und operator -= entfernen oder die add methoden remove explizit aufrufen.

event ist ein kontextbezogenes Schlüsselwort. Weitere Informationen finden Sie unter Kontextabhängige Schlüsselwörter.

Windows-Runtime

Hinweise

Weitere Informationen finden Sie unter Ereignisse (C++/CX).

Wenn Sie einen Ereignishandler hinzufügen und später entfernen möchten, speichern Sie die EventRegistrationToken Struktur, die add vom Vorgang zurückgegeben wird. Verwenden Sie dann im remove Vorgang die gespeicherte EventRegistrationToken Struktur, um den zu entfernenden Ereignishandler zu identifizieren.

Anforderungen

Compileroption: /ZW

Übersicht: Common Language Runtime (CLR)

Mit dem event-Schlüsselwort können Sie ein Ereignis deklarieren. Ein Ereignis ist eine Methode, anhand derer eine Klasse Benachrichtigungen übermitteln kann, wenn etwas von Interesse geschieht.

Syntax

// event data member
modifier event delegate^ event_name;

// event block
modifier event delegate^ event_name
{
   modifier return_value add(delegate^ name);
   modifier void remove(delegate^ name);
   modifier void raise(parameters);
}

Parameter

modifier
Ein Modifizierer, der entweder für die Ereignisdeklaration oder eine Ereigniszugriffsmethode verwendet werden kann. Mögliche Werte sind static und virtual.

delegate
Der Delegat, mit dessen Signatur der Ereignishandler übereinstimmen muss.

event_name
Der Name des Ereignisses.

return_value
Der Rückgabewert der Ereigniszugriffsmethode. Um überprüfbar zu sein, muss der Rückgabetyp sein void.

parameters
(Optional) Parameter für die raise-Methode, die mit der Signatur des Parameters delegate übereinstimmen.

Hinweise

Ein Ereignis ist eine Zuordnung zwischen einem Delegaten und einem Ereignishandler. Ein Ereignishandler ist eine Memberfunktion, die antwortet, wenn das Ereignis ausgelöst wird. Es ermöglicht Clients von jeder Klasse, Methoden zu registrieren, die der Signatur entsprechen, und den Rückgabetyp des zugrunde liegenden Delegaten.

Der Delegat kann über eine oder mehrere zugeordnete Methoden verfügen. Diese Methoden werden aufgerufen, wenn Ihr Code angibt, dass das Ereignis aufgetreten ist. Ein Ereignis in einem Programm kann für andere Programme verfügbar gemacht werden, die auf die .NET Framework Common Language Runtime abzielen.

Es gibt zwei Arten von Ereignisdeklarationen:

event data members
Der Compiler erstellt Speicher für Datenelementereignisse als Mitglied des Delegatentyps. Ein Ereignisdatenmember muss innerhalb einer Klasse deklariert werden. Es wird auch als triviales Ereignis bezeichnet. Ein Beispiel finden Sie im Codebeispiel.

event blocks
Mithilfe von Ereignisblöcken können Sie das Verhalten der addMethoden removeraise und Methoden anpassen, indem addSie Methoden removeimplementieren.raise Die Signatur des Delegierten und raise der addremoveMethoden muss mit der Signatur des Delegaten übereinstimmen. Ereignisblockereignisse sind keine Datenmmber. Jede Verwendung als Datenmememm generiert einen Compilerfehler.

Der Rückgabetyp des Ereignishandlers muss dem Rückgabetyp des Delegaten entsprechen.

In .NET Framework können Sie einen Datenmember behandeln, als wäre er eine Methode selbst (d. h. die Invoke-Methode des entsprechenden Delegaten). Um dies zu tun, müssen Sie den Delegattyp vordefinieren, um einen verwalteten Ereignisdatenmember zu deklarieren. Im Gegensatz dazu definiert eine verwaltete Ereignismethode implizit den entsprechenden verwalteten Delegaten, sofern er noch nicht definiert ist. Ein Beispiel finden Sie im Codebeispiel am Ende dieses Artikels.

Beim Deklarieren eines verwalteten Ereignisses können Sie angeben und remove Accessoren angebenadd, die aufgerufen werden, wenn Ereignishandler mithilfe von Operatoren += -=hinzugefügt oder entfernt werden. Die addMethoden und raise Methoden removekönnen explizit aufgerufen werden.

Die folgenden Schritte müssen ausgeführt werden, um Ereignisse in Microsoft C++ zu erstellen und zu verwenden:

1. Erstellen oder Identifizieren eines Delegaten. Wenn Sie Ihr eigenes Ereignis definieren, müssen Sie auch sicherstellen, dass es einen Delegaten gibt, der mit dem event Schlüsselwort verwendet werden soll. Wenn das Ereignis vordefiniert ist, beispielsweise in .NET Framework, müssen die Consumer des Ereignisses lediglich den Namen des Delegaten kennen.

2. Erstellen Sie eine Klasse, die Folgendes enthält:

   • Ein aus dem Delegaten erstelltes Ereignis.

   • (Optional) Eine Methode, die überprüft, ob eine Instanz des mit dem event Schlüsselwort deklarierten Delegaten vorhanden ist. Andernfalls muss diese Logik im Code eingefügt werden, durch den das Ereignis ausgelöst wird.

   • Methoden, die das Ereignis aufrufen. Diese Methoden können Überschreibungen von Funktionen der Basisklasse sein.

   Diese Klasse definiert das Ereignis.

3. Definieren Sie eine oder mehrere Klassen, die Methoden mit dem Ereignis verbinden. Jede dieser Klassen ordnet dem Ereignis in der Basisklasse eine oder mehrere Methoden zu.

4. Verwenden Sie das Ereignis:

   • Erstellen Sie ein Objekt der Klasse, die die Ereignisdeklaration enthält.

   • Erstellen Sie ein Objekt der Klasse, die die Ereignisdefinition enthält.

Weitere Informationen zu C++/CLI-Ereignissen finden Sie unter "Ereignisse in einer Schnittstelle".

Anforderungen

Compileroption: /clr

Beispiele

Im folgenden Codebeispiel wird das Deklarieren von Stellvertretungen, Ereignissen und Ereignishandlern veranschaulicht. Es zeigt, wie Sie die Ereignishandler abonnieren (hinzufügen), aufrufen und dann kündigen (entfernen).

// mcppv2_events.cpp
// compile with: /clr
using namespace System;

// declare delegates
delegate void ClickEventHandler(int, double);
delegate void DblClickEventHandler(String^);

// class that defines events
ref class EventSource {
public:
   event ClickEventHandler^ OnClick;   // declare the event OnClick
   event DblClickEventHandler^ OnDblClick;   // declare OnDblClick

   void FireEvents() {
      // raises events
      OnClick(7, 3.14159);
      OnDblClick("Hello");
   }
};

// class that defines methods that will called when event occurs
ref class EventReceiver {
public:
   void OnMyClick(int i, double d) {
      Console::WriteLine("OnClick: {0}, {1}", i, d);
   }

   void OnMyDblClick(String^ str) {
      Console::WriteLine("OnDblClick: {0}", str);
   }
};

int main() {
   EventSource ^ MyEventSource = gcnew EventSource();
   EventReceiver^ MyEventReceiver = gcnew EventReceiver();

   // hook handler to event
   MyEventSource->OnClick += gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
   MyEventSource->OnDblClick += gcnew DblClickEventHandler(MyEventReceiver, &EventReceiver::OnMyDblClick);

   // invoke events
   MyEventSource->FireEvents();

   // unhook handler to event
   MyEventSource->OnClick -= gcnew ClickEventHandler(MyEventReceiver, &EventReceiver::OnMyClick);
   MyEventSource->OnDblClick -= gcnew DblClickEventHandler(MyEventReceiver, &EventReceiver::OnMyDblClick);
}

OnClick: 7, 3.14159

OnDblClick: Hello

Im folgenden Codebeispiel wird die Logik veranschaulicht, mit der die raise Methode eines trivialen Ereignisses generiert wird. Wenn mindestens ein Abonnent für das Ereignis vorhanden ist, führt der Aufruf der raise-Methode implizit oder explizit zum Aufruf des Delegaten. Wenn der Rückgabetyp des Delegaten nicht void vorhanden ist und keine Ereignisabonnenten vorhanden sind, gibt die raise Methode den Standardwert für den Delegatentyp zurück. Wenn keine Ereignisabonnenten vorhanden sind, wird das Aufrufen der raise Methode sofort zurückgegeben, und es wird keine Ausnahme ausgelöst. Wenn der Rückgabetyp der Stellvertretung nicht voidlautet, wird der Delegattyp zurückgegeben.

// trivial_events.cpp
// compile with: /clr /c
using namespace System;
public delegate int Del();
public ref struct C {
   int i;
   event Del^ MyEvent;

   void FireEvent() {
      i = MyEvent();
   }
};

ref struct EventReceiver {
   int OnMyClick() { return 0; }
};

int main() {
   C c;
   c.i = 687;

   c.FireEvent();
   Console::WriteLine(c.i);
   c.i = 688;

   EventReceiver^ MyEventReceiver = gcnew EventReceiver();
   c.MyEvent += gcnew Del(MyEventReceiver, &EventReceiver::OnMyClick);
   Console::WriteLine(c.i);
}

0

688

Siehe auch

Komponentenerweiterungen für .NET und UWP