eventmot clé (C++/CLI et C++/CX)
Le event mot clé déclare un événement, qui est une notification aux abonnés inscrits (gestionnaires d’événements) que quelque chose d’intéressant s’est produit.
Tous les runtimes
C++/CX prend en charge la déclaration d’un membre d’événement ou d’un bloc d’événement. Un membre d'événement est un raccourci pour déclarer un bloc d'événement. Par défaut, un membre d'événement déclare les fonctions add, remove et raise qui sont déclarées explicitement dans un bloc d'événement. Pour personnaliser les fonctions dans un membre d'événement, déclarez un bloc d'événement à la place, puis remplacez les fonctions dont vous avez besoin.
Syntaxe
// 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);
}
Paramètres
modifier
Modificateur qui peut être utilisé sur la déclaration event ou une méthode d’accesseur d’événement. Les valeurs possibles sont static et virtual.
delegate
Délégué dont la signature doit correspondre au gestionnaire d’événements.
event_name
Nom de l’événement.
return_value
Valeur de retour de la méthode d’accesseur d’événement. Pour être vérifiable, le type de retour doit être void.
parameters
(facultatif) Paramètres de la méthode raise, qui correspondent à la signature du paramètre delegate.
Notes
Un événement est une association entre un délégué et un gestionnaire d’événements. Un gestionnaire d’événements est une fonction membre qui répond lorsque l’événement est déclenché. Il permet aux clients de n’importe quelle classe d’inscrire des méthodes qui correspondent à la signature et au type de retour du délégué.
Il existe deux types de déclarations d'événements :
membre de données d’événement
Le compilateur crée automatiquement le stockage de l'événement sous la forme d'un membre du type délégué et crée des fonctions membres add, remove et raise internes. Un membre de données d'événement doit être déclaré à l'intérieur d'une classe. Le type de retour du délégué doit correspondre à celui du gestionnaire d'événements.
bloc d’événement
Un bloc d'événement vous permet de déclarer et personnaliser explicitement le comportement des méthodes add, remove et raise.
Vous pouvez utiliser operator += et ajouter et operator -= supprimer un gestionnaire d’événements, ou appeler explicitement les méthodes et remove les add méthodes.
event est un mot clé contextuel. Pour plus d’informations, consultez les mot clé sensibles au contexte.
Windows Runtime
Notes
Pour plus d’informations, consultez Événements (C++/CX).
Pour ajouter et supprimer ultérieurement un gestionnaire d’événements, enregistrez la EventRegistrationToken structure retournée par l’opération add . Ensuite, dans l’opération remove , utilisez la structure enregistrée EventRegistrationToken pour identifier le gestionnaire d’événements à supprimer.
Spécifications
Option du compilateur : /ZW
Common Language Runtime
Le mot clé event vous permet de déclarer un événement. Un événement est un moyen pour une classe de fournir des notifications quand un fait digne d'intérêt se produit.
Syntaxe
// 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);
}
Paramètres
modifier
Modificateur qui peut être utilisé sur la déclaration event ou une méthode d’accesseur d’événement. Les valeurs possibles sont static et virtual.
delegate
Délégué dont la signature doit correspondre au gestionnaire d’événements.
event_name
Nom de l’événement.
return_value
Valeur de retour de la méthode d’accesseur d’événement. Pour être vérifiable, le type de retour doit être void.
parameters
(facultatif) Paramètres de la méthode raise, qui correspondent à la signature du paramètre delegate.
Notes
Un événement est une association entre un délégué et un gestionnaire d’événements. Un gestionnaire d’événements est une fonction membre qui répond lorsque l’événement est déclenché. Il permet aux clients de n’importe quelle classe d’inscrire des méthodes qui correspondent à la signature et au type de retour du délégué sous-jacent.
Le délégué peut avoir une ou plusieurs méthodes associées. Ces méthodes sont appelées lorsque votre code indique que l’événement s’est produit. Un événement propre à un programme peut être accessible à d'autres programmes qui ciblent le Common Language Runtime du .NET Framework.
Il existe deux types de déclarations d’événements :
membres de données d’événement
Le compilateur crée un stockage pour les événements membres de données en tant que membre du type délégué. Un membre de données d'événement doit être déclaré à l'intérieur d'une classe. Il est également connu sous le nom d’événement trivial. Consultez l’exemple de code pour obtenir un exemple.
blocs d’événement
Les blocs d’événements vous permettent de personnaliser le comportement des méthodes , removeet raise des addméthodes, en implémentant , removeet raise en utilisant adddes méthodes. La signature du adddélégué removeraise et les méthodes doivent correspondre à la signature du délégué. Les événements de bloc d’événements ne sont pas des membres de données. Toute utilisation en tant que membre de données génère une erreur du compilateur.
Le type de retour du gestionnaire d'événements doit correspondre à celui du 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éfinis le type de délégué pour 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. Consultez l’exemple de code à la fin de cet article pour obtenir un exemple.
Lors de la déclaration d’un événement managé, vous pouvez spécifier add et remove accéder aux accesseurs qui seront appelés lorsque des gestionnaires d’événements sont ajoutés ou supprimés à l’aide d’opérateurs += et -=. Les addméthodes et raise les méthodes removepeuvent être appelées explicitement.
Les étapes suivantes doivent être effectuées pour créer et utiliser des événements dans Microsoft C++ :
Créez ou identifiez un délégué. Si vous définissez votre propre événement, vous devez également vous assurer qu’il existe un délégué à utiliser avec le
eventmot clé. Si l'événement est prédéfini, dans le .NET Framework par exemple, alors les consommateurs de l'événement doivent uniquement connaître le nom du délégué.Créez une classe qui contient :
Un événement créé à partir du délégué.
(Facultatif) Méthode qui vérifie qu’une instance du délégué déclaré avec le
eventmot clé existe. Sinon, cette logique doit être placée dans le code qui déclenche l'événement.Des méthodes qui appellent l'événement. Ces méthodes peuvent être des substitutions de certaines fonctionnalités de la classe de base.
Cette classe définit l'événement.
Définissez une ou plusieurs classes qui connectent les méthodes à l'événement. Chacune de ces classes associe une ou plusieurs méthodes à l'événement dans la classe de base.
Utilisez l'événement :
Créez un objet de la classe qui contient la déclaration de l'événement.
Créez un objet de la classe qui contient la déclaration de l'événement.
Pour plus d’informations sur les événements C++/CLI, consultez Événements dans une interface.
Spécifications
Option du compilateur : /clr
Exemples
L’exemple de code suivant illustre la déclaration de paires de délégués, d’événements et de gestionnaires d’événements. Il montre comment s’abonner (ajouter), appeler, puis annuler (supprimer) les gestionnaires d’événements.
// 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
L’exemple de code suivant illustre la logique utilisée pour générer la raise méthode d’un événement trivial. Si l’événement a un ou plusieurs abonnés, appeler la méthode raise implicitement ou explicitement appelle le délégué. Si le type de retour du délégué n’est pas et s’il n’y a pas void d’abonnés aux événements, la raise méthode retourne la valeur par défaut du type délégué. S’il n’y a pas d’abonnés aux événements, l’appel de la raise méthode retourne immédiatement et aucune exception n’est levée. Si le type de retour délégué n’est pas void, le type délégué est retourné.
// 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
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour