Bubbling di un evento

  • Articolo

Il framework di pagina ASP.NET fornisce una tecnica denominata bubbling di evento che consente a un controllo figlio di propagare gli eventi fino alla relativa gerarchia. Il bubbling degli eventi consente di generare gli eventi da una posizione più appropriata nella gerarchia dei controlli e consente ai gestori eventi di essere connessi al controllo originale e al controllo che espone l'evento "bubble".

Il bubbling degli eventi viene utilizzato dai controlli con associazione a dati (Repeater, DataList e DataGrid) per esporre gli eventi di comando generati dai controlli figlio (all'interno dei modelli elementi) come eventi di primo livello. Mentre i controlli server ASP.NET in .NET Framework utilizzano il bubbling degli eventi per gli eventi di comando, ovvero eventi la cui classe di dati evento deriva da CommandEventArgs, è possibile eseguire il bubbling di qualsiasi evento definito su un controllo server.

Un controllo può essere utilizzato nel bubbling di un evento mediante due metodi ereditati dalla classe base System.Web.UI.Control, ovvero OnBubbleEvent e RaiseBubbleEvent. Nel codice riportato di seguito vengono illustrate le firme di questi metodi.

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 _
)

L'implementazione di RaiseBubbleEvent è fornita da Control e non è possibile effettuarne l'override. RaiseBubbleEvent invia i dati evento in alto nella gerarchia fino al padre del controllo. Per gestire o generare l'evento "bubble", un controllo deve eseguire l'override del metodo OnBubbleEvent.

Un controllo che contiene un evento "bubble" si comporta in uno dei tre modi illustrati di seguito.

  • Non esegue alcuna operazione. In questo caso l'evento viene automaticamente passato tramite bubbling al relativo padre.

  • Esegue alcune operazioni di elaborazione proseguendo il bubbling dell'evento. Per ottenere questo risultato, un controllo deve effettuare l'override di OnBubbleEvent e richiamare RaiseBubbleEvent da OnBubbleEvent. Nella porzione di codice riportata di seguito (tratta dalla sezione Esempio di controllo basato su template con associazione a dati) viene eseguito il bubbling di un evento dopo aver controllato il tipo degli argomenti dell'evento.

    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

  • Interrompe il bubbling dell'evento e genera e/o gestisce l'evento. La generazione di un evento comporta il richiamo del metodo che invia l'evento ai listener. Per generare l'evento "bubble", un controllo deve eseguire l'override del metodo OnBubbleEvent in modo da richiamare il metodo OnNomeEvento che genera l'evento "bubble". Un controllo che genera un evento "bubble" espone in genere tale evento come un evento di primo livello. Nella porzione di codice riportata di seguito (tratta dalla sezione Esempio di controllo basato su template con associazione a dati) viene generato un evento "bubble".

    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

Per esempi che illustrano il bubbling degli eventi, vedere Esempio di controllo per il bubbling degli eventi ed Esempio di controllo basato su template con associazione a dati.

Nota   Il metodo che attiva il bubbling degli eventi, OnBubbleEvent, si basa sul criterio di denominazione standard di .NET Framework per l'attribuzione dei nomi ai metodi che generano eventi. Non sono tuttavia presenti eventi denominati BubbleEvent. L'evento "bubble" viene esposto come evento di primo livello nel controllo che interrompe il bubbling degli eventi. Il controllo DataList, ad esempio, espone gli eventi Command dai controlli nel relativo modello come eventi ItemCommand. La firma standard dei metodi OnNomeEvento in .NET Framework, inoltre, contiene un argomento (protected void OnEventName (EventArgs e)). Tuttavia, poiché l'evento viene generato all'esterno del controllo, il metodo OnBubbleEvent comprende due argomenti. Il secondo argomento fornisce l'origine.

Negli argomenti finora discussi sono state illustrate le modalità utilizzate da un controllo per rispondere a un evento che viene passato tramite bubbling fino al controllo stesso. Nella sezione che segue viene illustrato come modificare un controllo che definisce un evento "bubble".

Definizione di un evento "bubble"

Se si desidera che il controllo attivi il bubbling degli eventi per un evento definito dal controllo stesso, è necessario richiamare RaiseBubbleEvent dal metodo OnNomeEvento che genera l'evento. Non è necessario eseguire alcuna operazione aggiuntiva all'interno del controllo. Nella porzione di codice riportata di seguito viene illustrato un controllo che definisce un evento Command che attiva il bubbling.

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

Nota   Il bubbling degli eventi non è limitato agli eventi di comando. È possibile utilizzare il meccanismo descritto in questa sezione per effettuare il bubbling di qualsiasi evento.

Vedere anche

Esempio di controllo di bubbling degli eventi | Esempio di controllo basato su template con associazione a dati