événement (Visual C++)

Le mot clé event déclare un événement, qui notifie aux abonnés inscrits (gestionnaires d'événements) qu'une situation intéressante s'est produite.

Tous les runtimes

C++/CX prend en charge la déclaration d'un membre d'événement ou d'un bloc d'événements. Un membre d'événement est une forme abrégée permettant de déclarer un bloc d'événements. 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énements. Pour personnaliser les fonctions dans un membre d'événement, déclarez un bloc d'événements à la place et substituez ensuite 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é dans la déclaration Event ou dans une méthode d'accesseur d'événement. Les valeurs possibles sont static et virtual.

• delegate
  Le 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) Les paramètres pour la méthode raise, qui correspondent à la signature du paramètre delegate.

Remarques

Un événement est une association entre un délégué et une fonction membre (gestionnaire d'événements) qui répond au déclenchement de l'événement et permet aux clients d'une classe d'inscrire des méthodes conformes à la signature et au type de retour du délégué sous-jacent.

Il existe deux genres de déclarations d'événements :

• donnée membre d'événement
  Le compilateur crée automatiquement le stockage pour l'événement sous la forme d'un membre de type délégué et crée les fonctions membres add(), remove()et raise() internes. Une donnée membre d'événement doit être déclarée dans une classe. Le type de retour du type de retour du délégué doit correspondre au type de retour du gestionnaire d'événements.

• bloc Event
  Un bloc d'événement vous permet de déclarer explicitement et de personnaliser le comportement des méthodes add(), remove() et raise().

Vous pouvez utiliser operators+= et operator-= pour ajouter et supprimer un gestionnaire d'événements, ou appeler les méthodes add() et remove() explicitement.

event est un mot clé contextuel ; consultez mots clés contextuels pour plus d'informations.

Windows Runtime

Remarques

Pour plus d'informations sur les événements, consultez Events (C++/CX).

Si vous avez l'intention d'ajouter et de supprimer ensuite un gestionnaire d'événements, vous devez enregistrer la structure EventRegistrationToken retournée par l'opération d'ajout. Ensuite dans l'opération de suppression, vous devez utiliser la structure EventRegistrationToken enregistrée pour identifier le gestionnaire d'événements à supprimer.

Conditions requises

Option du compilateur : /ZW

Common Language Runtime

Le mot clé event vous permet de déclarer un événement. Un événement permet à une classe de fournir des notifications lorsqu'une situation intéressante 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é dans la déclaration Event ou dans une méthode d'accesseur d'événement. Les valeurs possibles sont static et virtual.

• delegate
  Le 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) Les paramètres pour la méthode raise, qui correspondent à la signature du paramètre delegate.

Remarques

Un événement est une association entre un délégué et une fonction membre (gestionnaire d'événements) qui répond au déclenchement de l'événement et permet aux clients d'une classe d'inscrire des méthodes conformes à 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 qui seront appelées lorsque votre code indique que l'événement s'est produit. Un événement d'un programme peut être mis à la disposition d'autres programmes qui ciblent le Common Language Runtime de .NET Framework. Consultez Déclenchement d'un événement défini dans un assembly différent pour obtenir un exemple.

Il existe deux genres de déclarations d'événements :

• données membres d'événement
  Le stockage pour l'événement, sous la forme d'un membre de type délégué, est créé par le compilateur pour les événements de données membre. Une donnée membre d'événement doit être déclarée dans une classe. Cela s'appelle également un événement trivial (voir l'exemple de code ci-dessous.)

• blocs Event
  Les blocs Event vous permettent de personnaliser le comportement des méthodes add, remove et raise en implémentant ces méthodes. La signature des méthodes add, remove et raise doit correspondre à celle du délégué. Les événements de bloc Event ne sont pas des membres de données et une erreur du compilateur est générée s'ils sont utilisés comme un membre de données. Consultez Définition des méthodes d'accesseur d'événement pour obtenir un exemple.

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). Vous devez prédéfinir le type 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 cette rubrique pour obtenir un exemple.

Lors de la déclaration d'un événement managé, vous pouvez spécifier des accesseurs add et remove qui seront appelés lorsque les gestionnaires d'événements sont ajoutés ou supprimés à l'aide des opérateurs += et -=. Les méthodes add, remove et raise peuvent être appelées de manière explicite.

Vous devez suivre les étapes suivantes pour créer et utiliser des événements dans Visual C++ :

1. 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 mot clé event. Si l'événement est prédéfini, dans le .NET Framework par exemple, les consommateurs de l'événement doivent connaître le nom du délégué.

2. Créez une classe qui contient :

   • Événement créé à partir du délégué.

   • (facultatif) Une méthode qui vérifie l'existence d'une instance du délégué déclaré avec le mot clé event. Sinon, cette logique doit être placée dans le code qui déclenche l'événement.

   • 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.

3. Définissez une ou plusieurs classes qui connectent des méthodes à l'événement. Chacune de ces classes associera une ou plusieurs méthodes à l'événement dans la classe de base.

4. Utilisez l'événement :

   • Créez un objet de la classe qui contient la déclaration event.

   • Créez un objet de la classe qui contient la définition event.

Pour plus d'informations sur les événements C++/CLI, consultez

• Événements dans une interface

• Substitution de l'accès par défaut des méthodes add, remove, et raise.

• Plusieurs gestionnaires pour un événement

• Événements virtuels managés

• Méthodes d'accesseur d'événement

• Événements statiques

• Déclenchement d'un événement défini dans un assembly différent

• Événements Abstract

Conditions requises

Option du compilateur : /clr

Exemples

Exemple

L'exemple de code suivant montre comment déclarer les paires de délégués, d'événements et de gestionnaires d'événements ; abonner (ajouter) les gestionnaires d'événements ; appeler les gestionnaires d'événements ; et ensuite annuler l'abonnement (supprimer) des 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);
}

Sortie

Exemple

L'exemple de code suivant illustre la logique utilisée pour générer la méthode raise d'un événement trivial : si l'événement a un ou plusieurs abonnés, l'appel de la méthode raise appelle implicitement ou explicitement le délégué. Si le type de retour du délégué n'est pas void et s'il n'existe aucun abonné d'événement, la méthode raise retourne la valeur par défaut pour le type délégué. S'il n'existe aucun abonné d'événement, lorsque la méthode raise est appelée, elle est simplement retournée et aucune exception n'est levée. Si le type de retour du 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);   
}

Sortie

0

Voir aussi

Concepts

Fonctionnalités de langage pour cibler le CLR