Descrição geral de controlos de utilizador vs. controlos personalizados

Traduções de Artigos Traduções de Artigos
Artigo: 893667 - Ver produtos para os quais este artigo se aplica.
Coluna de voz de suporte do ASP.NET

Descrição geral de controlos de utilizador vs. controlos personalizados

Para personalizar esta coluna às suas necessidades, pretendemos convidá-lo para submeter as suas ideias sobre tópicos que interessam problemas que pretende ver e corrigida no futuro artigos da Base de dados de conhecimento e de colunas de voz de suporte. Pode submeter ideias e comentários utilizando a Pedir formulário. Existe também uma hiperligação para o formulário na parte inferior desta coluna.
Expandir tudo | Reduzir tudo

Nesta página

Introdução

Hi! Este é Parag e sou um engenheiro de suporte a trabalhar com o grupo de suporte Microsoft ASP.NET por mais de um ano agora. Antes de ingressar Microsoft, posso trabalhou projectos baseada na Web e aplicações de ambiente de trabalho utilizando tecnologias da Microsoft. Ao fornecimento do suporte de qualidade aos clientes, já VI casos em que ocorreu alguma confusão em torno de controlos personalizados, e apenas gostaria demorar algum tempo para explicar alguns conceitos de à volta de controlos personalizados. Como danificados como aparece, considerar-me, uma vez que obtiver o jeito, será em melhor posição para apreciar o ASP.NET.

Descrição geral

Na coluna deste mês, que irei falar os seguintes tópicos:
  • O que são controlos de utilizador?
  • O que são controlos personalizados?
  • Quais são as diferenças básicas entre controlos personalizados e controlos de utilizador?
Posso também vai introduzir alguns dos tópicos avançados que dizem respeito a controlos personalizados, tais como a composição de controlos personalizados e de gestão do Estado.

O que são controlos de utilizador?

Controlos de utilizador são controlos personalizados, reutilizáveis e utilizam as mesmas técnicas aplicadas pelos controlos de servidor Web e HTML. Estas funcionalidades oferecem uma forma fácil de criar partições e reutilizar as interfaces de utilizador comuns em aplicações ASP.NET Web. Utilizam o mesmo modelo programação de formulários da Web em que uma página de formulários Web funciona. Para obter mais detalhes sobre os formulários de Web modelo de programação, visite os seguintes Web sites da Microsoft Developer Network (MSDN):
Introdução às páginas de formulários da Web
http://msdn2.microsoft.com/en-us/library/65tcbxz3 (vs.71).aspx

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

Como criar um controlo de utilizador

A sintaxe a que utilizar para criar um controlo de utilizador é semelhante a sintaxe a que utilizar para criar uma página de formulários da Web (. aspx). A única diferença é que um utilizador o controlo não inclui o<html>,<body>, e<form>elementos de uma vez que uma página de formulários Web hospeda o controlo de utilizador. Para criar um controlo de utilizador, siga estes passos:</form></body></html>
  1. Abrir um texto ou o editor de HTML e criar um bloco de código do lado do servidor expor todas as propriedades, métodos e eventos.
    <script language="C#" runat="server">
       public void button1_Click(object sender, EventArgs e)
       {
          label1.Text = "Hello World!!!";
       }
    </script>
    
  2. Crie uma interface de utilizador para o controlo de utilizador.
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

Como utilizar um controlo de utilizador numa página de formulários da Web

  1. Crie uma nova página de formulários da Web (. aspx) no Microsoft Visual Studio .NET 2002, Microsoft Visual Studio .NET 2003, Microsoft Visual Studio 2005 ou qualquer editor de texto.
  2. Declare a directiva @ Register . Por exemplo, utilize o seguinte código.
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    Nota Suponha que o controlo de utilizador e a página de formulários da Web na mesma localização.
  3. Para utilizar o controlo de utilizador na página de formulários da Web, utilize o seguinte código depois da directiva @ Register .
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

Como criar uma instância de um controlo de utilizador através de programação no código por detrás do ficheiro de uma página de formulários da Web

O exemplo anterior criar instâncias de um controlo de utilizador de forma declarativa numa página de formulários da Web utilizando a directiva @ Register . No entanto, pode criar uma instância de um controlo de utilizador dinamicamente e adicioná-lo para a página. Eis os passos para efectuar a que:
  1. Crie uma nova página de formulários da Web no Visual Studio.
  2. Navegue para o código subjacente a ficheiro gerado para esta página de formulários da Web.
  3. No evento Page_Load da classe página , escreva o seguinte código.
    // 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 Pode adicionar um controlo de utilizador dinamicamente a determinados eventos do ciclo de vida da página.

    Para mais informações, visite os seguintes Web sites:
    Adicionar controlos a uma página de formulários da Web através de programação
    http://msdn2.microsoft.com/en-us/library/kyt0fzt1 (vs.71).aspx

    Ciclo de vida de execução remota de controlo
    http://msdn2.microsoft.com/en-us/library/aa719775 (vs.71).aspx

    Controlos Web dinâmicos, novas colocações e estado da vista, por Scott Mitchell
    http://ASPNET.4guysfromrolla.com/articles/092904-1.aspx

Modo de processamento de um controlo de utilizador

Quando é pedida uma página com um controlo de utilizador, ocorrerá o seguinte:
  • O analisador de página analisa o ficheiro. ascx especificado no atributo Src na directiva @ Registo e gera uma classe que deriva da classe UserControl .
  • O analisador, em seguida, dinamicamente compila a classe numa assemblagem.
  • Se estiver a utilizar o Visual Studio, em seguida, no momento da estruturação apenas, Visual Studio cria um código por detrás do ficheiro para o controlo de utilizador e o ficheiro é pré-compilada pelo criador do próprio.
  • Finalmente, a classe para o controlo de utilizador, que é gerado através do processo de geração de código dinâmico e de compilação, inclui o código para o código subjacente a ficheiro (. ascx.cs), bem como o código escrito dentro do ficheiro. ascx.

O que são controlos personalizados?

Controlos personalizados são componentes de código compilado que executar no servidor, expõem o modelo de objecto e componham texto de marcação, como HTML ou XML, tal como um controlo de formulário Web ou de utilizador normal.

Como escolher a classe base para o controlo personalizado

Para escrever um controlo personalizado, deve directa ou indirectamente derivar a nova classe da classe System.Web.UI.Control ou da classe System.Web.UI.WebControls.WebControl :
  • Deve derivar System.Web.UI.Control se pretender que o controlo para compor elementos nonvisual. Por exemplo, <meta> e<head>são exemplos de composição nonvisual.</head>
  • Deve derivar System.Web.UI.WebControls.WebControl se pretender que o controlo para compor o HTML que gera uma interface visual no computador cliente.
Se pretender alterar a funcionalidade de controlos existentes, tais como um botão ou rótulo, directamente pode derivar da nova classe com estas classes existentes e pode alterar o comportamento predefinido.

Em resumo, a classe de controlo fornece a funcionalidade básica através do qual pode colocá-lo na árvore de controlo para uma classe de página . A classe WebControl adiciona a funcionalidade para a classe de controlo base para apresentar conteúdo visual no computador cliente. Por exemplo, pode utilizar a classe de WebControl para controlar o aspecto e estilos através das propriedades como tipo de letra, cor e altura.

Como criar e utilizar um controlo personalizado simple que ultrapassa System.Web.UI.Control utilizando o Visual Studio

  1. Inicie o Visual Studio.
  2. Criar um projecto da biblioteca de classe e atribua um nome, por exemplo, CustomServerControlsLib.
  3. Adicione um ficheiro de origem do projecto, por exemplo, SimpleServerControl.cs.
  4. Inclua a referência do espaço de nomes System. Web na secção referências.
  5. Verifique se os espaços de nomes seguintes estão incluídos no ficheiro SimpleServerControl.cs.
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
  6. Herda da classe de SimpleServerControls com a classe de base de controlo .
    public class SimpleServerControl : Control
  7. Substitua o método de composição de mensagens em fila para escrever a saída na sequência de saída.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    Nota A classe HtmlTextWriter tem a funcionalidade de escrever HTML numa sequência de texto. O método Write da classe HtmlTextWriter exporta o texto especificado na sequência de resposta HTTP e é o mesmo que o método Response. Write .
  8. Compile o projecto da biblioteca de classe. Irá gerar a saída DLL.
  9. Abra um existente ou crie um novo projecto de aplicação Web do ASP.NET.
  10. Adicione uma página de formulários da Web onde o controlo personalizado pode ser utilizado.
  11. Adicione uma referência para a biblioteca de classes na secção referências do projecto ASP.NET.
  12. Registe o controlo personalizado na página Web Forms.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. Para criar uma instância ou utilizar o controlo personalizado na página Web de formulários, adicione a seguinte linha de código a<form>etiquetas. </form>
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    Nota No presente código, SimpleServerControl é o nome de classe de controlo dentro da biblioteca de classes.
  14. Execute a página de formulários da Web e poderá ver o resultado do controlo personalizado.
Se não estiver a utilizar o Visual Studio, terá de efectuar os seguintes passos:
  1. Abra qualquer editor de texto.
  2. Crie um ficheiro chamado SimpleServerControl.cs e escrever o código que figura nos passos 1 a 14.
  3. Na variável PATH, adicione o seguinte caminho:
    c:\Windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Inicie uma linha de comandos e vá para a localização onde o SimpleServerControl.cs está presente.
  5. Execute o seguinte comando:
    csc /t /out: CustomServerControlsLib. SimpleServerControl.dll /r:System.dll /r:System.Web.dll SimpleServerControl.cs
    Para mais informações sobre o compilador c# (csc.exe), visite o seguinte Web site da MSDN:
    http://msdn2.microsoft.com/en-us/library/1700bbwd (vs.71).aspx
  6. Para executar o controlo personalizado na página de formulários da Web, efectue o seguinte:
    1. Crie um directório na pasta wwwroot.
    2. Inicie o Microsoft Internet Information Services (IIS) Manager e marcar o novo directório como directório raiz virtual.
    3. Crie uma pasta de posição no novo directório.
    4. Copie o controlo personalizado DLL para a pasta Bin.
    5. Coloque a página de formulários Web de exemplo que criou nos passos anteriores dentro do directório de novo.
    6. Execute a página de exemplo a partir do Gestor de IIS.
Agora que criou um simple controlo personalizado, vamos observar como expor propriedades e aplicar atributos de inserção nesse controlo personalizado.

Como expor propriedades do controlo personalizado

Vou criar no exemplo anterior e introduzir um ou mais propriedades que podem ser configuradas enquanto estiver a utilizar o controlo personalizado na página Web Forms.

O exemplo seguinte mostra como definir uma propriedade que apresentará uma mensagem a partir do controlo de um determinado número de vezes, conforme especificado na propriedade do controlo:
  1. Abra SimpleServerControl.cs num editor de texto.
  2. Adicione uma propriedade na classe SimpleServerControl .
    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. Compile o controlo personalizado.
  4. Para utilizar o controlo personalizado na página de formulários da Web, adicione a nova propriedade à declaração de controlo.
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. Executar a página apresentará o mensagem "Olá mundo" do controlo personalizado tantas vezes como especificado na propriedade do controlo.

Como aplicar atributos de inserção sobre o controlo personalizado

Porque é que são necessários os atributos de tempo de estruturação
O controlo personalizado que criou no exemplo anterior funciona como previsto. No entanto, se pretender utilizar esse controlo no Visual Studio, poderá a propriedade NoOfTimes para ser automaticamente realçado na janela Propriedades, sempre que o controlo personalizado é seleccionado no momento da concepção.

Para que isto aconteça, é necessário fornecer as informações de metadados ao Visual Studio, que pode ser efectuada utilizando uma função no Visual Studio denominados atributos. Atributos podem definir uma classe, método, uma propriedade ou um campo. Quando o Visual Studio carrega classe o controlo personalizado, verifica a existência de quaisquer atributos definidos à classe, método, propriedade ou nível de campo e altera o comportamento do controlo personalizado no momento da concepção em conformidade.

Para obter mais informações sobre atributos, visite o seguinte Web site da MSDN:
http://msdn2.microsoft.com/en-us/library/Aa288059 (VS.71).aspx
Vamos compilação uma amostra que utiliza frequentemente atributos utilizados:
  1. Abra SimpleServerControl.cs num editor de texto.
  2. Introduzir alguns atributos básicos ao nível de classe, por exemplo, DefaultProperty, ToolboxDatae TagPrefixAttrbute. A Microsoft vai criar amostra estes três 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 --> " + 
    			DefaultProperty + "");
    		}
             }
    
  3. Existe um código mais chamado TagPrefixAttrbute. É um atributo de assemblagem nível que proporciona um prefixo para uma etiqueta quando arrasta o controlo da caixa de ferramentas para o estruturador. Caso contrário, o designer gera um prefixo, tal como "cc1" por predefinição. TagPrefixAttrbute não é aplicada directamente para a classe de controlo. Para aplicar TagPrefixAttrbute, abra AssemblyInfo.cs, inclua a seguinte linha de código e, em seguida, reconstrua o projecto.
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    Nota Se pretende criar a origem de linha de comandos, é necessário para criar o ficheiro de AssemblyInfo.cs, coloque o ficheiro no directório que contém todos os ficheiros de origem e executar o followingcommand para criar o controlo:
    > csc /t /out: ServerControlsLib.dll /r:System.dll /r: System.Web.dll *.cs

Quais são as diferenças básicas entre controlos personalizados e controlos de utilizador?

Agora que tem uma ideia básica de quais são controlos personalizados e controlos de utilizador e como criá-los, vamos um breve olhar sobre as diferenças entre os dois.
Reduzir esta tabelaExpandir esta tabela
FactoresControlo de utilizadorControlo personalizado
ImplementaçãoConcebidos para cenários de aplicação única

Implementado sob a forma de origem (. ascx) juntamente com o código de origem da aplicação

Se necessitar do mesmo comando a ser utilizado em mais de uma aplicação, introduz redundância e problemas de manutenção
Concebido para que possa ser utilizado por mais do que uma aplicação

Implementada no directório Bin da aplicação ou na cache de assemblagem global

Distribuído facilmente e sem problemas associados a redundância e manutenção
CriaçãoCriação é semelhante à forma como são criadas as páginas de formulários da Web; mais adequados para o desenvolvimento de aplicações rápidas (RAD)Escrita envolve muita código porque não existe suporte Estruturador
ConteúdoUma muito melhor opção quando necessitar conteúdo estático no prazo de um esquema fixo, por exemplo, quando efectuar os cabeçalhos e rodapésMais adequado para quando uma aplicação requer conteúdo dinâmico seja apresentado; pode ser reutilizada uma aplicação, por exemplo, para o controlo de tabela com linhas dinâmicas ligado a um dados
EstruturaEscrita não requer muito concepção da aplicação uma vez que são criados no momento da concepção e principalmente contenham dados estáticosEscrita de raiz requer uma boa compreensão de ciclo de vida do controlo e a ordem em que executar eventos, que é normalmente efectuado nos controlos de utilizador

Tópicos avançados

Em seguida, vamos observar algumas das funcionalidades avançadas que podem ser usados durante o desenvolvimento de controlos personalizados.

Gestão de Estados

Aplicações Web estão incorporadas no HTTP, o que é sem estado. Uma página e respectivos controlos subordinados são criados em todos os pedidos e são eliminados depois do pedido chegou ao fim. Para manter o estado em programação de ASP clássico, utilize objectos session e application. Mas, para que, é necessário fazer muita codificação. Para evitar esta situação, o ASP.NET fornece um mecanismo, conhecido como estado da vista para manter o estado através dos vários pedidos. Para mais informações sobre o estado de gestão e a vista de estado, visite os seguintes Web sites da MSDN:
Introdução à gestão do Estado de formulários da Web
http://msdn2.microsoft.com/en-us/library/75x4ha6s (vs.71).aspx

O estado da vista do ASP.NET
http://msdn.microsoft.com/msdnmag/issues/03/02/cuttingedge/default.aspx

Guardar formulários da Web valores utilizando o estado da vista de página
http://msdn2.microsoft.com/en-us/library/4yfdwycw (vs.71).aspx
Exemplo utilizando o estado da vista de um controlo 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);
		}
	}
}
Exemplo utilizando o controlo anterior numa página Web de formulários
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>

Composição

Nesta secção, posso vai descrever resumidamente os métodos, deve substituir quando derivar um controlo personalizado a classe de controlo ou a classe WebControl .
Métodos de composição da classe System.Web.UI.Control
Para obter informações sobre os métodos de composição da classe System.Web.UI.Control , visite os seguintes Web sites da MSDN:
Método de Control.Render
http://msdn2.microsoft.com/en-us/library/System.Web.UI.Control.Render (vs.71).aspx

Método de Control.RenderControl
http://msdn2.microsoft.com/en-us/library/System.Web.UI.Control.rendercontrol (vs.71).aspx

Método de Control.RenderChildren
http://msdn2.microsoft.com/en-us/library/System.Web.UI.Control.renderchildren (vs.71).aspx
Como um controlo é apresentado na página
Todas as páginas têm uma árvore de controlo que representa um conjunto de todos os controlos subordinados para essa página. Para compor a árvore de controlo, da classe HtmlTextWriter é criado um objecto que contém o código HTML para compor no computador cliente. Esse objecto é transmitido para o método RenderControl . Por sua vez, o método RenderControl invoca o método de composição . Em seguida, o método de composição chama o método de RenderChildren em cada controlo subordinado, efectuar um ciclo recursiva até que seja atingido o fim da colecção. Este processo é melhor explicado pelo código de exemplo seguinte.
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 composição da classe System.Web.UI.WebControl
Para obter informações sobre os métodos de composição da classe System.Web.UI.WebControl , visite os seguintes Web sites da MSDN:
Método de WebControl.RenderBeginTag
http://msdn2.microsoft.com/en-us/library/System.Web.UI.WebControls.WebControl.renderbegintag (vs.71).aspx

Método de WebControl.RenderContents
http://msdn2.microsoft.com/en-us/library/System.Web.UI.WebControls.WebControl.rendercontents (vs.71).aspx

Método de WebControl.RenderEndTag
http://msdn2.microsoft.com/en-us/library/System.Web.UI.WebControls.WebControl.renderendtag (vs.71).aspx
Como efectua o processamento da classe WebControl
Exemplo de código seguinte mostra o método de composição de mensagens em fila para o controlo personalizado.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
Não é necessário substituir o método de composição de mensagens em fila para a classe WebControl . Se pretender representar conteúdos de dentro da classe de WebControl , é necessário substituir o método RenderContents . No entanto, se pretender continuar a substituir o método de composição , terá de substituir o método de RenderBeginTag , bem como o método RenderEndTag pela ordem específica em que é mostrado no exemplo de código anterior.

Conclusão

É tudo por agora em controlos de utilizador e controlos personalizados no ASP.NET 1.0 e o ASP.NET 1.1. Espero que esta coluna ajuda a compreender as diferenças básicas existentes entre estas e as diversas abordagens que pode tomar para desenvolvê-los.

Obrigado pelo seu tempo. Esperamos escrever mais informações sobre os tópicos avançados para controlos personalizados, tais como a gestão do Estado, estilos do controlo, compostos de controlos e suporte de tempo de estruturação para controlos personalizados, num futuro próximo.

Para mais informações sobre controlos, visite os seguintes Web sites da MSDN:
Noções básicas do desenvolvimento de controlo de servidor do ASP.NET
http://msdn2.microsoft.com/en-us/library/aa310918 (vs.71).aspx

Um exame extensivo de controlos de utilizador
http://msdn2.microsoft.com/en-us/library/ms972975.aspx

Edifício transformada em modelo personalizados controlos de servidor ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478964.aspx

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

Controlo composto vs. controlo de utilizador
http://msdn2.microsoft.com/en-us/library/aa719735 (vs.71).aspx

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

Desenvolvimento de controlos personalizados: conceitos chave
http://msdn2.microsoft.com/en-us/library/aa720226 (vs.71).aspx

Adicionar suporte de tempo de estruturação para controlos ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478960.aspx
Como sempre, sensação gratuita submeter ideias sobre os tópicos que pretende no futuro corrigida colunas ou na Knowledge Base utilizando o Pedir formulário.

Propriedades

Artigo: 893667 - Última revisão: 9 de fevereiro de 2014 - Revisão: 2.0
A informação contida neste artigo aplica-se a:
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Palavras-chave: 
kbhowto kbasp kbmt KB893667 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática? erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 893667

Submeter comentários

 

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