Exporter (0) Imprimer
Développer tout

Consommation d'événements

Mise à jour : novembre 2007

Pour consommer un événement dans une application, vous devez fournir un gestionnaire d'événements (une méthode de gestion d'événements) qui exécute la logique de programme en réponse à l'événement et inscrit le gestionnaire d'événements dans la source de l'événement. Ce processus est appelé connexion des événements. Les concepteurs visuels Windows Forms et Web Forms proposent des outils RAD (Rapid Application Development) qui simplifient ou masquent les détails de la connexion des événements.

Cette rubrique décrit le modèle général de la gestion d'événements. Pour obtenir une vue d'ensemble du modèle d'événement dans le .NET Framework, consultez Événements et délégués. Pour plus d'informations sur le modèle d'événement dans les Windows Forms, consultez Comment : consommer des événements dans une application Windows Forms. Pour plus d'informations sur le modèle d'événement dans Web Forms, consultez Comment : consommer des événements dans une application Web Forms.

Les détails de la connexion des événements diffèrent dans les Windows Forms et dans Web Forms en raison des différents niveaux de prise en charge fournis par divers outils RAD. Toutefois, les deux scénarios suivent le même modèle d'événement qui possède les caractéristiques suivantes :

  • Une classe qui déclenche un événement nommé EventName possède le membre suivant :

    public event EventNameEventHandler EventName;
    
    

    Public Event EventName As EventNameEventHandler
    
  • Le délégué d'événement de l'événement EventName est EventNameEventHandler, avec la signature suivante :

    public delegate void EventNameEventHandler(object sender, EventNameEventArgs e);
    
    

    Public Delegate Sub EventNameEventHandler(sender As Object, e As EventNameEventArgs)
    

Pour utiliser l'événement EventName, votre gestionnaire d'événements doit posséder la même signature que celle du délégué d'événement :

void EventHandler(object sender, EventNameEventArgs e) {}

Remarque :

Un délégué d'événement figurant dans le .NET Framework est désigné par EventNameEventHandler, tandis que le terme gestionnaire d'événements utilisé dans la documentation se rapporte à la méthode de gestion d'événements. La logique selon laquelle le délégué EventNameEventHandler pointe vers le gestionnaire d'événements (la méthode) qui gère en fait l'événement repose à la base du schéma d'affectation de noms.

Lorsqu'un événement ne possède pas de données associées, la classe qui déclenche l'événement utilise System.EventHandler comme délégué et System.EventArgs pour les données d'événement. Les événements qui possèdent des données associées utilisent des classes qui dérivent d'EventArgs à partir du type de données d'événement et le type délégué d'événement correspondant. Par exemple, si vous souhaitez gérer un événement MouseUp dans une application Windows Forms, la classe des données d'événement est MouseEventArgs et le délégué d'événement est MouseEventHandler. Notez que plusieurs événements de souris utilisent une classe commune pour les données d'événement et un délégué d'événement commun, si bien que le schéma d'affectation de noms ne correspond pas exactement à la convention décrite ci-dessus. Pour les événements de souris, votre gestionnaire d'événements doit posséder la signature suivante :

void Mouse_Moved(object sender, MouseEventArgs e){}

Les paramètres d'expéditeur et d'argument d'événement fournissent des détails supplémentaires à propos de l'événement de souris au gestionnaire d'événements. L'objet sender indique ce qui a déclenché l'événement. Le paramètre MouseEventArgs fournit des détails sur le déplacement de la souris qui a déclenché l'événement. Beaucoup de sources d'événements fournissent des données supplémentaires pour l'événement, et beaucoup de gestionnaires d'événements utilisent les données spécifiques à l'événement pour traiter l'événement. Pour obtenir un exemple qui illustre le déclenchement et la gestion des événements avec les données spécifiques à l'événement, consultez Comment : déclencher et utiliser des événements.

Remarque :

Les événements surviennent également en dehors du contexte des interfaces utilisateur et le .NET Framework inclut en fait de nombreuses classes non-interface utilisateur qui déclenchent des événements. Tous les événements suivent toutefois le modèle décrit ci-dessus.

Pour plus d'informations sur le déclenchement d'événements à partir d'une classe, consultez Déclenchement d'un événement.

Le .NET Framework permet aux abonnées de s'inscrire pour recevoir des notifications d'événements statiques ou dynamiques. Les gestionnaires d'événements statiques sont actifs pour la durée de vie complète de la classe dont ils gèrent les événements. Cette méthode de gestion des événements est la plus courante. Les gestionnaires d'événements dynamiques sont activés et désactivés explicitement pendant l'exécution du programme, généralement en réponse à une logique de programme conditionnelle. Ils peuvent être utilisés par exemple lorsque des notifications d'événements sont nécessaires dans certaines conditions seulement ou si une application fournit plusieurs gestionnaires d'événements et si les conditions d'exécution définissent le gestionnaire à utiliser.

La méthode EventInfo.AddEventHandler ajoute des gestionnaires d'événements dynamiques tandis que la méthode EventInfo.RemoveEventHandler les désactive. Les langages individuels fournissent également leurs propres fonctionnalités de gestion dynamique des événements. L'exemple suivant définit une classe TemperatureMonitor qui déclenche un événement TemperatureTheshold lorsque la température atteint un seuil prédéfini. Un gestionnaire d'événements qui s'abonne à cet événement est activé et désactivé pendant l'exécution du programme.

using System;

public class TemperatureEventArgs : EventArgs
{
   private decimal oldTemp;
   private decimal newTemp;

   public decimal OldTemperature
   {
      get { return this.oldTemp; }
   }

   public decimal NewTemperature
   {
      get { return this.newTemp; }
   }

   public TemperatureEventArgs(decimal oldTemp, decimal newTemp)
   {
      this.oldTemp = oldTemp;
      this.newTemp = newTemp;   
   }
}

public delegate void TemperatureEventHandler(object sender, TemperatureEventArgs ev);

public class TemperatureMonitor
{
   private decimal currentTemperature;
   private decimal threshholdTemperature;

   public event TemperatureEventHandler TemperatureThreshold; 

   public TemperatureMonitor(decimal threshhold)
   {
      this.threshholdTemperature = threshhold;
   }

   public void SetTemperature(decimal newTemperature)
   {
      if ( (this.currentTemperature > this.threshholdTemperature && 
           newTemperature <= this.threshholdTemperature) ||
           (this.currentTemperature < this.threshholdTemperature &&
           newTemperature >= this.threshholdTemperature) )
         OnRaiseTemperatureEvent(newTemperature);
      this.currentTemperature = newTemperature;
   }

   public decimal GetTemperature()
   {
      return this.currentTemperature;
   }

   protected virtual void OnRaiseTemperatureEvent(decimal newTemperature)
   {
      // Raise the event if it has subscribers.
      if (TemperatureThreshold != null)
         TemperatureThreshold(this, new TemperatureEventArgs(this.currentTemperature, 
                               newTemperature));
   }
}

public class Example
{
   public static void Main()
   {
      Example ex = new Example();
      ex.MonitorTemperatures();
   }

   public void MonitorTemperatures()
   {
      TemperatureMonitor tempMon = new TemperatureMonitor(32);
      tempMon.SetTemperature(33);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(32);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.",
                        tempMon.GetTemperature());

      // Add event handler dynamically using C# syntax.
      tempMon.TemperatureThreshold += this.TempMonitor;

      tempMon.SetTemperature(33);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(34);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(32);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.",
                        tempMon.GetTemperature());

      // Remove event handler dynamically using C# syntax.
      tempMon.TemperatureThreshold -= this.TempMonitor;

      tempMon.SetTemperature(31);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
      tempMon.SetTemperature(35);
      Console.WriteLine("Current temperature is {0} degrees Fahrenheit.", 
                        tempMon.GetTemperature());
   }

   private void TempMonitor(object sender, TemperatureEventArgs e)
   {
      Console.WriteLine("   ***Warning: Temperature is changing from {0} to {1}.", 
                        e.OldTemperature, e.NewTemperature);
   } 
}
// The example displays the following output:
//       Current temperature is 33 degrees Fahrenheit.
//       Current temperature is 32 degrees Fahrenheit.
//       Current temperature is 33 degrees Fahrenheit.
//       Current temperature is 34 degrees Fahrenheit.
//          ***Warning: Temperature is changing from 34 to 32.
//       Current temperature is 32 degrees Fahrenheit.
//       Current temperature is 31 degrees Fahrenheit.
//       Current temperature is 35 degrees Fahrenheit.


Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft