__event
Déclare un événement.
__event method-declarator;
__event __interface interface-specifier;
__event member-declarator;
Notes
Le mot clé __event peut être appliqué à une déclaration de méthode, une déclaration d'interface, ou une déclaration de membre.Toutefois, vous ne pouvez pas utiliser le mot clé d' __event pour qualifier un membre d'une classe imbriquée.
Selon que votre source d'événements et récepteur sont C++ natif, COM, ou géré (.NET Framework), vous pouvez utiliser les éléments suivants en tant qu'événements :
C++ native |
COM |
Managé (.NET Framework) |
|---|---|---|
Méthode |
— |
méthode |
— |
interface |
— |
— |
— |
membre |
Utilisez __hook dans un récepteur d'événements pour associer une méthode de gestionnaire avec une méthode d'événement.Notez qu'après avoir créé un événement avec le mot clé d' __event , tous les gestionnaires d'événements par la suite accrochés à cet événement sont appelés lorsque l'événement est appelé.
Une déclaration de méthode d' __event ne peut pas avoir de définition ; une définition est implicitement générée, la méthode d'événement peut être appelée comme s'il était toute méthode ordinaire.
[!REMARQUE]
Une classe ou structure modélisée ne peut pas contenir d'événements.
Événements natifs
Les événements natifs sont des méthodes.Le type de retour est généralement HRESULT ou void, mais peut être tout type intégral, y compris enum.Lorsqu'un événement utilise un type de retour intégral, une condition d'erreur est définie lorsqu'un gestionnaire d'événements retourne une valeur différente de zéro, auquel cas l'événement est déclenché appelle les autres délégués.
// Examples of native C++ events:
__event void OnDblClick();
__event HRESULT OnClick(int* b, char* s);
Consultez Gestion des événements en C++ natif exemple de code.
Événements COM
Les événements COM sont des interfaces.Les paramètres d'une méthode dans une interface source de l'événement doivent être des paramètres d' in (mais cela n'est pas radicalement imposé), car un paramètre de out n'est pas utile multicasting.Un avertissement de niveau 1 est émis si vous utilisez un paramètre de out.
Le type de retour est généralement HRESULT ou void, mais peut être tout type intégral, y compris enum.Lorsqu'un événement utilise un type de retour intégral et retourne d'un gestionnaire d'événements une valeur différente de zéro, c'est une condition d'erreur, auquel cas l'événement sont les points déclenchés appelle aux autres délégués.Notez que le compilateur marque automatiquement une interface source de l'événement comme source dans le fichier IDL généré.
Le mot clé de __interface est toujours requis après __event pour une source d'événement COM.
// Example of a COM event:
__event __interface IEvent1;
Consultez gestion des événements dans COM exemple de code.
Événements managés
Pour plus d'informations sur les événements de codage dans la nouvelle syntaxe, consultez l' événement (Visual C++).
Les événements managés sont des données membres ou.En cas de utilisation avec un événement, le type de retour d'un délégué doit être conforme à spécification de langage commun.Le type de retour du gestionnaire d'événements doit correspondre au type de retour du délégué.Pour plus d'informations sur les délégués, consultez __delegate.Si un événement managé est une donnée membre, son type doit être un pointeur vers un délégué.
Dans le.NET Framework, vous pouvez traiter une donnée membre comme une méthode elle-même (autrement dit, la méthode d' Invoke de son délégué correspondant).Vous devez prédéfinir le type délégué pour déclarer un membre managé de données d'événement.En revanche, une méthode managée d'événements définit implicitement le délégué managé qui s'il n'est pas déjà définie.Par exemple, vous pouvez déclarer une valeur d'événement comme OnClick comme événement comme suit :
// Examples of managed events:
__event ClickEventHandler* OnClick; // data member as event
__event void OnClick(String* s); // method as event
En déclarant implicitement un événement managé, vous pouvez spécifier ajouter et supprimer des utilisateurs qui sont appelés lorsque les gestionnaires d'événements sont ajoutés ou supprimés.Vous pouvez également définir la méthode 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;
}
};
Exemple : événements managés
// EventHandling_Managed_Event.cpp
// compile with: /clr:oldSyntax /c
using namespace System;
[event_source(managed)]
public __gc class CPSource {
public:
__event void MyEvent(Int16 nValue);
};
En appliquant un attribut à un événement, vous pouvez spécifier que l'attribut s'appliquent aux méthodes générées ou à la méthode d'appel du délégué généré.La valeur par défaut (event:) est d'appliquer l'attribut à l'événement.
// EventHandling_Managed_Event_2.cpp
// compile with: /clr:oldSyntax /c
using namespace System;
[attribute(All, AllowMultiple=true)]
public __gc class Attr {};
public __delegate void D();
public __gc class X {
public:
[method:Attr] __event D* E;
[returnvalue:Attr] __event void noE();
};