Definieren eines Ereignisses

Wenn Sie mit dem Delegatmodell für Ereignisse nicht vertraut sind, finden Sie entsprechende Informationen unter Behandeln und Auslösen von Ereignissen.

Ereignisfunktionalität wird durch folgende Elemente bereitgestellt.

• Eine Klasse, die Ereignisdaten enthält (z. B. EventArgs, ImageClickEventArgs).

• Ein Ereignisdelegat (z. B. EventHandler, ImageClickEventHandler).

  Hinweis   Diese beiden Klassen werden im Allgemeinen außerhalb eines Steuerelements definiert. Die beiden folgenden Member werden im Steuerelement definiert.

• Ein im Steuerelement definierter Ereignismember. Dieser wird über das Schlüsselwort event identifiziert.

• Eine Methode im Steuerelement, durch die Delegaten aufgerufen werden (z. B. OnClick, OnTextChanged).

Im folgenden Beispiel wird im benutzerdefinierten Steuerelement MyButton ein Click-Ereignis definiert.

// 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

Zusätzlich zur Definition des Ereignisses muss der Entwickler auch entscheiden, wie das Ereignis ausgelöst wird (von woher die OnEreignisname-Methode aufgerufen wird). In dem Beispiel wird im Steuerelement MyButton das Click-Ereignis von der RaisePostBackEvent-Methode (die Teil des IpostBackEventHandler-Vertrags ist) ausgelöst. Weitere Informationen zu diesem Beispiel finden Sie unter Auffangen von Postback-Ereignissen.

Optimieren der Implementierung von Ereignissen

Die oben beschriebene Ereignisimplementierung ist nicht leistungsoptimiert. Da pro Delegatinstanz ein Feld generiert wird, erhöhen sich die Speicherkosten, wenn für ein Steuerelement viele Ereignisse definiert werden. Durch die Basisklasse System.Web.UI.Control wird über die Events-Eigenschaft eine effizientere Datenstruktur zum Speichern und Abrufen von Ereignisdelegaten bereitgestellt. Die Events-Eigenschaft ist vom Typ EventHandlerList, einer Datenstruktur, die für das effiziente Speichern und Abrufen von Ereignisdelegaten entwickelt wurde. Im folgenden Beispiel wird die Ereignisimplementierung unter Verwendung der Events-Eigenschaft gezeigt. Dieses C#-Beispiel unterscheidet sich vom weiter oben definierten MyButton-Beispiel nur hinsichtlich der Implementierung des Click-Ereignisses. Der Code, mit dem das Ereignis implementiert wird, ist fett hervorgehoben.

Hinweis   In dieser Version werden von Visual Basic .NET keine Ereigniseigenschaften unterstützt.

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' />"); 
      }
   }    
}

Hinweis   Zur Vereinfachung werden in einigen anderen Beispielen der Dokumentation bei der Definition von Ereignissen Ereignisfelder verwendet. Generell sollte in Steuerelementen aber die hier erläuterte optimierte Implementierung verwendet werden.

Siehe auch

Behandeln und Auslösen von Ereignissen | Bubbling eines Ereignisses | Verarbeiten von Postback-Daten | Auffangen von Postback-Ereignissen | Generieren von clientseitigen Skripts für Postback