Compartir a través de

Ejecutar un evento

El marco de trabajo de páginas ASP.NET proporciona una técnica denominada ejecución de eventos que permite a un control secundario transmitir eventos en sentido ascendente en su jerarquía de almacenamiento. La ejecución de eventos permite, por un lado, que los eventos puedan ser generados desde una ubicación más conveniente dentro de la jerarquía de controles y, por otro, que controladores de eventos se puedan asociar al control original y al control que expone el evento ejecutado.

La ejecución de eventos se utiliza en los controles de enlace de datos (Repeater, DataList y DataGrid) para exponer eventos de comandos provocados por controles secundarios (dentro de las plantillas de elementos) como eventos de nivel superior. Mientras que los controles de servidor ASP.NET de .NET Framework utilizan la ejecución de eventos para los eventos de comandos (eventos cuya clase de evento se deriva de CommandEventArgs), los eventos definidos en un control de servidor se pueden ejecutar.

Los controles pueden intervenir en la ejecución de eventos a través de dos métodos que heredan de la clase base System.Web.UI.Control. Dichos métodos son OnBubbleEvent y RaiseBubbleEvent. En el siguiente código se muestran las firmas de ambos métodos.

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

Control proporciona la implementación de RaiseBubbleEvent, la cual no puede ser reemplazada. RaiseBubbleEvent envía los datos de eventos en sentido ascendente en la jerarquía hasta el control principal. Para controlar o provocar el evento ejecutado, el método OnBubbleEvent debe reemplazarse por un control.

Los controles que tienen un evento ejecutado hacen una de estas tres cosas.

  • No hace nada, en cuyo caso el evento se ejecuta automáticamente hasta a su principal.

  • Realiza algún procesamiento y continúa ejecutando el evento. Para ello, un control debe reemplazar OnBubbleEvent e invocar a RaiseBubbleEvent desde OnBubbleEvent. En el siguiente fragmento de código (de Ejemplo de control enlazado datos a partir de plantillas) se ejecuta un evento después de comprobar el tipo de los argumentos de 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

  • Deja de ejecutar el evento y provoca y/o ejecuta el evento. Provocar un evento implica invocar el método que envía el evento a los agentes de escuchas. Para provocar el evento ejecutado, un control debe reemplazar OnBubbleEvent para invocar el método OnEventName que provoca el evento ejecutado. Los controles que provocan un evento ejecutado generalmente exponen el evento ejecutado como evento de nivel superior. En el siguiente fragmento de código (de Ejemplo de control enlazado a datos a partir de plantillas) se provoca un evento ejecutado.

    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

Para ver ejemplos que muestran la ejecución de eventos, vea Ejemplo de control de ejecución de eventos y Ejemplo de control de enlace de datos basado en plantilla.

Nota   Si bien el método que permite la ejecución de eventos, OnBubbleEvent, sigue un modelo de nomenclatura .NET Framework estándar para los métodos que provocan eventos, no existe ningún evento denominado BubbleEvent. El evento ejecutado se expone como evento de nivel superior del control que detiene la ejecución de eventos. Por ejemplo, el control DataList expone eventos Command de controles de su plantilla como eventos ItemCommand. Observe también que la firma estándar de los métodos OnEventName en .NET Framework tiene un argumento (protected void OnEventName (EventArgs e)). En cambio, OnBubbleEvent tiene dos argumentos dado que el evento se origina fuera del control; el segundo argumento proporciona el origen.

Hasta el momento, la descripción ha mostrado cómo un control puede responder a un evento que se ejecuta hasta el control. En la siguiente sección se muestra cómo crear un control que define un evento ejecutado.

Definir un evento ejecutado

Si desea que el control permita la ejecución de eventos en un evento que defina, se debe invocar RaiseBubbleEvent desde el método OnEventName que provoca el evento. No es necesario realizar trabajo adicional alguno desde el control. El fragmento de código siguiente muestra un control que define un evento Command que permite la ejecución.

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   La ejecución de eventos no se limita a los eventos de comandos. El mecanismo que aquí se describe se puede utilizar para ejecutar cualquier evento.

Vea también

Ejemplo de control de ejecución de eventos | Ejemplo de control enlazado a datos a partir de plantillas

  • Last updated on