Mot clé __event

Déclare un événement.

Remarque

Les attributs d’événement en C++ natif sont incompatibles avec C++ Standard. Ils ne sont pas compilés quand vous spécifiez le mode de conformité /permissive-.

Syntaxe

__event member-function-declarator ;
__event __interface interface-specifier ;
__event data-member-declarator ;

Notes

Le mot clé __event spécifique à Microsoft peut être appliqué à une déclaration de fonction membre, à une déclaration d’interface ou à une déclaration de membre de données. Toutefois, vous ne pouvez pas utiliser le mot clé __event pour qualifier un membre d’une classe imbriquée.

Selon que votre source et votre récepteur d'événements sont C++ natif, COM ou managé (.NET Framework), vous pouvez utiliser les constructions suivantes en tant qu'événements :

C++ natif	COM	Managé (.NET Framework)
fonction membre	-	method
-	interface	-
-	-	membre de données

Utilisez __hook dans un récepteur d’événements pour associer une fonction membre de gestionnaire à une fonction membre d’événement. Une fois que vous avez créé un événement avec le mot clé __event, tous les gestionnaires d’événements attachés à cet événement sont appelés par la suite quand l’événement est appelé.

Une déclaration de fonction membre __event ne peut pas avoir de définition. Dans la mesure où une définition est générée de manière implicite, la fonction membre d’événement peut être appelée comme s’il s’agissait d’une fonction membre ordinaire.

Remarque

Une classe ou un struct basé sur un modèle ne peut pas contenir d’événements.

Événements natifs

Les événements natifs sont des fonctions membres. Le type de retour est généralement HRESULT ou void, mais il peut s’agir de n’importe quel type intégral, notamment enum. Si un événement utilise un type de retour intégral, une condition d’erreur est définie quand un gestionnaire d’événements retourne une valeur différente de zéro. Dans ce cas, l’événement déclenché appelle les autres délégués.

// Examples of native C++ events:
__event void OnDblClick();
__event HRESULT OnClick(int* b, char* s);

Pour obtenir un exemple de code, consultez Gestion des événements en C++ natif.

Événements COM

Les événements COM sont des interfaces. Les paramètres d’une fonction membre dans une interface source d’événements doivent être des paramètres in, mais cette règle n’est pas appliquée de manière rigoureuse. En effet, un paramètre out n’est pas utile dans le cadre de la multidiffusion. Un avertissement de niveau 1 est émis si vous utilisez un paramètre out.

Le type de retour est généralement HRESULT ou void, mais il peut s’agir de n’importe quel type intégral, notamment enum. Quand un événement utilise un type de retour intégral, et qu’un gestionnaire d’événements retourne une valeur différente de zéro, il s’agit d’une condition d’erreur. L’événement déclenché abandonne les appels aux autres délégués. Le compilateur marque automatiquement une interface source d’événements en tant que source dans l’IDL généré.

Le mot clé __interface est toujours obligatoire après __event pour une source d’événements COM.

// Example of a COM event:
__event __interface IEvent1;

Pour obtenir un exemple de code, consultez Gestion des événements dans COM.

Événements managés

Pour plus d’informations sur l’écriture de code incluant des événements dans la nouvelle syntaxe, consultez event.

Les événements managés sont des membres de données ou des fonctions membres. Quand il est utilisé avec un événement, le type de retour d’un délégué doit être conforme à la Common Language Specification. Le type de retour du gestionnaire d'événements doit correspondre à celui du délégué. Pour plus d’informations sur les délégués, consultez Délégués et événements. Si un événement managé est un membre de données, son type doit être un pointeur vers un délégué.

Dans .NET Framework, vous pouvez traiter un membre de données comme s'il s'agissait d'une méthode (autrement dit, la méthode Invoke de son délégué correspondant). Pour ce faire, prédéfinissez le type délégué afin de déclarer un membre de données d’événement managé. En revanche, une méthode d’événement managé définit implicitement le délégué managé correspondant, s’il n’est pas déjà défini. Par exemple, vous pouvez déclarer une valeur d'événement telle que OnClick comme événement de la manière suivante :

// Examples of managed events:
__event ClickEventHandler* OnClick;  // data member as event
__event void OnClick(String* s);  // method as event

Quand vous déclarez implicitement un événement managé, vous pouvez spécifier les accesseurs add et remove qui sont appelés quand des gestionnaires d’événements sont ajoutés ou supprimés. Vous pouvez également définir la fonction membre qui appelle (déclenche) l’événement depuis l’extérieur de la classe.

Exemple : événements natifs

// EventHandling_Native_Event.cpp
// compile with: /c
[event_source(native)]
class CSource {
public:
   __event void MyEvent(int nValue);
};

Exemple : événements COM

// EventHandling_COM_Event.cpp
// compile with: /c
#define _ATL_ATTRIBUTES 1
#include <atlbase.h>
#include <atlcom.h>

[ module(dll, name="EventSource", uuid="6E46B59E-89C3-4c15-A6D8-B8A1CEC98830") ];

[ dual, uuid("00000000-0000-0000-0000-000000000002") ]
__interface IEventSource {
   [id(1)] HRESULT MyEvent();
};
[ coclass, uuid("00000000-0000-0000-0000-000000000003"),  event_source(com) ]
class CSource : public IEventSource {
public:
   __event __interface IEventSource;
   HRESULT FireEvent() {
      __raise MyEvent();
      return S_OK;
   }
};

Voir aussi

Mots clés
Gestion des événements
event_source
event_receiver
__hook
__unhook
__raise