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.

Modèle d'événement

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) {}

Sub EventHandler(sender As Object, e As EventNameEventArgs)

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){}

Sub Mouse_Moved(sender As Object, e As MouseEventArgs)

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.

Événements statiques et dynamiques

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.

public class TemperatureEventArgs : Inherits EventArgs
   Private oldTemp As Decimal
   Private newTemp As Decimal

   Public ReadOnly Property OldTemperature As Decimal
      Get
         Return Me.oldTemp
      End Get   
   End Property

   Public ReadOnly Property NewTemperature As Decimal
      Get
         Return Me.newTemp
      End Get
   End Property

   Public Sub New(oldTemp As Decimal, newTemp As Decimal)
      Me.oldTemp = oldTemp
      Me.newTemp = newTemp   
   End Sub
End Class

Public Delegate Sub TemperatureEventHandler(sender As Object, _
                                            ev As TemperatureEventArgs)

Public Class TemperatureMonitor
   Private currentTemperature As Decimal
   Private threshholdTemperature As Decimal

   Public Event TemperatureThreshold As TemperatureEventHandler 

   Public Sub New(threshHold As Decimal)
      Me.threshholdTemperature = threshHold
   End Sub

   Public Sub SetTemperature(newTemperature As Decimal)
      If (Me.currentTemperature > threshholdTemperature And _
         newTemperature <= Me.threshholdTemperature) Or _
         (Me.CurrentTemperature < Me.threshholdTemperature And _
             newTemperature >= Me.threshholdTemperature) Then
         OnRaiseTemperatureEvent(newTemperature)
      End If
      Me.currentTemperature = newTemperature
   End Sub

   Public Function GetTemperature() As Decimal
      Return Me.currentTemperature
   End Function

   Protected Overridable Sub OnRaiseTemperatureEvent(newTemperature As Decimal)
      RaiseEvent TemperatureThreshold(Me, New TemperatureEventArgs(Me.currentTemperature, _ 
                                       newTemperature))
   End Sub                                       
End Class

Public Module Example
   Public Sub Main()
      Dim tempMon As New TemperatureMonitor(32d)
      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 Visual Basic syntax.
      AddHandler tempMon.TemperatureThreshold, AddressOf 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 Visual Basic syntax.
      RemoveHandler tempMon.TemperatureThreshold, AddressOf 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())
   End Sub

   Private Sub TempMonitor(sender As Object, e As TemperatureEventArgs)
      Console.WriteLine("   ***Warning: Temperature is changing from {0} to {1}.", _ 
                        e.OldTemperature, e.NewTemperature)
   End Sub 
End Module
' 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.

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.

Voir aussi

Tâches

Comment : consommer des événements dans une application Web Forms

Comment : consommer des événements dans une application Windows Forms

Concepts

Événements et délégués

Déclenchement d'un événement

Autres ressources

Gestion et déclenchement d'événements