Définition d'un événement

Si vous n'êtes pas familiarisé avec le modèle de délégué des événements, consultez Gestion et déclenchement d'événements.

Les fonctionnalités des événements sont fournies par les éléments suivants.

• Une classe contenant les données d'événement (par exemple, EventArgs, ImageClickEventArgs).

• Un délégué d'événement (par exemple, EventHandler, ImageClickEventHandler).

  Remarque   Les deux classes précédentes sont généralement définies à l'extérieur de votre contrôle. Les deux membres suivants sont définis dans votre contrôle.

• Un événement membre défini dans votre contrôle. Il est identifié par le mot clé event.

• Une méthode dans votre contrôle appelant les délégués (par exemple, OnClick, OnTextChanged).

L'exemple suivant définit un événement Click dans le contrôle personnalisé MyButton.

// If the event does not generate data, you do not have
// to define a class for the event data or define an event delegate. 
// Use System.EventArgs for event data
// and System.EventHandler as the event delegate.
// MyButton uses EventHandler and EventArgs.

using System;
using System.Web.UI;

namespace CustomControls 
{  
   public class MyButton: Control, IPostBackEventHandler 
   {     
      // Defines the Click event.
      public event EventHandler Click;

      // OnClick dispatches the event to delegates that
      // are registered with the Click event.
      // Controls that derive from MyButton can handle the
      // Click event by overriding OnClick
      // instead of attaching a delegate. The event data
      // is passed as an argument to this method.
      protected virtual void OnClick(EventArgs e) 
      {     
         if (Click != null) 
         {
            Click(this, e);
         }  
      }
      
      // Method of IPostBackEventHandler that raises change events.
      public void RaisePostBackEvent(string eventArgument)
      {     
         OnClick(EventArgs.Empty);
      }
      
      protected override void Render(HtmlTextWriter output) 
      {     
         output.Write("<INPUT TYPE = submit name = " + this.UniqueID + 
            " Value = 'Click Me' />"); 
      }
   }    
}
[Visual Basic]
' If the event does not generate data, you do not have
' to define a class for the event data or define an event delegate. 
' Use System.EventArgs for event data
' and System.EventHandler as the event delegate.
' MyButton uses EventHandler and EventArgs.
Option Explicit
Option Strict

Imports System
Imports System.Web.UI

Namespace CustomControls
   Public Class MyButton
      Inherits Control
      Implements IPostBackEventHandler
      
      ' Defines the Click event.
      Public Event Click As EventHandler
      
      ' OnClick dispatches the event to delegates that
      ' are registered with the Click event.
      ' Controls that derive from MyButton can handle the
      ' Click event by overriding OnClick
      ' instead of attaching a delegate. The event data
      ' is passed as an argument to this method.
      Protected Overridable Sub OnClick(e As EventArgs)
         RaiseEvent Click(Me, e)
      End Sub
      
      ' Method of IPostBackEventHandler that raises change events.
      Public Sub RaisePostBackEvent(eventArgument As String) Implements IPostBackEventHandler.RaisePostBackEvent
         OnClick(EventArgs.Empty)
      End Sub 'RaisePostBackEvent
      
      Protected Overrides Sub Render(output As HtmlTextWriter)
         output.Write(("<INPUT TYPE = submit name = " & Me.UniqueID & " Value = 'Click Me' />"))
      End Sub
   End Class
End Namespace

Outre la définition d'un événement, un développeur de contrôles doit également décider de la manière dont l'événement doit se déclencher (à partir d'où appeler la méthode OnNomÉvénement). Par exemple, MyButton déclencher l'événement Click à partir de sa méthode RaisePostBackEvent (qui fait partie du contrat IPostBackEventHandler). Pour plus d'informations sur cet exemple, consultez Capture d'événements de publication.

Optimisation de l'implémentation des événements

L'implémentation des événements décrite ci-dessus n'est pas optimisée pour assurer les meilleures performances. Elle génère un champ par instance de délégué, ce qui augmente le coût du stockage lorsque de nombreux événements sont définis sur un contrôle. La classe de base System.Web.UI.Control fournit une structure de données efficace (à l'aide de sa propriété Events) pour le stockage et l'extraction de délégués d'événements. La propriété Events est de type EventHandlerList, c'est-à-dire une structure de données conçue pour un stockage et une extraction efficaces des délégués d'événements. L'exemple suivant illustre l'implémentation des événements à l'aide de la propriété Events. Cet exemple C# ne diffère de l'exemple MyButton, défini précédemment dans cette rubrique, que par son implémentation de l'événement Click. Le code implémenté par cet événement est mis en surbrillance et en gras.

Remarque   Dans cette version, les propriétés d'événement ne sont pas prises en charge dans Visual Basic .NET.

using System;
using System.Web.UI;

namespace CustomControls 
{
   public class OptimizedEventButton: Control, IPostBackEventHandler 
   {
      // Defines a key for storing the delegate for the Click event
      // in the Events list.
      private static readonly object ClickEvent = new object();
      
      // Defines the Click event using the event property syntax.
      // The Events property stores all the event delegates of
      // a control as name/value pairs. 
      public event EventHandler Click 
      {
         // When a user attaches an event handler to the Click event 
         // (Click += myHandler;), the Add method 
         // adds the handler to the 
         // delegate for the Click event (keyed by ClickEvent 
         // in the Events list).
         add          {            Events.AddHandler(ClickEvent, value);         }
         // When a user removes an event handler from the Click event 
         // (Click -= myHandler;), the Remove method 
         // removes the handler from the 
         // delegate for the Click event (keyed by ClickEvent 
         // in the Events list).
         remove          {            Events.RemoveHandler(ClickEvent, value);         }
      }
      
      // Invokes delegates registered with the Click event.
      //
      protected virtual void OnClick(EventArgs e) 
      {
         // Retrieves the event delegate for the Click event
         // from the Events property (which stores
         // the control's event delegates). You must
         // cast the retrieved delegate to the type of your 
         // event delegate.
         EventHandler clickEventDelegate = (EventHandler)Events[ClickEvent];         if (clickEventDelegate != null) {            clickEventDelegate(this, e);         }  
      }
      
      // Method of IPostBackEventHandler that raises change events.
      //
      public void RaisePostBackEvent(string eventArgument)
      {
         
         OnClick(new EventArgs());
      }
      
      protected override void Render(HtmlTextWriter output) 
      {
         
         output.Write("<INPUT TYPE = submit name = " + this.UniqueID + 
            " Value = 'Click Me' />"); 
      }
   }    
}

Remarque   Par souci de simplicité, certains autres exemples de la documentation définissent des événements à l'aide de champs d'événement. Dans vos contrôles, cependant, vous devez utiliser l'implémentation optimisée décrite ici.

Voir aussi

Gestion et déclenchement d'événements | Propagation d'un événement | Traitement des données de publication | Capture d'événements de publication | Génération d'un script côté client pour la publication