Información general sobre controles de usuario frente a controles personalizados

Seleccione idioma Seleccione idioma
Id. de artículo: 893667 - Ver los productos a los que se aplica este artículo
Columna de voz de soporte ASP.NET

Información general sobre controles de usuario frente a controles personalizados

para personalizar esta columna a sus necesidades, deseamos invitar a enviar sus ideas sobre temas que le interesen y resuelve los problemas que se desea ver artículos de Knowledge Base en el futuro y columnas de voz de soporte. Puede enviar sus ideas y comentarios mediante el formulario Ask For It. También es un vínculo al formulario en la parte inferior de esta columna.
Expandir todo | Contraer todo

En esta página

Introducción

Hola! Se trata de Parag y Soy ingeniero de soporte técnico trabajar con el grupo de soporte técnico de Microsoft ASP.NET para ahora más de un año. Antes para unirse a Microsoft, he trabajado proyectos basados en Web y aplicaciones de escritorio utilizando las tecnologías de Microsoft. Mientras proporciona soporte técnico de calidad a los clientes, he visto donde hubo alguna confusión en controles personalizados y me gustaría Tómese tiempo para explicar algunos conceptos alrededor de controles personalizados. Como mala como parece, cree me, una vez que el bloqueo de ella, estará en una mejor posición para apreciar ASP.NET.

Información general

En la columna de este mes, Hablaré sobre los temas siguientes:
  • ¿Cuáles son los controles de usuario?
  • Qué son los controles personalizados
  • ¿Qué son las diferencias básicas entre controles de usuario y controles personalizados?
También presentaré a algunas de los temas avanzados que conciernen a controles personalizados, tales como administración de estado y la representación de controles personalizados.

¿Cuáles son los controles de usuario?

Controles de usuario son controles personalizados y reutilizables, y utilizan las mismas técnicas que se emplean los controles de servidor Web y HTML. Ofrecen una forma sencilla de dividir y reutilizar interfaces de usuario comunes entre las aplicaciones Web ASP.NET. Utilizan el mismo modelo de programación de formularios Web Forms en el que una página de formularios Web Forms funciona. Para obtener más detalles sobre el modelo de programación de formularios Web Forms, visite los siguientes sitios Web de Microsoft Developer Network (MSDN):
Introducción a las páginas de formularios Web Forms
http://msdn2.microsoft.com/en-us/library/65tcbxz3(vs.71).aspx

Modelo de código de formularios Web
http://msdn2.microsoft.com/en-us/library/015103yb(vs.71).aspx

Cómo crear un control de usuario

La sintaxis que se utiliza para crear un control de usuario es similar a la sintaxis que utiliza para crear una página de formularios Web Forms (.aspx). La única diferencia es que un control de usuario no incluye el <html> <body>, y <form> elementos desde una página de formularios Web Forms hospeda el control de usuario. Para crear un control de usuario, siga estos pasos:
  1. Abra un editor de HTML o texto y cree un bloque de código del lado del servidor exponer propiedades, métodos y eventos.
    <script language="C#" runat="server">
       public void button1_Click(object sender, EventArgs e)
       {
          label1.Text = "Hello World!!!";
       }
    </script>
    
  2. Crear una interfaz de usuario para el control de usuario.
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

Cómo utilizar un control de usuario en una página de formularios Web Forms

  1. Crear una nueva página de formularios Web Forms (.aspx) en Visual Studio .NET 2002, Visual Studio .NET 2003, Microsoft Visual Studio 2005 o en cualquier editor de texto.
  2. Declare la directiva @ Register . Por ejemplo, puede utilizar el código siguiente.
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    Nota suponer que el control de usuario y la página de formularios Web Forms están en la misma ubicación.
  3. Para utilizar el control de usuario en la página de formularios Web Forms, utilice el siguiente código después de la directiva @ Register .
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

Cómo crear una instancia de un control de usuario mediante programación en el archivo de código subyacente de una página de formularios Web Forms

El ejemplo anterior crean instancias de un control de usuario mediante declaración en una página de formularios Web Forms mediante la directiva @ Register . Sin embargo, puede crear dinámicamente una instancia de un control de usuario y agregar a la página. Éstos son los pasos para hacer:
  1. Crear una nueva página de formularios Web Forms en Visual Studio.
  2. Desplácese hasta el archivo generado para esta página de formularios Web Forms de código subyacente.
  3. En el evento Page_Load de la clase Page , escritura la code.
    // Load the control by calling LoadControl on the page class.
    Control c1 = LoadControl("test.ascx");
                
    // Add the loaded control in the page controls collection.	
    Page.Controls.Add(c1);
    
    Nota se puede agregar un control usuario dinámicamente en determinados eventos de ciclo de vida de página.

    Para obtener más información, visite los siguientes sitios Web:
    Agregar controles a una página de formularios Web Forms mediante programación
    http://msdn2.microsoft.com/en-us/library/kyt0fzt1(vs.71).aspx

    Ciclo vital de ejecución de control
    http://msdn2.microsoft.com/en-us/library/aa719775(vs.71).aspx

    Controles de Web dinámicos, devoluciones y estado de vista por Scott Mitchell
    http://aspnet.4guysfromrolla.com/articles/092904-1.aspx

Cómo se procesa un control de usuario

Cuando se solicita una página con un control de usuario, ocurre lo siguiente:
  • El Analizador de páginas analiza el archivo .ascx especificado en el atributo Src de la directiva @ Register y genera una clase que deriva de la clase System.Web.UI.UserControl .
  • A continuación, el Analizador compila dinámicamente la clase en un ensamblado.
  • Si utiliza Visual Studio, a continuación, sólo en tiempo de diseño, Visual Studio crea un código de archivo para el control de usuario y el archivo está precompilado por el Diseñador de sí mismo.
  • Por último, la clase del control de usuario, que se genera el proceso de generación de código dinámico y compilación, incluye el código para el archivo de código subyacente (. ascx.cs), así como el código escrito dentro del archivo .ascx.

Qué son los controles personalizados

Controles personalizados son componentes de código compilado que ejecutan en el servidor, exponen el modelo de objetos y representan texto marcado como HTML o XML, como un control de formularios Web Forms o un usuario normal.

Cómo elegir la clase base para el control personalizado

Para escribir un control personalizado, deberá directa o indirectamente derivar la nueva clase de la clase System.Web.UI.Control o de la clase System.Web.UI.WebControls.WebControl :
  • Si desea que el control para representar elementos no visuales debe derivar de System.Web.UI.Control . Por ejemplo, <meta> y <head> es ejemplos de representación no Visual.
  • Si desea que el control para representar HTML que genera una interfaz visual en el equipo cliente debe derivar de System.Web.UI.WebControls.WebControl .
Si desea cambiar la funcionalidad de controles existentes, como un botón o etiqueta, usted directamente puede derivar la nueva clase con estas clases existentes y puede cambiar su comportamiento predeterminado.

En resumen, la clase de control proporciona la funcionalidad básica que pueda colocarlo en el árbol de control para una clase de página . La clase WebControl agrega la funcionalidad a la clase base control para mostrar el contenido visual en el equipo cliente. Por ejemplo, puede utilizar la clase WebControl para controlar el aspecto y estilos mediante propiedades como fuente, color y alto.

Cómo crear y utilizar un control personalizado simple que abarca desde System.Web.UI.control utilizando Visual Studio

  1. Inicie Visual Studio.
  2. Cree un proyecto de biblioteca de clases y asígnele un nombre, por ejemplo, CustomServerControlsLib.
  3. Agregar un archivo de código fuente al proyecto, por ejemplo, SimpleServerControl.cs.
  4. Incluir la referencia del espacio de nombres System.Web en la sección de referencias.
  5. Compruebe si los espacios de nombres siguientes están incluidos en el archivo SimpleServerControl.cs.
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
  6. Herede la clase SimpleServerControls con la clase base control .
    public class SimpleServerControl : Control
  7. Reemplazar el método Render para escribir el resultado en la secuencia de salida.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    Nota La clase HtmlTextWriter tiene la funcionalidad de escritura de HTML en una secuencia de texto. El método Write de la clase HtmlTextWriter envía el texto especificado en la secuencia de respuesta HTTP y es el mismo que el método Response.Write .
  8. Compilar el proyecto de biblioteca de clase. Se generará el resultado DLL.
  9. Abra una existente o cree un nuevo proyecto de aplicación Web ASP.NET.
  10. Agregar una página Web Forms donde se puede utilizar el control personalizado.
  11. Agregar una referencia a la biblioteca de clase en la sección de referencias del proyecto ASP.NET.
  12. Registrar el control personalizado en la página de formularios Web Forms.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. Para crear una instancia o utilizar el control personalizado en la página de formularios Web Forms, agregue la siguiente línea de código en las etiquetas <form>.
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    Nota en este código SimpleServerControl es el nombre de clase de control dentro de la biblioteca de clase.
  14. Ejecutar la página de formularios Web Forms y verá el resultado de control personalizado.
Si no se utiliza Visual Studio, deberá realizar los pasos siguientes:
  1. Abra cualquier editor de texto.
  2. Cree un archivo denominado SimpleServerControl.cs y escribir el código como se muestra en los pasos 1 a 14.
  3. En la variable PATH, agregue la ruta de acceso siguiente:
    c:\Windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Inicie un símbolo del sistema y vaya a la ubicación donde SimpleServerControl.cs está presente.
  5. Ejecute el comando siguiente:
    csc/t: library/out: CustomServerControlsLib. SimpleServerControl.dll/r: System. dll / /r:System.Web.dll SimpleServerControl.cs
    Para obtener más información sobre el compilador de C# (csc.exe), visite el siguiente sitio Web de MSDN:
    http://msdn2.microsoft.com/en-us/library/1700bbwd(vs.71).aspx
  6. Para ejecutar el control personalizado en la página de formularios Web Forms, haga lo siguiente:
    1. Cree un directorio bajo la carpeta wwwroot.
    2. Inicie el Administrador de servicios de Internet Information Server (IIS) y marque el nuevo directorio como directorio raíz virtual.
    3. Cree una carpeta bin bajo el directorio nuevo.
    4. Copie el archivo DLL personalizado del control en la carpeta bin.
    5. Coloque la página de formularios Web Forms de ejemplo que creó en los pasos anteriores dentro del directorio nuevo.
    6. Ejecute la página de ejemplo desde el Administrador de IIS.
Ahora que ha creado un control personalizado simple, veamos cómo exponer propiedades y aplicar atributos de tiempo de diseño en dicho control personalizado.

Cómo exponer propiedades en el control personalizado

Se genere en el ejemplo anterior y presentar una o más propiedades que se pueden configurar mientras utiliza el control personalizado en la página de formularios Web Forms.

En el ejemplo siguiente se muestra cómo definir una propiedad que se mostrará un mensaje desde el control de un determinado número de veces, como se especifica en la propiedad del control:
  1. Abra SimpleServerControl.cs en un editor de texto.
  2. Agregar una propiedad de la clase SimpleServerControl . clase pública
    public class SimpleServerControl : Control
    {
       private int noOfTimes;
       public int NoOfTimes
       {
           get { return this.noOfTimes; }
           set { this.noOfTimes = value; }
       } 
       protected override void Render (HtmlTextWriter writer)
       {
         for (int i=0; i< NoOfTimes; i++)
         {
           write.Write("Hello World.."+"<BR>");
         } 
       }
    }
    
  3. Compilar el control personalizado.
  4. Para utilizar el control personalizado en la página de formularios Web Forms, agregar la nueva propiedad a la declaración del control.
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. Ejecutar la página se mostrará el mensaje "Hello world" desde el control personalizado tantas veces como especificada en la propiedad del control.

Cómo aplicar atributos de tiempo de diseño en el control personalizado

¿Por qué son necesarios los atributos en tiempo de diseño
El control personalizado que crea en el ejemplo anterior funciona como esperaba. Sin embargo, si desea usar ese control en Visual Studio, es posible que desea la propiedad de NoOfTimes se resalta automáticamente en la ventana Propiedades cuando se selecciona el control personalizado en tiempo de diseño.

Para que esto suceda, necesitará proporcionar la información de metadatos a Visual Studio, que puede hacer mediante la característica de Visual Studio denominadas atributos. Los atributos pueden definir una clase, un método, una propiedad o un campo. Cuando Visual Studio carga clase del control personalizado, comprueba los atributos definidos en la clase, método, propiedad o nivel de campo y cambia el comportamiento del control personalizado en tiempo de diseño en consecuencia.

Para obtener más información acerca de los atributos, visite el siguiente sitio Web de MSDN:
http://msdn2.microsoft.com/en-us/library/Aa288059(VS.71).aspx
Vamos a generar un ejemplo de atributos que utiliza utilizado:
  1. Abra SimpleServerControl.cs en un editor de texto.
  2. Introducir algunos atributos básicos en el nivel de clase, por ejemplo, DefaultProperty , ToolboxData y TagPrefixAttrbute . Se creará nuestro ejemplo de estos tres atributos.
            [
    	// Specify the default property for the control.		
    	DefaultProperty("DefaultProperty"),
    	
    	// Specify the tag that is written to the aspx page when the
            // control is dragged from the Toolbox to the Design view. 
    	// However this tag is optional since the designer automatically 
    	// generates the default tag if it is not specified.		
    	ToolboxData("<{0}:ControlWithAttributes runat=\"server\">" +
    		"</{0}:ControlWithAttributes>")
    	]
    	public class ControlWithAttributes : Control
    	{
    		private string _defaultProperty;
    		public string DefaultProperty
    		{
    			get { return "This is a default property value"; }
    			set { this._defaultProperty = value; }
    		}
    
    		protected override void Render(HtmlTextWriter writer)
    		{
    			writer.Write("Default Property --> <B>" + 
    			DefaultProperty + "</B>");
    		}
             }
    
  3. Hay una etiqueta más denominada TagPrefixAttrbute . Es un atributo de nivel de ensamblado que proporciona un prefijo a una etiqueta cuando se arrastra el control desde el cuadro de herramientas al diseñador. En caso contrario, el diseñador genera un prefijo como "cc1" de forma predeterminada. TagPrefixAttrbute no se aplica directamente a la clase del control. Para aplicar TagPrefixAttrbute , abra AssemblyInfo.cs, incluya la siguiente línea de código y a continuación, volver a generar el proyecto.
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    Nota: si desea crear el origen mediante la línea de comandos, deberá crear el archivo AssemblyInfo.cs, coloque el archivo en el directorio que contiene todos los archivos de origen y ejecute el siguiente comando para generar el control:
    > csc/t: library/out: ServerControlsLib.dll/r: System. dll / /r: *.cs System.Web.dll

¿Qué son las diferencias básicas entre controles de usuario y controles personalizados?

Ahora que tiene una idea básica de qué son los controles de usuario y controles personalizados y cómo crearlos, vamos a eche un vistazo rápido a las diferencias entre los dos.
Contraer esta tablaAmpliar esta tabla
factores control de usuario control personalizado
ImplementaciónDiseñado para escenarios de aplicaciones único

Implementar en el formulario de origen (.ascx) junto con el código fuente de la aplicación

Si el mismo control necesita utilizarse en más de una aplicación, proporciona redundancia y problemas de mantenimiento
Diseñado para que se puede utilizar más de una aplicación

Implementar en el directorio bin de la aplicación o en la caché de ensamblados global

Distribuir fácilmente y sin problemas asociados con redundancia y mantenimiento
CreaciónCrear es similar a la manera en que las páginas de formularios Web Forms se crean; adecuado para el desarrollo rápido de aplicaciones (RAD)Escritura implica grandes cantidades de código porque no hay ninguna compatibilidad de diseñador
ContenidoMucho mejor opción cuando necesite contenido estático dentro de una presentación fija, por ejemplo, cuando puede realizar los encabezados y pies de páginaMás adecuado para cuando una aplicación requiere dinámicos contenido que para se va a mostrar; se pueden reutilizar en una aplicación, por ejemplo, para el control de tabla con filas dinámicas enlazada a datos
DiseñoEscritura no requiere mucho diseño de la aplicación porque se crean en tiempo de diseño y principalmente contienen datos estáticosEscritura desde cero requiere un buen conocimiento de ciclo de vida del control y el orden en que ejecutan eventos, que normalmente está ocupando de los controles de usuario

Temas avanzados

A continuación, vamos a echar un vistazo a algunas de las características avanzadas que puede utilizar al desarrollar controles personalizados.

Administración de estado

Las aplicaciones Web se basan en HTTP, que es independiente. Una página y sus controles secundarios se crean en cada solicitud y se eliminan después de la solicitud. Para mantener el estado de la programación de ASP clásica, utilice objetos de sesión y aplicación. Pero para ello, necesita realizar gran cantidad de codificación. Para evitar este problema, ASP.NET proporciona un mecanismo conocido como el estado de vista para mantener el estado entre varias solicitudes. Para obtener información adicional sobre el estado de administración y vista de estado, visite los sitios Web de MSDN siguientes:
Introducción a administración de estado de formularios Web Forms
http://msdn2.microsoft.com/en-us/library/75x4ha6s(vs.71).aspx

El estado de vista de ASP.NET
http://msdn.microsoft.com/msdnmag/issues/03/02/cuttingedge/default.aspx

Guardar formularios Web Forms valores mediante el estado de vista de página
http://msdn2.microsoft.com/en-us/library/4yfdwycw(vs.71).aspx
Ejemplo mediante el estado de vista en un control personalizado
ViewStateExample.cs
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Text;

namespace ServerControlLib
{
	/// <summary>
	/// When a page framework reloads this control after postback, it   
        /// will restore the values which are in view state.
	/// This control can easily perform state management without 
        /// implementing our own logic for maintaining the state.
	/// </summary>
	public class ViewStateExample : WebControl
	{
		// Text to be displayed in Text box control.
		private string _text;
		
		/*
		 * This property needs to be populated before every 
                 * postback in order to 
		 * retain its value.
		*/ 
		public string Text
		{
			get { return (_text == null) ? "_text property is empty"  : _text; }
			set { _text = value; }
		}

		/*
		 * This property needs to be filled once and should be 
                 * available on the successive postbacks.
		*/ 
		public string TextInViewState
		{
			get
			{
				object o = ViewState["TextInViewState"];
				return (o == null) ? "View state is empty" : (string)o;
			}
			set { ViewState["TextInViewState"] = value; } 
		}

		/*
		 * Over-ridden method on WebControl base class which                   
                 * displays both of the property values 
		 * i.e. one stored in view state and other which is not 
                 * saved in view state.
		*/
		protected override void RenderContents(HtmlTextWriter writer)
		{
			writer.Write("Text Without View State = ");
			writer.Write(Text);
			writer.Write("<hr><br>");
			writer.Write("Text In View State = ");
			writer.Write(TextInViewState);
		}
	}
}
Ejemplo de cómo utilizar el control anterior en una página de formularios Web Forms
ViewStateExampleDemo.aspx
<%@ Page Language="C#" %>
<%@ Register TagPrefix="CC" Namespace="ServerControlLib" Assembly = "ServerControlLib" %>

<html>
  <head>
    <script runat="server">
      void button1_Click(object sender, EventArgs e)
      {
          Control1.Text = textbox1.Text;
          Control1.TextInViewState = textbox2.Text;
      }
    </script>
  </head>
  <body>
    <form runat="server" ID="Form1">
      <br>
      Property Value Without View State: <asp:TextBox id="textbox1" 
        runat="server" />
      <br>
      Property Value with View State: <asp:TextBox id="textbox2" 
        runat="server" />

      <asp:Button text="Cause Postback" onClick="button1_Click" 
        id="button1" Runat="server" />

      Output from the ViewStateExample Control :
      <CC:ViewStateExample id="Control1" runat="server"/>
    </form>
  </body>
</html>

Representación

En esta sección, describiré brevemente qué métodos debe reemplazar al derivar un control personalizado de la clase de control o de la clase WebControl .
Métodos de representación de la clase System.Web.UI.Control
Para obtener información acerca de los métodos de representación de la clase System.Web.UI.Control , visite los sitios Web de MSDN siguientes:
método Control.Render
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.render(vs.71).aspx

método Control.RenderControl
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.rendercontrol(vs.71).aspx

método Control.RenderChildren
http://msdn2.microsoft.com/en-us/library/system.web.ui.control.renderchildren(vs.71).aspx
Cómo se procesa un control en la página
Cada página tiene un árbol de control que representa una colección de todos los controles secundarios para esa página. Para representar el árbol de control, se crea un objeto de la clase HtmlTextWriter que contiene el código HTML que se va a procesar en el equipo cliente. Ese objeto se pasa al método RenderControl . El método RenderControl a su vez, invoca el método Render . A continuación, el método Render llama al método RenderChildren en cada control secundario, realizar un bucle recursivo hasta que se alcanza el final de la colección. Este proceso se explica mejor en el siguiente código de ejemplo.
public void RenderControl(HtmlTextWriter writer) 
{
    // Render method on that control will only be called if its visible property is true.
    if (Visible)
    {
        Render(writer);
    }
}

protected virtual void Render(HtmlTextWriter writer) 
{
    RenderChildren(writer);
}
protected virtual void RenderChildren(HtmlTextWriter writer) 
{
    foreach (Control c in Controls) 
    {
        c.RenderControl(writer);
    }
} 
Métodos de representación de la clase System.Web.UI.WebControl
Para obtener información acerca de los métodos de representación de la clase System.Web.UI.WebControl , visite los sitios Web de MSDN siguientes:
método WebControl.RenderBeginTag
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderbegintag(vs.71).aspx

método WebControl.RenderContents
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.rendercontents(vs.71).aspx

método WebControl.RenderEndTag
http://msdn2.microsoft.com/en-us/library/system.web.ui.webcontrols.webcontrol.renderendtag(vs.71).aspx
Cómo realiza la representación de la clase WebControl
En el ejemplo de código siguiente se muestra el método Render para el control personalizado.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
No es necesario reemplazar el método Render de la clase WebControl . Si desea representar contenido dentro de la clase WebControl , deberá reemplazar el método RenderContents . Sin embargo, si desea reemplazar el método Render , debe reemplazar el método RenderBeginTag , así como el método RenderEndTag en el orden específico que se muestra en el ejemplo de código anterior.

Conclusión

Eso es todo por ahora en controles de usuario y controles personalizados de ASP.NET 1.0 y 1.1 de ASP.NET. Espero que esta columna le ayudará a comprender las diferencias básicas entre ellos y los diversos enfoques que puede seguir para desarrollarlos.

Le agradecemos su tiempo. Vamos a escribir más información acerca de los temas avanzados para controles personalizados, como administración de estado, estilos de control, los controles compuestos y compatibilidad en tiempo de diseño para controles personalizados, en el futuro.

Para obtener más información acerca de los controles, visite los sitios Web de MSDN siguientes:
Fundamentos de desarrollo de control de servidor ASP.NET
http://msdn2.microsoft.com/en-us/library/aa310918(vs.71).aspx

Un examen extenso de controles de usuario
http://msdn2.microsoft.com/en-us/library/ms972975.aspx

Controles de servidor creación con plantilla personalizados ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478964.aspx

Eventos en controles de servidor ASP.NET
http://msdn2.microsoft.com/en-us/library/aa720049(vs.71).aspx

Control compuesto frente a control de usuario
http://msdn2.microsoft.com/en-us/library/aa719735(vs.71).aspx

Desarrollar controles de servidor ASP.NET
http://msdn2.microsoft.com/en-us/library/aa719973(vs.71).aspx

Desarrollar controles personalizados: conceptos de clave
http://msdn2.microsoft.com/en-us/library/aa720226(vs.71).aspx

Agregar compatibilidad en tiempo de diseño a controles de ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478960.aspx
Como siempre, quieres enviar ideas sobre temas que desea dirigidos en futuras columnas o en Knowledge Base utilizando Ask For It.

Propiedades

Id. de artículo: 893667 - Última revisión: miércoles, 14 de noviembre de 2007 - Versión: 1.8
La información de este artículo se refiere a:
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Palabras clave: 
kbmt kbhowto kbasp KB893667 KbMtes
Traducción automática
IMPORTANTE: Este artículo ha sido traducido por un software de traducción automática de Microsoft (http://support.microsoft.com/gp/mtdetails) en lugar de un traductor humano. Microsoft le ofrece artículos traducidos por un traductor humano y artículos traducidos automáticamente para que tenga acceso en su propio idioma a todos los artículos de nuestra base de conocimientos (Knowledge Base). Sin embargo, los artículos traducidos automáticamente pueden contener errores en el vocabulario, la sintaxis o la gramática, como los que un extranjero podría cometer al hablar el idioma. Microsoft no se hace responsable de cualquier imprecisión, error o daño ocasionado por una mala traducción del contenido o como consecuencia de su utilización por nuestros clientes. Microsoft suele actualizar el software de traducción frecuentemente.
Haga clic aquí para ver el artículo original (en inglés): 893667

Enviar comentarios

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com