El artículo anterior presentó los conceptos básicos de la implementación de eventos de control de servidor personalizados. Este artículo explicará cómo capturar eventos de devolución de llamada mediante ejemplos típicos.
1. Implementar la captura de eventos de devolución de datos.
Si un control de servidor necesita capturar eventos de devolución de datos del cliente y desea personalizar la lógica de procesamiento de eventos del lado del servidor para los eventos de devolución de datos, entonces el control debe implementar la interfaz System.Web.UI.IPostBackEventHandler. La definición de la interfaz se enumera a continuación.
interfaz pública IPostBackEventHandler
{
void RaisePostBackEvent (cadena eventArgument);
}
Como se muestra en el código anterior, la interfaz IPostBackEventHandler solo incluye un método miembro RaisePostBackEvent. Este método permite que el control del servidor maneje los eventos generados cuando el formulario se envía al servidor. Su parámetro eventArgument representa los parámetros de evento opcionales que se pasarán al controlador de eventos. Los desarrolladores pueden implementar la lógica realizada durante el proceso de devolución de datos de control del servidor en el método RaisePostBackEvent. Normalmente, el método RaisePostBackEvent generará uno o más eventos del lado del servidor. El siguiente fragmento de código muestra la implementación de RaisePostBackEvent que genera el evento Click en el servidor.
público vacío RaisePostBackEvent (String eventArgument)
{
Al hacer clic (EventArgs.Empty);
}
Para lograr capturar eventos de devolución de datos, no es suficiente simplemente hacer que la clase de control del servidor implemente la interfaz IPostBackEventHandler e implemente los métodos miembro de esta interfaz. Los desarrolladores también deben prestar atención a la implementación de otras cosas. A continuación se enumeran tres puntos clave en el proceso de capturar eventos de devolución de datos.
En primer lugar, y lo más importante, la clase de control de servidor personalizado debe implementar la interfaz IPostBackEventHandler e implementar el método RaisePostBackEvent del miembro de la interfaz. Este proceso se ha descrito anteriormente.
En segundo lugar, asigne un ID único al control.
Definir el valor del atributo de nombre del control que hace que el evento de devolución sea UniqueID es una de las claves para implementar correctamente el método RaisePostBackEvent. Cuando se activa una devolución de datos, el marco de la página busca el contenido que se envía y determina si el nombre del objeto de envío corresponde al ID único del control de servidor que implementa IPostBackEventHandler. Si corresponde, el marco de la página llamará al método RaisePostBackEvent en el control. El punto clave aquí es que los desarrolladores deben asignar UniqueID al atributo de nombre del control en la lógica de representación. A continuación se muestra un ejemplo de código simple.
Anulación protegida Renderizado vacío (salida HtmlTextWriter)
{
salida.Write("
}
Como se muestra en el código anterior, en el método de representación de control Render, se presenta un botón, cuyo valor de atributo de nombre es UniqueID. Solo cuando al atributo de nombre del control que causa la devolución se le asigna un ID único se puede capturar correctamente el evento de devolución.
En tercer lugar, implemente la estructura de atributos del evento.
La estructura de atributos de eventos es una forma optimizada de implementar eventos. Antes de la introducción, primero veamos los métodos comunes de implementación de eventos de control. El código específico es el siguiente.
...
clase pública WebCustomControl:WebControl,IPostBackEventHandler{
// Declarar evento público delegado del evento Click EventHandler Click;
//Implementar el método RaisePostBackEvent void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) {
Al hacer clic (EventArgs.Empty);
}
//Definir el controlador de eventos OnClick protected virtual void OnClick(EventArgs e) {
if(Haga clic!= nulo) { Haga clic(esto,e});
}
...
}
En el código anterior, se incluyen tres contenidos clave relacionados con la definición de eventos: 1. Definir el delegado de eventos Click; 2. La clase de control implementa la interfaz IPostBackEventHandler, en la que el controlador de eventos OnClick se define al implementar el método miembro de la interfaz RaisePostBackEvent. ;3. Implementar el controlador de eventos OnClick. El método de implementación anterior es simple y fácil de usar, pero tiene el inconveniente de que tiene una baja eficiencia de ejecución. Especialmente cuando se activan varios eventos en una clase, aumentará la sobrecarga, desperdiciará muchos recursos del servidor y, en última instancia, reducirá la eficiencia operativa.
Para resolver los problemas anteriores, a continuación se presenta una estructura optimizada de atributos de evento y método de implementación de eventos. Esta estructura utiliza la clase System.ComponentModel.EventHandlerList, que proporciona una lista de delegados simple. Al utilizar los métodos relacionados proporcionados por esta clase, los desarrolladores pueden manipular de manera flexible la lista de delegados del controlador de eventos del control. Por ejemplo, el evento Click en el control usa la estructura de atributos del evento de la siguiente manera:
objeto de solo lectura estático protegido EventClick = new object();
evento público EventHandler Haga clic en {
agregar {
Eventos.AddHandler (EventClick, valor);
}
eliminar {
Eventos.RemoveHandler(EventClick,valor);
}
}
Antes de definir la estructura de atributos del evento, primero debe definir el objeto delegado del evento Click. Dado que cada evento solo se crea una vez, debe declararse estático y de solo lectura. Luego, opere la lista de delegados del controlador de eventos a través de los métodos AddHandler y RemoveHandler en la estructura de propiedades. Cuando la página llama al evento Click, agrega o elimina controladores de la colección EventHandlerList del control. Dado que este método de implementación es más eficiente que el método de implementación ordinario en el proceso de declaración de múltiples eventos, es un método muy recomendado.
Además, durante la implementación del método OnClick, cuando se utiliza un atributo de evento, el delegado debe recuperarse de EventHandlerList y convertirse al tipo EventHandler.
vacío virtual protegido OnClick (EventArgs e) {
EventHandler clickHandler = (EventHandler)Eventos[EventClick];
if(clickHandler!= nulo) {
haga clic en Handler (este, e);
}
}
Tenga en cuenta a los lectores: la estructura de atributos del evento no es aplicable al lenguaje VB.NET y solo se puede aplicar en lenguajes como C#.
2. Aplicaciones típicas
Para ser honesto, la introducción teórica anterior a la captura de eventos de devolución de datos es algo difícil de entender para los lectores que nunca han implementado eventos de control del servidor. Con este fin, esta sección utiliza un ejemplo típico para ilustrar específicamente el método de implementación para capturar eventos de retorno.
Este ejemplo implementa un control de servidor personalizado WebCustomControl. Aunque este control aparece como un botón, no hereda de la clase Botón. Cuando se hace clic en el botón, el control provocará una devolución de datos y el servidor capturará automáticamente el evento de clic devuelto, activará el evento Click y ejecutará el controlador de eventos correspondiente. El siguiente es el código fuente de la implementación del control del servidor:
| usando Sistema; usando System.Collections.Generic; usando System.ComponentModel; usando System.Text; usando System.Web; utilizando System.Web.UI; usando System.Web.UI.WebControls; espacio de nombres WebControlLibrary{ [Evento predeterminado ("Clic")] [ToolboxData("<{0}:WebCustomControl runat=servidor>")] clase pública WebCustomControl: WebControl, IPostBackEventHandler { //Definir un objeto delegado de evento Click objeto privado de solo lectura estático EventClick = new object(); //Implementar propiedades del evento Click [Descripción("Propiedades del evento Click"), Categoría("Acción") ] evento público EventHandler Haga clic en { agregar { Eventos.AddHandler (EventClick, valor); } eliminar { Eventos.RemoveHandler (EventClick, valor); } } // Anula el método de renderizado de control RenderContents anulación protegida void RenderContents (salida de HtmlTextWriter) { salida.Write(" } //Implementar método de evento protected virtual void OnClick(EventArgs e) { EventHandler clickHandler = (EventHandler)Eventos[EventClick]; si (clickHandler! = nulo) { haga clic en Handler (esto, e); } } // Implementar el miembro de interfaz IPostBackEventHandler void IPostBackEventHandler.RaisePostBackEvent(string eventArgument) { Al hacer clic (EventArgs.Empty); } } } |
| <%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Hereda="_Default" %> <%@ Registrar TagPrefix="cc" Namespace="WebControlLibrary" Assembly="WebControlLibrary" %> |
  Figura 1 Representaciones de inicialización de página Figura 2 Efectos después de hacer clic en el botón |
| //Definir el atributo AutoPostBack público bool AutoPostBack{ colocar { this._autoPostBack = valor; } conseguir { devolver this._autoPostBack; } } //Agregar el método Page.GetPostBackEventReference() en el método Render anulación protegida Renderizado vacío (salida de HtmlTextWriter) { ... si(this.AutoPostBack) { escritor.WriteAttribute("ontextchanged","javascript:" + Page.GetPostBackEventReference(this)); } ... } |