Página de inicio Biblioteca Aprender Descargas Soporte técnico Comunidad
Iniciar sesión | United States - English | |
Personas que lo han encontrado útil: 0 de 1 - Valorar este tema

Button (Clase)

.NET Framework 4

Muestra un control de botón de comando en la página Web.

System.Object
  System.Web.UI.Control
    System.Web.UI.WebControls.WebControl
      System.Web.UI.WebControls.Button

Espacio de nombres:  System.Web.UI.WebControls
Ensamblado:  System.Web (en System.Web.dll)
C#
C++
F#
VB
Copiar 
public class Button : WebControl, IButtonControl, 
	IPostBackEventHandler
ASP.NET
Copiar 
<asp:Button />

El tipo Button expone los siguientes miembros.

  Nombre Descripción
Método público Button Inicializa una nueva instancia de la clase Button.
Arriba
  Nombre Descripción
Propiedad pública AccessKey Obtiene o establece la clave de acceso que permite navegar rápidamente al control de servidor web. (Se hereda de WebControl).
Propiedad protegida Adapter Obtiene el adaptador específico del explorador para el control. (Se hereda de Control).
Propiedad pública AppRelativeTemplateSourceDirectory Obtiene o establece el directorio virtual relativo a la aplicación del objeto Page o el objeto UserControl que contiene este control. (Se hereda de Control).
Propiedad pública Attributes Obtiene la colección de atributos arbitrarios (sólo para su representación) que no corresponden a propiedades del control. (Se hereda de WebControl).
Propiedad pública BackColor Obtiene o establece el color de fondo del control de servidor web. (Se hereda de WebControl).
Propiedad pública BindingContainer Infraestructura. Obtiene el control que contiene el enlace de datos de este control. (Se hereda de Control).
Propiedad pública BorderColor Obtiene o establece el color de borde del control Web. (Se hereda de WebControl).
Propiedad pública BorderStyle Obtiene o establece el estilo del borde del control de servidor web. (Se hereda de WebControl).
Propiedad pública BorderWidth Obtiene o establece el ancho del borde del control de servidor web. (Se hereda de WebControl).
Propiedad pública CausesValidation Obtiene o establece un valor que indica si la validación se realiza al hacer clic en el control Button.
Propiedad protegida ChildControlsCreated Obtiene un valor que indica si se han creado controles secundarios del control de servidor. (Se hereda de Control).
Propiedad pública ClientID Obtiene el identificador de control del formato HTML generado por ASP.NET. (Se hereda de Control).
Propiedad pública ClientIDMode Obtiene o establece el algoritmo que se utiliza para generar el valor de la propiedad ClientID. (Se hereda de Control).
Propiedad protegida ClientIDSeparator Obtiene un valor de carácter que representa el carácter separado utilizado en la propiedad ClientID. (Se hereda de Control).
Propiedad pública CommandArgument Obtiene o establece un parámetro opcional que se pasa al evento Command junto con la propiedad CommandName asociada.
Propiedad pública CommandName Obtiene o establece el nombre de comando asociado al control Button que se pasa al evento Command.
Propiedad protegida Context Obtiene el objeto HttpContext asociado al control de servidor para la solicitud Web actual. (Se hereda de Control).
Propiedad pública Controls Obtiene un objeto ControlCollection que representa los controles secundarios para un control de servidor especificado en la jerarquía de la interfaz de usuario. (Se hereda de Control).
Propiedad pública ControlStyle Obtiene el estilo del control de servidor web. Esta propiedad la usan principalmente los programadores de controles. (Se hereda de WebControl).
Propiedad pública ControlStyleCreated Obtiene un valor que indica si se ha creado un objeto Style para la propiedad ControlStyle. Esta propiedad la usan principalmente los programadores de controles. (Se hereda de WebControl).
Propiedad pública CssClass Obtiene o establece la clase hoja de estilo en cascada (CSS) presentada por el control de servidor web en el cliente. (Se hereda de WebControl).
Propiedad pública DataItemContainer Obtiene una referencia al contenedor de nomenclatura si este implementa IDataItemContainer. (Se hereda de Control).
Propiedad pública DataKeysContainer Obtiene una referencia al contenedor de nomenclatura si este implementa IDataKeysControl. (Se hereda de Control).
Propiedad protegida DesignMode Obtiene un valor que indica si se está utilizando un control en una superficie de diseño. (Se hereda de Control).
Propiedad pública Enabled Obtiene o establece un valor que indica si el control de servidor web está habilitado. (Se hereda de WebControl).
Propiedad pública EnableTheming Obtiene o establece un valor que indica si los temas se aplican a este control. (Se hereda de WebControl).
Propiedad pública EnableViewState Obtiene o establece un valor que indica si el control de servidor debe mantener su estado de vista y el de los controles secundarios que contiene, en el cliente que realiza la solicitud. (Se hereda de Control).
Propiedad protegida Events Obtiene una lista de delegados de controladores de eventos del control. Esta propiedad es de sólo lectura. (Se hereda de Control).
Propiedad pública Font Obtiene las propiedades de fuente asociadas al control de servidor web. (Se hereda de WebControl).
Propiedad pública ForeColor Obtiene o establece el color de primer plano (normalmente el color del texto) del control de servidor web. (Se hereda de WebControl).
Propiedad pública HasAttributes Obtiene un valor que indica si el control tiene establecido algún atributo. (Se hereda de WebControl).
Propiedad protegida HasChildViewState Obtiene un valor que indica si los controles secundarios del control de servidor actual tienen guardada alguna configuración del estado de vista. (Se hereda de Control).
Propiedad pública Height Obtiene o establece el alto del control de servidor Web. (Se hereda de WebControl).
Propiedad pública ID Obtiene o establece el identificador de programación asignado al control de servidor. (Se hereda de Control).
Propiedad protegida IdSeparator Infraestructura. Obtiene el carácter utilizado para separar los identificadores de control. (Se hereda de Control).
Propiedad protegida IsChildControlStateCleared Obtiene un valor que indica si los controles que se encuentran en este control tienen estado de control. (Se hereda de Control).
Propiedad protegida IsEnabled Obtiene un valor que indica si está habilitado el control. (Se hereda de WebControl).
Propiedad protegida IsTrackingViewState Obtiene un valor que indica si el control de servidor está guardando los cambios realizados en su estado de vista. (Se hereda de Control).
Propiedad protegida IsViewStateEnabled Obtiene un valor que indica si el estado de vista está habilitado para este control. (Se hereda de Control).
Propiedad protegida LoadViewStateByID Obtiene un valor que indica si el control participa en la carga de su estado de vista mediante ID en lugar de índice. (Se hereda de Control).
Propiedad pública NamingContainer Obtiene una referencia al contenedor de nomenclatura del control de servidor, que crea un espacio de nombres único para diferenciar los distintos controles de servidor que tienen el mismo valor para la propiedad Control.ID. (Se hereda de Control).
Propiedad pública OnClientClick Obtiene o establece el script de cliente que se ejecuta cuando se provoca un evento Click del control Button.
Propiedad pública Page Obtiene una referencia a la instancia Page que contiene el control de servidor. (Se hereda de Control).
Propiedad pública Parent Obtiene una referencia al control principal del control de servidor en la jerarquía de controles de página. (Se hereda de Control).
Propiedad pública PostBackUrl Obtiene o establece la dirección URL de la página de destino del envío desde la página actual cuando se hace clic en el control Button.
Propiedad pública RenderingCompatibility Obtiene o establece un valor que especifica la versión de ASP.NET compatible con los elementos HTML representados. (Se hereda de Control).
Propiedad pública Site Obtiene información sobre el contenedor en que se encuentra el control actual cuando se representa en una superficie de diseño. (Se hereda de Control).
Propiedad pública SkinID Obtiene o establece la máscara que se va a aplicar al control. (Se hereda de WebControl).
Propiedad pública Style Obtiene una colección de atributos de texto que se representan como atributo de estilo en la etiqueta externa del control de servidor web. (Se hereda de WebControl).
Propiedad pública SupportsDisabledAttribute Obtiene un valor que indica si el control debe establecer en "disabled" el atributo disabled del elemento HTML presentado cuando el valor de la propiedad IsEnabled del control es false. (Se hereda de WebControl).
Propiedad pública TabIndex Obtiene o establece el índice de tabulación del control de servidor web. (Se hereda de WebControl).
Propiedad protegida TagKey Obtiene el valor HtmlTextWriterTag correspondiente a este control de servidor web. Esta propiedad la usan principalmente los programadores de controles. (Se hereda de WebControl).
Propiedad protegida TagName Obtiene el nombre de la etiqueta del control. Esta propiedad la usan principalmente los programadores de controles. (Se hereda de WebControl).
Propiedad pública TemplateControl Obtiene o establece una referencia a la plantilla que contiene este control. (Se hereda de Control).
Propiedad pública TemplateSourceDirectory Obtiene el directorio virtual de Page o UserControl que contiene el control de servidor actual. (Se hereda de Control).
Propiedad pública Text Obtiene o establece el título de texto que se muestra en el control Button.
Propiedad pública ToolTip Obtiene o establece el texto que se muestra cuando el puntero del mouse se desplaza sobre el control de servidor web. (Se hereda de WebControl).
Propiedad pública UniqueID Obtiene el identificador único calificado jerárquicamente para el control de servidor. (Se hereda de Control).
Propiedad pública UseSubmitBehavior Obtiene o establece un valor que indica si el control Button utiliza el mecanismo de envío del explorador del cliente o el mecanismo de devolución de datos de ASP.NET.
Propiedad pública ValidationGroup Obtiene o establece el grupo de controles para los que el control Button ejecuta la validación cuando realiza devoluciones al servidor.
Propiedad protegida ViewState Obtiene un diccionario con información de estado que le permite guardar y restaurar el estado de vista de un control de servidor en las distintas solicitudes de la misma página. (Se hereda de Control).
Propiedad protegida ViewStateIgnoresCase Obtiene un valor que indica si el objeto StateBag no distingue mayúsculas de minúsculas. (Se hereda de Control).
Propiedad pública ViewStateMode Obtiene o establece el modo del estado de vista de este control. (Se hereda de Control).
Propiedad pública Visible Obtiene o establece un valor que indica si un control de servidor se debe representar como interfaz de usuario en la página. (Se hereda de Control).
Propiedad pública Width Obtiene o establece el ancho del control de servidor web. (Se hereda de WebControl).
Arriba
  Nombre Descripción
Método protegido AddAttributesToRender Infraestructura. Agrega los atributos del control Button al flujo de salida para representar en el cliente. (Invalida a WebControl.AddAttributesToRender(HtmlTextWriter)).
Método protegido AddedControl Se le llama una vez que se ha agregado un control secundario a la colección Controls del Control objeto. (Se hereda de Control).
Método protegido AddParsedSubObject Indica al control de servidor que se ha analizado un elemento, ya sea XML o HTML, y agrega dicho elemento al objeto ControlCollection del control de servidor. (Se hereda de Control).
Método público ApplyStyle Copia en el control Web todos los elementos no vacíos del estilo especificado, sobrescribiendo los elementos de estilo existentes del mismo. Este método lo usan principalmente los programadores de controles. (Se hereda de WebControl).
Método público ApplyStyleSheetSkin Aplica al control las propiedades de estilo definidas en la hoja de estilos de la página. (Se hereda de Control).
Método protegido BuildProfileTree Infraestructura. Recopila información sobre el control de servidor y la pasa a la propiedad Trace para que se muestre cuando está habilitada la traza de la página. (Se hereda de Control).
Método protegido ClearCachedClientID Infraestructura. Establece en null el valor de ClientID almacenado en caché. (Se hereda de Control).
Método protegido ClearChildControlState Elimina la información sobre el estado de control de los controles secundarios del control de servidor. (Se hereda de Control).
Método protegido ClearChildState Elimina la información sobre el estado de vista y el estado de control de los controles secundarios del control de servidor. (Se hereda de Control).
Método protegido ClearChildViewState Elimina la información sobre el estado de vista de todos los controles secundarios del control de servidor. (Se hereda de Control).
Método protegido ClearEffectiveClientIDMode Infraestructura. Establece la propiedad ClientIDMode de la instancia del control actual y de cualquier control secundario en Inherit. (Se hereda de Control).
Método público CopyBaseAttributes Copia las propiedades no encapsuladas por el objeto Style del control de servidor web especificado al control de servidor web desde el que se efectúa la llamada al método. Este método lo usan principalmente los programadores de controles. (Se hereda de WebControl).
Método protegido CreateChildControls Lo llama el marco de trabajo de las páginas ASP.NET para indicar a los controles de servidor que utilizan la implementación basada en la composición que creen los controles secundarios que contengan como forma de preparar la devolución o representación de los datos. (Se hereda de Control).
Método protegido CreateControlCollection Crea un nuevo objeto ControlCollection para guardar los controles secundarios (tanto literales como de servidor) del control de servidor. (Se hereda de Control).
Método protegido CreateControlStyle Crea el objeto de estilo que utiliza la clase WebControl de forma interna para implementar todas las propiedades relacionadas con el estilo. Este método lo usan principalmente los programadores de controles. (Se hereda de WebControl).
Método público DataBind() Enlaza un origen de datos al control de servidor invocado y a todos sus controles secundarios. (Se hereda de Control).
Método protegido DataBind(Boolean) Enlaza un origen de datos al control de servidor que se ha invocado y a todos sus controles secundarios con una opción para generar el evento DataBinding. (Se hereda de Control).
Método protegido DataBindChildren Enlaza un origen de datos a los controles secundarios del control de servidor. (Se hereda de Control).
Método público Dispose Habilita un control de servidor para que realice la limpieza final antes de que se libere de la memoria. (Se hereda de Control).
Método protegido EnsureChildControls Determina si el control de servidor contiene controles secundarios. Si no tiene controles secundarios, los crea. (Se hereda de Control).
Método protegido EnsureID Crea un identificador para controles que no tiene un identificador asignado. (Se hereda de Control).
Método público Equals(Object) Determina si el objeto Object especificado es igual al objeto Object actual. (Se hereda de Object).
Método protegido Finalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método público FindControl(String) Busca un control de servidor con el parámetro id especificado en el contenedor de nomenclatura actual. (Se hereda de Control).
Método protegido FindControl(String, Int32) Infraestructura. Busca el contenedor de nomenclatura actual para un control de servidor con el id especificado y un entero, que se especifica en el parámetro pathOffset, que ayuda a realizar la búsqueda. Esta versión del método FindControl no se debe reemplazar. (Se hereda de Control).
Método público Focus Establece el foco de entrada en un control. (Se hereda de Control).
Método protegido GetDesignModeState Infraestructura. Obtiene datos en tiempo de diseño para un control. (Se hereda de Control).
Método público GetHashCode Actúa como función hash para un tipo concreto. (Se hereda de Object).
Método protegido GetPostBackOptions Crea un objeto PostBackOptions que representa el comportamiento de devolución de datos del control Button.
Método público GetRouteUrl(Object) Obtiene la dirección URL que corresponde a un conjunto de parámetros de ruta. (Se hereda de Control).
Método público GetRouteUrl(RouteValueDictionary) Obtiene la dirección URL que corresponde a un conjunto de parámetros de ruta. (Se hereda de Control).
Método público GetRouteUrl(String, Object) Obtiene la dirección URL que corresponde a un conjunto de parámetros de ruta y un nombre de ruta. (Se hereda de Control).
Método público GetRouteUrl(String, RouteValueDictionary) Obtiene la dirección URL que corresponde a un conjunto de parámetros de ruta y un nombre de ruta. (Se hereda de Control).
Método público GetType Obtiene el objeto Type de la instancia actual. (Se hereda de Object).
Método público GetUniqueIDRelativeTo Devuelve la parte correspondiente al prefijo de la propiedad UniqueID del control especificado. (Se hereda de Control).
Método público HasControls Determina si el control de servidor contiene controles secundarios. (Se hereda de Control).
Método protegido HasEvents Devuelve un valor que indica si se registran eventos para el control o los controles secundarios. (Se hereda de Control).
Método protegido IsLiteralContent Infraestructura. Determina si el control de servidor alberga únicamente contenido literal. (Se hereda de Control).
Método protegido LoadControlState Restaura información de estado de control de una solicitud de página anterior guardada por el método SaveControlState. (Se hereda de Control).
Método protegido LoadViewState Restaura la información de estado de vista de una solicitud anterior guardada con el método SaveViewState. (Se hereda de WebControl).
Método protegido MapPathSecure Recupera la ruta de acceso física a la que se asigna una ruta de acceso virtual, absoluta o relativa. (Se hereda de Control).
Método protegido MemberwiseClone Crea una copia superficial del objeto Object actual. (Se hereda de Object).
Método público MergeStyle Copia en el control Web todos los elementos no vacíos del estilo especificado, pero no sobrescribe los elementos de estilo existentes en el mismo. Este método lo usan principalmente los programadores de controles. (Se hereda de WebControl).
Método protegido OnBubbleEvent Determina si el evento del control de servidor debe pasarse a la jerarquía de controles de servidor de la interfaz de usuario de la página. (Se hereda de Control).
Método protegido OnClick Provoca el evento Click del control Button.
Método protegido OnCommand Provoca el evento Command del control Button.
Método protegido OnDataBinding Provoca el evento DataBinding. (Se hereda de Control).
Método protegido OnInit Provoca el evento Init. (Se hereda de Control).
Método protegido OnLoad Provoca el evento Load. (Se hereda de Control).
Método protegido OnPreRender Determina si se ha hecho clic en el botón antes de representarlo en el cliente. (Invalida a Control.OnPreRender(EventArgs)).
Método protegido OnUnload Provoca el evento Unload. (Se hereda de Control).
Método protegido OpenFile Obtiene un objeto Stream utilizado para leer un archivo. (Se hereda de Control).
Método protegido RaiseBubbleEvent Asigna los orígenes del evento y su información al control principal del control. (Se hereda de Control).
Método protegido RaisePostBackEvent Provoca eventos del control Button cuando devuelve datos al servidor.
Método protegido RemovedControl Se le llama una vez que se ha quitado un control secundario de la colección Controls del Control objeto. (Se hereda de Control).
Método protegido Render Presenta el control en el sistema de escritura HTML especificado. (Se hereda de WebControl).
Método público RenderBeginTag Presenta la etiqueta HTML de apertura del control en el sistema de escritura especificado. Este método lo usan principalmente los programadores de controles. (Se hereda de WebControl).
Método protegido RenderChildren Envía el contenido del control secundario del control de servidor a un objeto HtmlTextWriter suministrado, que escribe el contenido que se va a representar en el cliente. (Se hereda de Control).
Método protegido RenderContents Presenta el contenido del control en el sistema de escritura especificado. (Invalida a WebControl.RenderContents(HtmlTextWriter)).
Método público RenderControl(HtmlTextWriter) Envía el contenido del control de servidor a un objeto HtmlTextWriter que se proporciona y almacena la información de traza sobre el control si dicha traza está habilitada. (Se hereda de Control).
Método protegido RenderControl(HtmlTextWriter, ControlAdapter) Coloca el contenido de un control de servidor en un objeto HtmlTextWriter proporcionado, utilizando un objeto ControlAdapter proporcionado. (Se hereda de Control).
Método público RenderEndTag Presenta la etiqueta HTML de cierre del control en el escritor especificado. Este método lo usan principalmente los programadores de controles. (Se hereda de WebControl).
Método protegido ResolveAdapter Obtiene el adaptador de controles que se encarga de representar el control especificado. (Se hereda de Control).
Método público ResolveClientUrl Obtiene una dirección URL que el explorador puede utilizar. (Se hereda de Control).
Método público ResolveUrl Convierte una dirección URL en una que el cliente solicitante pueda utilizar. (Se hereda de Control).
Método protegido SaveControlState Guarda los cambios de estado de un control de servidor que se hayan producido desde el momento en que se devolvieron al servidor los datos de la página. (Se hereda de Control).
Método protegido SaveViewState Guarda cualquier estado modificado después de invocar el método TrackViewState. (Se hereda de WebControl).
Método protegido SetDesignModeState Establece datos en tiempo de diseño para un control. (Se hereda de Control).
Método público SetRenderMethodDelegate Infraestructura. Asigna un delegado de controlador de eventos para representar el control de servidor y su contenido en el control principal. (Se hereda de Control).
Método público ToString Devuelve una cadena que representa el objeto actual. (Se hereda de Object).
Método protegido TrackViewState Hace que el control efectúe un seguimiento de los cambios de su estado de vista para que se puedan almacenar en la propiedad ViewState del objeto. (Se hereda de WebControl).
Arriba
  Nombre Descripción
Evento público Click Se produce cuando se hace clic en el control Button.
Evento público Command Se produce cuando se hace clic en el control Button.
Evento público DataBinding Se produce cuando el control de servidor se enlaza a un origen de datos. (Se hereda de Control).
Evento público Disposed Se produce cuando un control de servidor se libera de la memoria, lo que constituye la última fase del período de duración de un control de servidor cuando se solicita una página ASP.NET. (Se hereda de Control).
Evento público Init Tiene lugar al inicializar el control de servidor, que es el primer paso en su ciclo de vida. (Se hereda de Control).
Evento público Load Se produce cuando el control de servidor se carga en el objeto Page. (Se hereda de Control).
Evento público PreRender Se produce una vez que se carga el objeto Control, pero antes de su representación. (Se hereda de Control).
Evento público Unload Se produce cuando el control de servidor se descarga de la memoria. (Se hereda de Control).
Arriba
  Nombre Descripción
Método de extensión público FindDataSourceControl Devuelve el origen de datos que está asociado al control de datos del control especificado. (Definido por DynamicDataExtensions).
Método de extensión público FindFieldTemplate Devuelve la plantilla de campo para la columna especificada en el contenedor de nomenclatura del control especificado. (Definido por DynamicDataExtensions).
Método de extensión público FindMetaTable Devuelve el objeto de metatabla para el control de datos contenedor. (Definido por DynamicDataExtensions).
Arriba
  Nombre Descripción
Implementación explícita de interfaces Método privado IAttributeAccessor.GetAttribute Infraestructura. Obtiene un atributo del control Web con el nombre especificado. (Se hereda de WebControl).
Implementación explícita de interfaces Método privado IAttributeAccessor.SetAttribute Establece un atributo del control Web con el nombre y el valor especificados. (Se hereda de WebControl).
Implementación explícita de interfaces Propiedad privada IControlBuilderAccessor.ControlBuilder Para obtener una descripción de este miembro, vea IControlBuilderAccessor.ControlBuilder. (Se hereda de Control).
Implementación explícita de interfaces Método privado IControlDesignerAccessor.GetDesignModeState Para obtener una descripción de este miembro, vea IControlDesignerAccessor.GetDesignModeState. (Se hereda de Control).
Implementación explícita de interfaces Método privado IControlDesignerAccessor.SetDesignModeState Para obtener una descripción de este miembro, vea IControlDesignerAccessor.SetDesignModeState. (Se hereda de Control).
Implementación explícita de interfaces Método privado IControlDesignerAccessor.SetOwnerControl Infraestructura. Para obtener una descripción de este miembro, vea IControlDesignerAccessor.SetOwnerControl. (Se hereda de Control).
Implementación explícita de interfaces Propiedad privada IControlDesignerAccessor.UserData Para obtener una descripción de este miembro, vea IControlDesignerAccessor.UserData. (Se hereda de Control).
Implementación explícita de interfaces Propiedad privada IDataBindingsAccessor.DataBindings Para obtener una descripción de este miembro, vea IDataBindingsAccessor.DataBindings. (Se hereda de Control).
Implementación explícita de interfaces Propiedad privada IDataBindingsAccessor.HasDataBindings Para obtener una descripción de este miembro, vea IDataBindingsAccessor.HasDataBindings. (Se hereda de Control).
Implementación explícita de interfaces Propiedad privada IExpressionsAccessor.Expressions Para obtener una descripción de este miembro, vea IExpressionsAccessor.Expressions. (Se hereda de Control).
Implementación explícita de interfaces Propiedad privada IExpressionsAccessor.HasExpressions Para obtener una descripción de este miembro, vea IExpressionsAccessor.HasExpressions. (Se hereda de Control).
Implementación explícita de interfaces Método privado IParserAccessor.AddParsedSubObject Para obtener una descripción de este miembro, vea IParserAccessor.AddParsedSubObject. (Se hereda de Control).
Implementación explícita de interfaces Método privado IPostBackEventHandler.RaisePostBackEvent Provoca eventos del control Button cuando devuelve datos al servidor.
Arriba

En este tema:

Introduction

Utilice el control Button para crear un botón de comando en la página web que permite a los usuarios enviar por correo una página al servidor. El control desencadena un evento en el código del servidor que puede controlar para responder al postback. También puede generar un evento en script de cliente que puede administrar antes de que se exponga la página o que se puede ejecutar y, a continuación, cancelar el envío de la página.

Nota Nota

ASP.NET incluye varios tipos de controles de botón, cada uno de los cuales aparece de manera diferente en las páginas web. Son el control Button, que se representa como un botón de comando; el control LinkButton, que se representa como un vínculo; y el control ImageButton, que se representa como una imagen; además, el control ImageMap, le permite crear un gráfico con zonas activas en las que los usuarios pueden hacer clic. De forma predeterminada, todos los controles de botón envían la página cuando se hace clic en ellos. También puede utilizar los controles HtmlButton y HtmlInputButton para crear botones en la página que se puedan programar en el código del servidor. Para obtener información detallada sobre las diferencias que existen entre los controles HTML y los controles de servidor Web, vea Información general sobre los controles de servidor web ASP.NET.

De manera predeterminada, un control Button es un botón Enviar. Un botón Enviar no tiene asociado un nombre de comando (especificado por la propiedad CommandName) y simplemente devuelve la página Web al servidor. Se puede proporcionar un controlador de eventos para el evento Click con el fin de controlar mediante programación las acciones realizadas cuando se hace clic en el botón Enviar.

Un botón Comando puede tener asociado un nombre de comando, como Sort, mediante el establecimiento de la propiedad CommandName. Esto permite crear varios controles Button en una página Web y determinar mediante programación en qué control Button se hace clic. También se puede usar la propiedad CommandArgument con un botón de comando para facilitar información adicional sobre el comando que se va a ejecutar, como Ascending. Se puede proporcionar un controlador de eventos para el evento Command con el fin de controlar mediante programación las acciones realizadas cuando se hace clic en el botón Comando.

Comportamiento de postback de los botones y eventos de servidor

Cuando un usuario hace clic en cualquier botón de control de servidor web, la página se envía al servidor. Esto hace que se procese la página Web y que se desencadenen los eventos pendientes en el código del servidor. Cuando todo el procesamiento de páginas y controles ha finalizado, la página se representa de nuevo en el explorador.

Los botones pueden generar sus propios eventos Click o el evento Command, que puede administrar usando el código basado en servidor. Esto es diferente a los eventos en páginas HTML tradicionales o en aplicaciones web basadas en cliente, donde el evento onclick de un botón se administra mediante JavaScript que se ejecuta en el cliente. Para obtener más información, vea Modelo de eventos de control de servidor web ASP.NET.

Cuando los usuarios hacen clic en un control de botón, la página se envía al servidor. De forma predeterminada, la página se devuelve datos a sí misma,

Puede configurar los botones para que envíen la página actual a otra página. Esto puede resultar útil para crear formularios de varias páginas. Para obtener información detallada, vea Envío entre páginas en las páginas Web ASP.NET.

Administrar los eventos de botón en el script de cliente

Los controles de botón pueden desencadenar eventos de servidor y eventos de cliente. Los eventos de servidor se producen después de la devolución de datos y se controlan en el código del servidor que se ha escrito para la página. Los eventos de cliente se controlan en un script de cliente, normalmente ECMAScript (JavaScript), y se desencadenan antes de que se envíe la página. Si agrega eventos de cliente a los controles de botón de ASP.NET, puede realizar tareas, como mostrar los cuadros de diálogo de confirmación antes de enviar la página y cancelar el posible envío. Para obtener información detallada, vea Scripts de cliente en páginas Web ASP.NET y Cómo: Responder a los eventos de un control Button de servidor web en un script de cliente.

Puede desear el control Button para también usar el script de cliente para realizar un postback (en lugar de simplemente realizar una operación Http POST). Esto puede resultar útil si quiere manipular la devolución de datos mediante programación, para adjuntarla, por ejemplo, a otros elementos de la página. Puede establecer la propiedad UseSubmitBehavior del control Button en true para hacer que el control Button utilice una devolución de datos basada del script de cliente.

Controles de botón y validación

Si una página contiene controles validadores de ASP.NET, de forma predeterminada, al hacer clic en un control de botón, el control de validación realiza su comprobación. Si la validación del cliente se habilita en un control validador, no se envía la página si se produce un error en una comprobación de validación.

En la tabla siguiente se describen las propiedades admitidas por los controles de botón que permiten controlar el proceso de validación con más precisión.

Propiedad

Descripción

CausesValidation

Especifica si al hacer clic en el botón, también se realiza una comprobación de validación. Establezca esta propiedad en false para impedir que se ejecute una comprobación de validación.

ValidationGroup

Le permite especificar qué validadores de la página se invocan cuando se hace clic en el botón. Si no se ha establecido ningún grupo de validaciones, al hacer clic en el botón se invocan los validadores que están en la página.

Para obtener más información, vea Validar la información especificada por el usuario en páginas web ASP.NET.

Botones en controles de datos

Los controles de botón de servidor Web se utilizan a menudo en controles de datos, como en los controles de lista DataList, GridView y Repeater. En esos casos, normalmente no se responde directamente al evento de clic de botón. En su lugar, un botón en un control de datos genera un evento que es específico del control de datos. Por ejemplo, en el control DataList, un botón podría desencadenar el evento ItemCommand del control DataList en lugar del evento Click del control Button.

Dado que los controles de lista enlazados a datos pueden contener muchos botones diferentes, puede establecer la propiedad CommandArgument del botón para especificar un valor que se transfiera como parte del evento. Después, podrá comprobar este argumento para ver en qué botón se hizo clic.

Enlazar datos a los controles

Puede enlazar los controles de botón de servidor Web a un origen de datos para controlar dinámicamente la configuración de sus propiedades. Por ejemplo, puede establecer la propiedad Text de un botón usando el enlace de datos.

Utilizar los botones con controles UpdatePanel

La representación de la página parcial hace posible actualizar partes de una página sin un postback. Los controles UpdatePanel le permiten marcar las partes de la página que participan en la representación parcial de la página. De forma predeterminada, el comportamiento de los controles dentro de un control UpdatePanel, incluidos los controles Button, es realizar postback asincrónico en vez de un postback. Esto actualiza sólo el contenido del control UpdatePanel del que se origina el postback.

Además del escenario de un control Button que está dentro de un control UpdatePanel, puede utilizar los controles Button con controles UpdatePanel en los siguientes escenarios:

  • Definir un control Button que está fuera de un control UpdatePanel como un control AsyncPostBackTrigger para ese panel. Cuando se hace clic en el botón, se realiza un postback asincrónico y se actualiza el contenido del panel.

  • Definir un control Button que está dentro de un control UpdatePanel como un PostBackTrigger para el panel. Cuando se hace clic en el botón, se realiza un postback aunque sea dentro de un control UpdatePanel.

Para obtener más información sobre la representación parcial de la página y sobre cómo utilizar controles UpdatePanel vea Información general sobre el control UpdatePanel y Información general sobre la representación parcial de páginas.

Sintaxis de la declaración

Copiar 
<asp:Button
    AccessKey="string"
    BackColor="color name|#dddddd"
    BorderColor="color name|#dddddd"
    BorderStyle="NotSet|None|Dotted|Dashed|Solid|Double|Groove|Ridge|
        Inset|Outset"
    BorderWidth="size"
    CausesValidation="True|False"
    CommandArgument="string"
    CommandName="string"
    CssClass="string"
    Enabled="True|False"
    EnableTheming="True|False"
    EnableViewState="True|False"
    Font-Bold="True|False"
    Font-Italic="True|False"
    Font-Names="string"
    Font-Overline="True|False"
    Font-Size="string|Smaller|Larger|XX-Small|X-Small|Small|Medium|
        Large|X-Large|XX-Large"
    Font-Strikeout="True|False"
    Font-Underline="True|False"
    ForeColor="color name|#dddddd"
    Height="size"
    ID="string"
    OnClick="Click event handler"
    OnClientClick="string"
    OnCommand="Command event handler"
    OnDataBinding="DataBinding event handler"
    OnDisposed="Disposed event handler"
    OnInit="Init event handler"
    OnLoad="Load event handler"
    OnPreRender="PreRender event handler"
    OnUnload="Unload event handler"
    PostBackUrl="uri"
    runat="server"
    SkinID="string"
    Style="string"
    TabIndex="integer"
    Text="string"
    ToolTip="string"
    UseSubmitBehavior="True|False"
    ValidationGroup="string"
    Visible="True|False"
    Width="size"
/>

En el ejemplo de código siguiente se muestra cómo crear un control Button de envío que devuelve el contenido de la página Web al servidor.

C#
VB
Copiar 

<%@ Page Language="C#" AutoEventWireup="True" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
    <title>Button Example</title>
<script language="C#" runat="server">

      void SubmitBtn_Click(Object sender, EventArgs e) 
      {
         Message.Text="Hello World!!";
      }

   </script>
</head>
<body>
   <form id="form1" runat="server">

      <h3>Button Example</h3>

      Click on the submit button.<br /><br />

      <asp:Button id="Button1"
           Text="Submit"
           OnClick="SubmitBtn_Click" 
           runat="server"/>

      <br />

      <asp:label id="Message" runat="server"/>

   </form>
</body>
</html>

En el ejemplo de código siguiente se muestra cómo crear un control Button de comando que ordena una lista.

C#
VB
Copiar 

<%@ Page Language="C#" AutoEventWireup="True" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Button CommandName Example</title>
<script runat="server">

      void CommandBtn_Click(Object sender, CommandEventArgs e) 
      {

         switch(e.CommandName)
         {

            case "Sort":

               // Call the method to sort the list.
               Sort_List((String)e.CommandArgument);
               break;

            case "Submit":

               // Display a message for the Submit button being clicked.
               Message.Text = "You clicked the Submit button";

               // Test whether the command argument is an empty string ("").
               if((String)e.CommandArgument == "")
               {
                  // End the message.
                  Message.Text += ".";
               }
               else
               {
                  // Display an error message for the command argument. 
                  Message.Text += ", however the command argument is not recogized.";
               }                
               break;

            default:

               // The command name is not recognized. Display an error message.
               Message.Text = "Command name not recogized.";
               break; 

         }

      }

      void Sort_List(string commandArgument)
      {

         switch(commandArgument)
         {

            case "Ascending":

               // Insert code to sort the list in ascending order here.
               Message.Text = "You clicked the Sort Ascending button.";
               break;

            case "Descending":

               // Insert code to sort the list in descending order here.
               Message.Text = "You clicked the Sort Descending button.";
               break;

            default:

               // The command argument is not recognized. Display an error message.
               Message.Text = "Command argument not recogized.";
               break;

         }

      }

   </script>

</head>

<body>

   <form id="form1" runat="server">

      <h3>Button CommandName Example</h3>

      Click on one of the command buttons.

      <br /><br />

      <asp:Button id="Button1"
           Text="Sort Ascending"
           CommandName="Sort"
           CommandArgument="Ascending"
           OnCommand="CommandBtn_Click" 
           runat="server"/>

      &nbsp;

      <asp:Button id="Button2"
           Text="Sort Descending"
           CommandName="Sort"
           CommandArgument="Descending"
           OnCommand="CommandBtn_Click" 
           runat="server"/>

      <br /><br />

      <asp:Button id="Button3"
           Text="Submit"
           CommandName="Submit"
           OnCommand="CommandBtn_Click" 
           runat="server"/>

      &nbsp;

      <asp:Button id="Button4"
           Text="Unknown Command Name"
           CommandName="UnknownName"
           CommandArgument="UnknownArgument"
           OnCommand="CommandBtn_Click" 
           runat="server"/>

      &nbsp;

      <asp:Button id="Button5"
           Text="Submit Unknown Command Argument"
           CommandName="Submit"
           CommandArgument="UnknownArgument"
           OnCommand="CommandBtn_Click" 
           runat="server"/>

      <br /><br />

      <asp:Label id="Message" runat="server"/>

   </form>

</body>
</html>

.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.
¿Le ha resultado útil?
(Caracteres restantes: 1500)
Contenido de la comunidad Agregar
Anotaciones Preguntas más frecuentes
frm
private String NombreFichero = "";
        private bool swHayCambios = false;
        public Form1()
        {
            InitializeComponent();
        }

        private void lstvLista_SelectedIndexChanged(object sender, EventArgs e)
        {
            Estado();
        }

     
        public bool HayAmarillos()
        {
            bool swColor = false;
            for (int i = 0; i < lvwLista.Items.Count; i++)
            {
                if (lvwLista.Items[i].BackColor == Color.Yellow)
                {
                    swColor = true;
                    break;
                }
            }
            return swColor;
        }


        public void Estado()
        {
            bool sw = lvwLista.Items.Count > 0;
            lvwLista.Enabled = sw;
            cmbBuscar.Enabled = sw;
            cmdBuscar.Enabled = sw;
            
            bool sw1 = lvwLista.SelectedItems.Count > 0;
            cmdEliminar.Enabled = sw1;
            cmdModificar.Enabled = sw1;
            eliminarToolStripMenuItem.Enabled = sw1;
            modificarToolStripMenuItem.Enabled = sw1;
            
            cmdBorrar.Enabled = HayAmarillos();
            lblPie.Text = "En lista: " + lvwLista.Items.Count + " contactos";
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            cmbBuscar.Select();
            for (int i = 0; i < lvwLista.Items.Count; i++)
            {
                lvwLista.Items[i].BackColor = SystemColors.Control;
            }
            abrirToolStripMenuItem_Click(null, null);
           
            Estado();
        }


--------------------------------------------------------------------------------------------
   private void cmdguardar_Click(object sender, EventArgs e)
        {
            guardarToolStripMenuItem_Click(null, null);
        }

        private void nuevoToolStripMenuItem_Click(object sender, EventArgs e)
        {
            cmdInsertar_Click(null, null);
        }
Historial
button
private void cmdBuscar_Click(object sender, EventArgs e)
        {//combo
            string buscar = cmbBuscar.Text.Trim();
            bool swIns = true;
            cmdBuscar.Select();
            for (int i = 0; i < cmbBuscar.Items.Count; i++)
            {
                if (buscar.Equals(cmbBuscar.Items[i].ToString(),StringComparison.CurrentCultureIgnoreCase))
                {
                    swIns = false;
                    break;
                }
            }
            if (swIns)
            {
                cmbBuscar.Items.Add(buscar);
            }
            cmdBorrar_Click(null, null);
            for (int i = 0; i < lvwLista.Items.Count; i++)
            {
                if(lvwLista.Items[i].Text.StartsWith(cmbBuscar.Text.ToUpper()))
                lvwLista.Items[i].BackColor = Color.Yellow;                
            }
            cmbBuscar.Select();
            Estado();
        }

private void cmBuscar_Enter(object sender, EventArgs e)
        {
            cmbBuscar.SelectAll();
        }

----------------------------------------------------------------------------------------------------------------------------------------

 private void cmdBorrar_Click(object sender, EventArgs e)
        {//combo
           
            for (int i = 0; i < lvwLista.Items.Count; i++)
            {
                if(lvwLista.Items[i].BackColor==Color.Yellow)
                    lvwLista.Items[i].BackColor = Color.White;
            }
            Estado();
        }
----------------------------------------------------------------------------------------------------------------------------------------

private void cmdInsertar_Click(object sender, EventArgs e)
        {
            formNuevoModificar frm = new formNuevoModificar();

            frm.enlace = null;
            frm.ShowDialog();

            if (frm.DialogResult == DialogResult.OK)
            {
                ListViewItem fila = lvwLista.Items.Add(frm.enlace.NuevaLinea());
                fila.Selected = true;
                lvwLista.Select();
                Estado();
                swHayCambios = true;
            }

            frm.Dispose();
           
        }

        private void cmdModificar_Click(object sender, EventArgs e)
        {
            formNuevoModificar frm = new formNuevoModificar();

            frm.enlace = (Agenda)lvwLista.SelectedItems[0].Tag;
            frm.ShowDialog();
            int pos = lvwLista.SelectedIndices[0];

            if (frm.DialogResult == DialogResult.OK)
            {
                frm.enlace.CargarDatos(lvwLista.SelectedItems[0]);
                lvwLista.Select();
                Estado();
                swHayCambios = true;
            }
            lvwLista.Select();
            frm.Dispose();
           
        }

  private void cmdEliminar_Click(object sender, EventArgs e)
        {
            Agenda ag = (Agenda)lvwLista.SelectedItems[0].Tag;
            String ss = "¿Desea eliminar el contacto [" + ag.Nombre +"]?";
            DialogResult resp = MessageBox.Show(ss, this.Text, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation);
            if (resp == DialogResult.Yes)
            {
                cmdEliminar.Select();

                for (int i = lvwLista.SelectedItems.Count - 1; i >= 0; i--)
                {
                    lvwLista.Items.Remove(lvwLista.SelectedItems[i]);
                   
                }
                swHayCambios = true;
            }
            Estado();
           
        }

  private void cmdVolcar_Click(object sender, EventArgs e)
        {
            txtVolcado.Clear();
            if (lvwLista.CheckedItems.Count > 0)
            {
                txtVolcado.Enabled = true;               
                txtVolcado.Text = "Volcado: ";

                for (int i = 0; i < lvwLista.CheckedItems.Count; i++)
                {
                    txtVolcado.Text += "----------------------------------------";
                    txtVolcado.Text += lvwLista.CheckedItems[i].Text + " Tlfno:" + lvwLista.CheckedItems[i].SubItems[1].Text + " Movil:" + lvwLista.CheckedItems[i].SubItems[2].Text + "";
                }
                txtVolcado.Text += "----------------------------------------";
            }
            else
            {
                txtVolcado.Enabled = false;
            }
        }

        private void cmdFiltro_Click(object sender, EventArgs e)
        {
            FormFiltro frm = new FormFiltro();
            frm.lvwOrigen = this.lvwLista;
            frm.buscar = cmbBuscar.Text;
            frm.ShowDialog();
           
            frm.Dispose();
        }
Historial