Visão geral dos controles de usuário ou controles personalizados

Traduções deste artigo Traduções deste artigo
ID do artigo: 893667 - Exibir os produtos aos quais esse artigo se aplica.
Coluna de voz de suporte do ASP.NET

Visão geral dos controles de usuário ou controles personalizados

para personalizar esta coluna às suas necessidades, queremos convidá-lo para enviar suas idéias sobre tópicos que interessam a você e problemas que você deseja ver abordados artigos do Knowledge Base no futuro e colunas de voz de suporte. Você pode enviar suas idéias e comentários usando o formulário Ask For It. Há também um link para o formulário na parte inferior desta coluna.
Expandir tudo | Recolher tudo

Neste artigo

Introdução

Olá! Isso é Parag e eu sou um engenheiro de suporte trabalhando com o grupo de suporte do Microsoft ASP.NET por mais de um ano agora. Antes para entrar na Microsoft, trabalhei em projetos baseados na Web e aplicativos da área de trabalho usando as tecnologias Microsoft. Fornecendo suporte de qualidade aos clientes, já vi casos em que houve alguma confusão em torno de controles personalizados, e gostaria apenas levar algum tempo para explicar alguns conceitos em torno de controles personalizados. Como defeituosos como ela aparece, acredita-me, depois de chegar a travar dele, você será em uma posição melhor para apreciar ASP.NET.

Visão geral

Na coluna deste mês, Falarei sobre os tópicos a seguir:
  • O que são controles de usuário?
  • O que são controles personalizados?
  • O que são as diferenças básicas entre controles de usuário e controles personalizados?
Também apresentarei alguns tópicos avançados que se referem a controles personalizados, como gerenciamento de estado e o processamento de controles personalizados.

O que são controles de usuário?

Controles de usuário são controles personalizados, reutilizáveis e usam as mesmas técnicas empregadas por controles do servidor Web e HTML. Eles oferecem uma maneira fácil de partição e reutilizar interfaces de usuário comuns em aplicativos da Web ASP.NET. Eles usam o mesmo modelo de programação Web Forms, em que uma página de Web Forms funciona. Para obter mais detalhes sobre o modelo de programação de Web Forms, visite o seguinte da Microsoft Developer Network (MSDN):
Introdução a páginas de Web Forms
http://msdn2.microsoft.com/en-us/library/65tcbxz3(vs.71).aspx

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

Como criar um controle de usuário

A sintaxe que você usar para criar um controle de usuário é semelhante a sintaxe que você usar para criar uma página de Web Forms (.aspx). A única diferença é que um controle de usuário não inclui <html>, <body>, e <form> elementos como uma página de Web Forms hospeda o controle de usuário. Para criar um controle de usuário, execute essas etapas:
  1. Abra um editor de HTML ou texto e crie 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 usuário para o controle de usuário.
    <asp:Label id="label1" runat="server"/>
     <br><br>
    <asp:button id="button1" text="Hit" OnClick="button1_Click" runat="server" />
    

Como usar um controle de usuário em uma página de Web Forms

  1. Crie uma nova página Web Forms (.aspx) no Microsoft Visual Studio .NET 2002, Microsoft Visual Studio .NET 2003, Microsoft Visual Studio 2005 ou em qualquer editor de texto.
  2. Declare a diretiva @ Register . Por exemplo, use o código a seguir.
    <%@ Register TagPrefix="UC" TagName="TestControl" Src="test.ascx" %>
    Assume Observação se o controle de usuário e a página de Web Forms estão no mesmo local.
  3. Para usar o controle de usuário na página de Web Forms, use o seguinte código após a diretiva @ Register .
    <html>
        <body>
              <form runat="server">
                   <UC:TestControl id="Test1" runat="server"/>
              </form>
        </body>  
    </html>
    

Como criar programaticamente uma instância de um controle de usuário no code-behind arquivo de uma página de Web Forms

O exemplo anterior instanciar um controle de usuário declarativamente em uma página de Web Forms usando a diretiva @ Register . No entanto, você pode instanciar um controle de usuário dinamicamente e adicioná-lo para a página. Aqui estão as etapas para fazer isso:
  1. Crie uma nova página de Web Forms no Visual Studio.
  2. Navegue até o código gerado para esta página de Web Forms de arquivo.
  3. No evento Page_Load da classe Page , gravação 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);
    
    Observação você pode adicionar um controle de usuário dinamicamente em determinados eventos de ciclo de vida da página.

    Para obter mais informações, visite os seguintes sites:
    Adicionar controles a uma página de Web Forms programaticamente
    http://msdn2.microsoft.com/en-us/library/kyt0fzt1(vs.71).aspx

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

    Controles da Web dinâmicos, postbacks e estado de exibição, por Scott Mitchell
    http://aspnet.4guysfromrolla.com/articles/092904-1.aspx

Como um controle de usuário é processado

Quando uma página com um controle de usuário é solicitada, ocorre o seguinte:
  • O analisador de página analisa o arquivo .ascx especificado no atributo Src na diretiva @ Register e gera uma classe que deriva da classe System.Web.UI.UserControl .
  • O analisador, em seguida, dinamicamente compila a classe em um assembly.
  • Se você estiver usando o Visual Studio, em seguida, em tempo de design somente, Visual Studio cria um código por trás de arquivo para o controle de usuário e o arquivo é pré-compilado pelo criador do próprio.
  • Finalmente, a classe para o controle de usuário, que é gerado durante o processo de geração de código dinâmico e compilação, inclui o código para o código por trás de arquivo (. ascx.cs), bem como o código escrito no arquivo .ascx.

O que são controles personalizados?

Controles personalizados são componentes de código compilado que executar no servidor, expõem o modelo de objeto e processam o texto de marcação, como HTML ou XML, como um controle de formulário da Web ou de usuário normal.

Como escolher a classe base para seu controle personalizado

Para escrever um controle personalizado, você deve direta ou indiretamente derivam da nova classe da classe System.Web.UI.Control ou da classe System.Web.UI.WebControls.WebControl :
  • Você deve derivar System.Web.UI.Control se desejar que o controle para processar elementos nonvisual. Por exemplo, <meta> e <head> é exemplos de processamento nonvisual.
  • Você deve derivar de System.Web.UI.WebControls.WebControl se desejar que o controle para processar HTML que gera uma interface visual no computador cliente.
Se você deseja alterar a funcionalidade de controles existentes, como um botão ou rótulo, você pode derivar diretamente a nova classe com essas classes existentes e poderá alterar o comportamento padrão.

Em resumo, a classe de controle fornece a funcionalidade básica ao qual você pode colocá-lo na árvore de controle para uma classe de página . A classe WebControl adiciona a funcionalidade para a classe base do controle para exibir o conteúdo visual no computador cliente. Por exemplo, você pode usar a classe WebControl para controlar a aparência e estilos através das propriedades como fonte, cor e altura.

Como criar e usar um controle personalizado simples que se estende da System.Web.UI.Control usando o Visual Studio

  1. Inicie o Visual Studio.
  2. Crie um projeto de biblioteca de classe e dê a ele um nome, por exemplo, CustomServerControlsLib.
  3. Adicione um arquivo fonte para o projeto, for example, SimpleServerControl.cs.
  4. Incluem a referência do namespace System.Web na seção de referências.
  5. Verifique se os namespaces a seguir estão incluídos no
    System
    System.Collections
    System.ComponentModel
    System.Data
    System.Web
    System.Web.SessionState
    System.Web.UI
    System.Web.UI.WebControls
    
    do SimpleServerControl.cs arquivo.
  6. Herda a classe SimpleServerControls com a classe base Control .
    public class SimpleServerControl : Control
  7. Substitua o método Render para escrever a saída para o fluxo de saída.
    protected override void Render(HtmlTextWriter writer) 
    {
    	 writer.Write("Hello World from custom control");
    }
    
    Observação A classe HtmlTextWriter tem a funcionalidade de escrever HTML em um fluxo de texto. O método Write da classe HtmlTextWriter produz o texto especificado para o fluxo de resposta HTTP e é o mesmo como o método Response.write .
  8. Compile o projeto de biblioteca de classe. Ele irá gerar a saída DLL.
  9. Abra um existente ou crie um novo projeto de aplicativo ASP.NET Web.
  10. Adicione uma página Web Forms onde o controle personalizado pode ser usado.
  11. Adicione uma referência à biblioteca de classe na seção de referências de projeto ASP.NET.
  12. Registre o controle personalizado na página de Web Forms.
    <%@ Register TagPrefix="CC " Namespace=" CustomServerControlsLib " Assembly="CustomServerControlsLib " %>
  13. Para criar uma instância ou use o controle personalizado na página de Web Forms, adicione a seguinte linha de código nas marcas <form>.
    <form id="Form1" method="post" runat="server">
        <CC:SimpleServerControl id="ctlSimpleControl" runat="server">
        </CC:SimpleServerControl >
    </form>
    
    Observação esse código, SimpleServerControl é o nome de classe do controle dentro da biblioteca de classes.
  14. Executar a página de Web Forms, e você verá a saída do controle personalizado.
Se você não estiver usando o Visual Studio, você precisa executar as seguintes etapas:
  1. Abra qualquer editor de texto.
  2. Crie um arquivo chamado SimpleServerControl.cs e escrever o código conforme indicado nas etapas 1 a 14.
  3. Na variável PATH, adicione o seguinte caminho:
    c:\Windows (winnt)\Microsoft.Net\Framework\v1.1.4322
  4. Inicie um prompt de comando e vá para o local onde SimpleServerControl.cs está presente.
  5. Execute o seguinte comando:
    csc/t: Library/out: CustomServerControlsLib. SimpleServerControl.dll /r:System.dll /r:System.Web.dll SimpleServerControl.cs
    Para obter mais informações sobre o compilador translation from VPE for Csharp (csc.exe), visite o seguinte site da MSDN:
    http://msdn2.microsoft.com/en-us/library/1700bbwd(vs.71).aspx
  6. Para executar o controle personalizado da página de Web Forms, faça o seguinte:
    1. Crie um diretório na pasta wwwroot.
    2. Inicie o Gerenciador dos serviços de informações da Internet (IIS) e marcar a nova pasta como o diretório raiz virtual.
    3. Crie uma pasta bin o novo diretório.
    4. Copie a DLL de controle personalizado para a pasta bin.
    5. Coloque a página de Web Forms de exemplo que você criou nas etapas anteriores dentro do novo diretório.
    6. Execute a página de exemplo no Gerenciador do IIS.
Agora que você criou um controle personalizado simples, vamos examinar como expor as propriedades e aplicar atributos de tempo de design em que o controle personalizado.

Como expor propriedades no controle personalizado

Será criar o exemplo anterior e apresentar uma ou mais propriedades que podem ser configuradas ao usar o controle personalizado na página Web Forms.

O exemplo a seguir mostra como definir uma propriedade que exibirá uma mensagem do controle de um determinado número de vezes, conforme especificado na propriedade do controle:
  1. Abra SimpleServerControl.cs em um 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 controle personalizado.
  4. Para usar o controle personalizado da página de Web Forms, adicione a nova propriedade à declaração do controle.
    <CC:SimpleServerControl id="ctlSimpleControl" NoOfTimes="5" runat="server"></CC:SimpleServerControl>
  5. Executar a página exibirá a mensagem "Hello world" do controle personalizado como muitas vezes como especificado na propriedade do controle.

Como aplicar atributos de tempo de design no controle personalizado

Por que os atributos de tempo de design são necessárias
O controle personalizado que você criou no exemplo anterior funciona conforme o esperado. No entanto, se você quiser usar esse controle no Visual Studio, você pode ser que a propriedade NoOfTimes automaticamente ser realçadas na janela Properties, sempre que o controle personalizado é selecionado em tempo de design.

Para fazer isso, você precisará fornecer as informações de metadados ao Visual Studio, você pode fazer usando um recurso no Visual Studio chamada atributos. Atributos podem definir uma classe, um método, uma propriedade ou um campo. Quando o Visual Studio carrega classe do controle personalizado, ele verifica para os atributos definidos na classe, método, propriedade ou campo nível e altera o comportamento do controle personalizado em tempo de design de acordo.

Para obter mais informações sobre atributos, visite o seguinte site da MSDN:
http://msdn2.microsoft.com/en-us/library/Aa288059(VS.71).aspx
Vamos criar um exemplo que atributos usa usado:
  1. Abra SimpleServerControl.cs em um editor de texto.
  2. Apresente alguns atributos básicos no nível de classe, por exemplo, DefaultProperty ToolboxData e TagPrefixAttrbute . Criaremos nosso exemplo nesses 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 --> <B>" + 
    			DefaultProperty + "</B>");
    		}
             }
    
  3. Há uma marca mais chamada TagPrefixAttrbute . É um atributo de nível de assembly que fornece um prefixo para uma marca ao arrastar o controle da caixa de ferramentas para o designer. Caso contrário, o designer gera um prefixo, como "cc1" por padrão. TagPrefixAttrbute não será aplicada diretamente a classe de controle. Para aplicar TagPrefixAttrbute , abra AssemblyInfo.cs, inclua a seguinte linha de código e, em seguida, recriar project.
    [assembly:TagPrefix("ServerControlsLib ", "MyControl")]
    Observação se você deseja criar a fonte usando a linha de comando, você precisará criar o arquivo AssemblyInfo.cs, coloque o arquivo no diretório que contém todos os arquivos de origem e execute o seguinte comando para criar o controle:
    > csc/t: Library/out: ServerControlsLib.dll /r:System.dll /r: *.cs System.Web.dll

O que são as diferenças básicas entre controles de usuário e controles personalizados?

Agora que você tem uma idéia básica do que são controles de usuário e controles personalizados e como criá-los, vamos observar um rápido as diferenças entre os dois.
Recolher esta tabelaExpandir esta tabela
fatores controle de usuário controle personalizado
ImplantaçãoProjetado para cenários de aplicativo único

Implantado no formulário de origem (.ascx) junto com o código-fonte do aplicativo

Se o mesmo controle precisa ser usado em mais de um aplicativo, ele apresenta redundância e problemas de manutenção
Projetado de modo que ele pode ser usado por mais de um aplicativo

Implantado no diretório bin do aplicativo ou no cache global de assemblies

Distribuído facilmente e sem problemas associados com redundância e manutenção
CriaçãoCriação é semelhante da maneira que páginas de Web Forms são criados; adequado para desenvolvimento rápido de aplicativo (RAD)Escrita envolve muita código porque não há nenhum suporte de designer
ConteúdoUma opção muito melhor quando você precisar conteúdo estático dentro de um layout fixo, por exemplo, quando você fazer cabeçalhos e rodapésMais adequado para quando um aplicativo exigir dinâmico conteúdo a ser exibido; podem ser reutilizados a em um aplicativo de por exemplo, para um dados ligados controle de tabela com linhas dinâmicas
DesignGravação não exige muito criação do aplicativo porque eles são criados em tempo de design e principalmente contenham dados estáticosEscrever do zero requer uma compreensão boa de ciclo de vida do controle e a ordem na qual executar eventos, que é normalmente solucionada em controles de usuário

Tópicos avançados

Em seguida, vamos observar alguns dos recursos avançados que você pode usar ao desenvolver controles personalizados.

Gerenciamento de estado

Aplicativos da Web são criados em HTTP, que é sem monitoração de estado. Uma página e seus controles filhos são criados em cada solicitação e são descartados após a solicitação sobre. Para manter o estado em programação ASP clássica, use objetos de sessão e aplicativo. Mas para isso, você precisa fazer muita codificação. Para evitar isso, o ASP.NET fornece um mecanismo conhecido como estado de exibição para manter o estado entre várias solicitações. Para saber mais sobre o estado de gerenciamento e o modo de exibição, visite os seguintes sites do MSDN:
Introdução ao gerenciamento de estado de Web Forms
http://msdn2.microsoft.com/en-us/library/75x4ha6s(vs.71).aspx

O estado de exibição ASP.NET
http://msdn.microsoft.com/msdnmag/issues/03/02/cuttingedge/default.aspx

Salvando Web Forms valores usando o estado de exibição de página
http://msdn2.microsoft.com/en-us/library/4yfdwycw(vs.71).aspx
Exemplo usando o estado de exibição em um controle 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 usando o controle anterior em uma página de 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>

Processamento

Nesta seção, descreverei rapidamente quais métodos devem substituir quando você derivar um controle personalizado da classe Control ou a classe WebControl .
Métodos de processamento da classe System.Web.UI.Control
Para informações sobre os métodos de processamento da classe System.Web.UI.Control , visite os seguintes sites da MSDN:
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
Como um controle é processado na página
Cada página tem uma árvore de controle que representa uma coleção de todos os controles filho para essa página. Para processar a árvore de controle, um objeto da classe HtmlTextWriter é criado que contém o HTML para ser processado no computador cliente. Esse objeto é passado para o método RenderControl . Por sua vez, o método RenderControl invoca o método Render . Em seguida, o método Render chama o método RenderChildren em cada controle filho, fazer um loop recursivo até o final da coleção é atingido. Esse processo é explicado melhor pelo seguinte código exemplo.
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 processamento da classe System.Web.UI.WebControl
Para informações sobre os métodos de processamento da classe System.Web.UI.WebControl , visite os seguintes sites da MSDN:
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
Como o processamento da classe WebControl ocorre
O exemplo de código a seguir mostra o método Render para o controle personalizado.
protected override void Render(HtmlTextWriter writer)
{
    RenderBeginTag(writer);
    RenderContents(writer);
    RenderEndTag(writer);
}
Você não precisará substituir o método Render para a classe WebControl . Se você quiser processar conteúdo dentro da classe WebControl , você precisará substituir o método RenderContents . No entanto, se você ainda deseja substituir o método Render , você deve substituir o método RenderBeginTag , bem como o método RenderEndTag em ordem específica que é mostrado no exemplo de código anterior.

Conclusão

Isso é tudo para agora em controles de usuário e controles personalizados no ASP.NET 1.0 e ASP.NET 1.1. Espero que essa coluna ajuda você compreender as diferenças básicas entre eles e as várias abordagens que você pode tomar para desenvolvê-los.

Obrigado por seu tempo. Esperamos que escrever mais sobre os tópicos avançados para controles personalizados, como gerenciamento de estado, estilos de controle, composição de controles e suporte em tempo de design para controles personalizados, em um futuro próximo.

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

Uma análise abrangente de controles de usuário
http://msdn2.microsoft.com/en-us/library/ms972975.aspx

Criando modelo controles ASP.NET personalizados servidor
http://msdn2.microsoft.com/en-us/library/Aa478964.aspx

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

Controle composto versus controle de usuário
http://msdn2.microsoft.com/en-us/library/aa719735(vs.71).aspx

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

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

Adicionando suporte a tempo de design para controles ASP.NET
http://msdn2.microsoft.com/en-us/library/Aa478960.aspx
Como sempre, vontade enviar idéias sobre tópicos desejado no futuro abordada colunas ou na Base de dados de Conhecimento usando o formulário Ask For It.

Propriedades

ID do artigo: 893667 - Última revisão: quarta-feira, 14 de novembro de 2007 - Revisão: 1.8
A informação contida neste artigo aplica-se a:
  • Microsoft ASP.NET 1.1
  • Microsoft ASP.NET 1.0
Palavras-chave: 
kbmt kbhowto kbasp 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 traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes 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