Freigeben über

Bubbling eines Ereignisses

  • Artikel

Im ASP.NET-Seitenframework steht ein Verfahren zur Verfügung, das Eventbubbling genannt wird. Dadurch erhalten untergeordnete Steuerelemente die Möglichkeit, Ereignisse in ihrer Verkapselungshierarchie nach oben bekannt zu geben. Durch Eventbubbling können Ereignisse von einem besser geeigneten Standort innerhalb der Hierarchie der Steuerelemente ausgelöst werden. Außerdem können das ursprüngliche Steuerelement und dasjenige, durch das ein weitergeleitetes Ereignis offen gelegt wird, mit einem Ereignishandler verknüpft werden.

Eventbubbling wird insbesondere von datengebundenen Steuerelementen (Repeater, DataList und DataGrid) verwendet, um command-Ereignisse, die durch untergeordnete Steuerelemente (innerhalb von Elementvorlagen) ausgelöst werden, als Ereignisse der obersten Ebene offen zu legen. Von ASP.NET-Serversteuerelemente in .NET Framework wird Eventbubbling nur für command-Ereignisse (Ereignisse, deren Ereignisdatenklasse von CommandEventArgs abgeleitet wird) verwendet. Dagegen kann jedes durch ein Serversteuerelement definierte Ereignis weitergeleitet werden.

Ein Steuerelement kann mit zwei Methoden, die von der Basisklasse System.Web.UI.Control vererbt werden, am Eventbubbling teilnehmen. Diese Methoden sind OnBubbleEvent und RaiseBubbleEvent. Der folgende Beispielcode veranschaulicht die Signaturen dieser Methoden.

protected virtual bool OnBubbleEvent(
   object source,
   EventArgs args
);
protected void RaiseBubbleEvent(
   object source,
   EventArgs args 
);
[Visual Basic]
Overridable Protected Function OnBubbleEvent( _
   ByVal source As Object, _
   ByVal args As EventArgs _
) As Boolean
Protected Sub RaiseBubbleEvent( _
   ByVal source As Object, _
   ByVal args As EventArgs _
)

Die Implementierung von RaiseBubbleEvent wird durch Control bereitgestellt und kann nicht überschrieben werden. Durch RaiseBubbleEvent werden Ereignisdaten zu den in der Hierarchie übergeordneten Steuerelementen gesendet. Um das weitergeleitete Ereignis zu behandeln oder auszulösen, muss die OnBubbleEvent-Methode durch ein Steuerelement überschrieben werden.

Wenn ein Ereignis zu einem Steuerelement weitergeleitet wird, reagiert dieses auf eine der folgenden Weisen:

  • Es reagiert überhaupt nicht. In diesem Fall wird das Ereignis automatisch zum nächsten darüber liegenden Steuerelement weitergeleitet.

  • Es führt einige Verarbeitungsschritte aus und leitet dann das Ereignis weiter. Um dazu in der Lage zu sein, muss das Steuerelement OnBubbleEvent überschreiben und RaiseBubbleEvent von OnBubbleEvent aufrufen. Im folgenden Codefragment (siehe auch Beispiel für ein datengebundenes Steuerelement mit Vorlagen) wird das Ereignis erst weitergeleitet, nachdem der Typ der Ereignisargumente geprüft wurde.

    protected override bool OnBubbleEvent(object source, EventArgs e) {
            if (e is CommandEventArgs) {
                // Adds information about an Item to the  
                // CommandEvent.
                TemplatedListCommandEventArgs args =
                    new TemplatedListCommandEventArgs(this, source, (CommandEventArgs)e);
                RaiseBubbleEvent(this, args);
                return true;
            }
            return false;
        }
[Visual Basic]
Protected Overrides Function OnBubbleEvent(source As Object, e As EventArgs) As Boolean
   If TypeOf e Is CommandEventArgs Then
      ' Adds information about an Item to the  
      ' CommandEvent.
      Dim args As New TemplatedListCommandEventArgs(Me, source, CType(e, CommandEventArgs))
      RaiseBubbleEvent(Me, args)
      Return True
   End If
   Return False
End Function

  • Das Eventbubbling wird beendet und das Ereignis ausgelöst und/oder behandelt. Das Auslösen eines Ereignisses geht mit dem Aufruf einer Methode einher, mit der das Ereignis an Listener ausgesendet wird. Wurde von einem Steuerelement die OnBubbleEvent-Methode überschrieben, kann ein weitergeleitetes Ereignis von diesem Steuerelement durch Aufruf der OnEreignisname-Methode ausgelöst werden. Das weitergeleitete Ereignis wird durch das auslösende Steuerelement im Allgemeinen als Ereignis der obersten Ebene offen gelegt. Im folgenden Codefragment (siehe auch Beispiel für ein datengebundenes Steuerelement mit Vorlagen) wird ein weitergeleitetes Ereignis ausgelöst.

    protected override bool OnBubbleEvent(object source, EventArgs e) {
    bool handled = false;

    if (e is TemplatedListCommandEventArgs) {
        TemplatedListCommandEventArgs ce = (TemplatedListCommandEventArgs)e;

        OnItemCommand(ce);
        handled = true;
    }
    return handled;
}
[Visual Basic]
Protected Overrides Function OnBubbleEvent(source As Object, e As EventArgs) As Boolean
   Dim handled As Boolean = False

   If TypeOf e Is TemplatedListCommandEventArgs Then
      Dim ce As TemplatedListCommandEventArgs = CType(e, TemplatedListCommandEventArgs)

      OnItemCommand(ce)
      handled = True
   End If
   Return handled
End Function

Weitere Beispiele für Eventbubbling finden Sie unter Beispiel für Ereignisbubbling anhand eines Steuerelements und Beispiel für ein datengebundenes Steuerelement mit Vorlagen.

Hinweis   Die für das Eventbubbling verwendete OnBubbleEvent-Methode folgt der in .NET Framework standardmäßig verwendeten Konvention zur Benennung von Methoden, mit denen Ereignisse ausgelöst werden. Es gibt kein Ereignis namens BubbleEvent. Das weitergeleitete Ereignis wird als Ereignis der obersten Ebene von dem Steuerelement offen gelegt, in dem das Eventbubbling beendet wird. Beispielsweise werden von einem DataList-Steuerelement Command-Ereignisse, die von Steuerelementen seiner Vorlage ausgelösten wurden, als ItemCommand-Ereignisse offen gelegt. Beachten Sie außerdem, dass die Standardsignatur von OnEreignisname-Methoden in .NET Framework über ein Argument verfügt (protected void OnEventName (EventArgs e)). Dagegen verfügt OnBubbleEvent über zwei Argumente, da dieses Ereignis außerhalb des Steuerelements ausgelöst und mit dem zweiten Argument die Quelle angegeben wird.

Die bisherigen Erläuterungen haben gezeigt, wie ein Steuerelement auf ein Ereignis reagieren kann, das nach oben bis auf seine Ebene weitergeleitet wurde. Im folgenden Abschnitt wird die Erstellung eines Steuerelements gezeigt, das ein solches Ereignis definiert.

Definieren eines weitergeleiteten Ereignisses

Eventbubbling wird für ein in einem Steuerelement definiertes Ereignis ermöglicht, indem RaiseBubbleEvent von der das Ereignis auslösenden OnEreignisname-Methode aufgerufen wird. Vonseiten des Steuerelements sind keine weiteren Aktivitäten erforderlich. Im folgenden Codefragment wird ein Steuerelement gezeigt, in dem ein Command-Ereignis ist, wodurch das Eventbubbling aktiviert wird.

protected virtual void OnCommand(CommandEventArgs e) {
            CommandEventHandler handler = (CommandEventHandler)Events[EventCommand];
            if (handler != null)
                handler(this,e);

            // The Command event is bubbled up the control hierarchy.
            RaiseBubbleEvent(this, e);
        } 
[Visual Basic]
Protected Overridable Sub OnCommand(e As CommandEventArgs)
   Dim handler As CommandEventHandler = CType(Events(EventCommand), CommandEventHandler)
   If Not (handler Is Nothing) Then
      handler(Me, e)
   End If 
   ' The Command event is bubbled up the control hierarchy.
   RaiseBubbleEvent(Me, e)
End Sub

Hinweis   Eventbubbling ist nicht auf command-Ereignisse beschränkt. Mit dem hier beschriebenen Verfahren können jegliche Ereignisse weitergeleitet werden.

Siehe auch

Beispiel für Ereignisbubbling anhand eines Steuerelements | Beispiel für ein datengebundenes Steuerelement mit Vorlagen