Explicação Passo a Passo: Desenvolvendo e Usando um Controle de Servidor Personalizado

  • Artigo

Essa explicação passo a passo mostra como criar e compilar um controle de servidor ASP.NET personalizado e usá-lo em uma página.

Durante este passo-a-passo você aprenderá como:

  • Criar um controle de servidor ASP.NET.

  • Adicionar metadados ao controle e a seus membros para controlar segurança e comportamento de tempo de design.

  • Usar o diretório App_Code em um site da Web ASP.NET para testar o seu controle sem etapas manuais de compilação .

  • Especificar um prefixo de marca em um arquivo de configuração e na montagem do controle.

  • Compilar o controle em um conjunto de módulos (assembly) e adicioná-lo para o diretório Bin.

  • Incorporar um bitmap na montagem do controle como o Ícone Caixa de ferramentas para um designer visual.

  • Usar o controle compilado em uma página.

Uma ferramenta de design visual, como Microsoft Visual Studio 2005 Simplifica o desenvolvimento de controle, mas não é essencial para a criação ou criar controles Personalizars.Você pode Criar os controles usando qualquer editor de texto e crie-los a partir de linha de comando usar os compiladores que fazem parte das .NET framework SDK.Indiferentemente de como você cria o seu controle, a aparência em tempo de design do controle e o seu comportamento em um designer visual serão os mesmos.Um desenvolvedor de página pode adicionar o seu controle para caixa de ferramentas do designer visual, arrastá-lo para a superfície de design e acessar as suas propriedades e eventos no navegador da propriedade.Em alguns designers visuais, como. Visual Studio 2005Um controle personalizado também possui suporte IntelliSense sem qualquer trabalho de sua parte.

Criando o Controle de Servidor

O controle que você criará, WelcomeLabelUm controle simples é semelhante ao padrão Label o controle.O WelcomeLabel Classe deriva de WebControl e define um Texto Propriedade que permite que um desenvolvedor de página fornecer uma seqüência de texto para um usuário a um site bem-vindo.WelcomeLabel acrescentará o nome do usuário para a seqüência de texto, se o nome do usuário está presente no cabeçalho enviado pelo navegador do usuário.Para obter mais informações sobre como recuperar o nome de usuário, consulte User().Por exemplo, se o desenvolvedor de página define "Olá" Como o valor das Texto Propriedade, WelcomeLabel reproduz "Hello, UserName!" ou "Olá!" Com base no se o nome de usuário está presente no cabeçalho.

Para criar o código para o controle de servidor personalizado

  1. Crie um arquivo chamado WelcomeLabel.cs ou WelcomeLabel.vb.

  2. Adicione o seguinte código ao arquivo de origem para o controle:

Discussão de Código

A discussão do código que segue não é essencial para executar as etapas nessa explicação passo a passo e você pode ignorá-la inicialmente.No entanto, se você for iniciante na criação de controle, recomendamos que você leia-a pelo menos depois de concluir a explicação.

Se o controle processa um elemento interface do usuário (interface do usuário) ou qualquer outro elemento visível no cliente, você deve derivar o controle de WebControl (ou um classe derivada).Se o controle processa um elemento que não estiver visível no navegador do cliente, como um elemento oculto ou um Meta Elemento, derivar o controle de Control.O WebControl Classe deriva de Control e adiciona propriedades estilo-relacionados, como Font(), ForeColore BackColor.Além disso, um controle que é derivado de WebControl Participa temas recursos do ASP.NET sem qualquer trabalho extra de sua parte.

Se o controle amplia a funcionalidade de um controle existente, como o Button, Label, ou Image controles, você pode derivar de controle.Porque WelcomeLabel estende a funcionalidade das Label Controle, ele pode derivar de Label.No entanto, essa explicação passo a passo deriva WelcomeLabel de WebControl Para mostrar como definir uma propriedade e definir propriedades de metadados.

O WelcomeLabel Define uma propriedade, Textoe usa Exibir estado para armazenar a valor da propriedade.Usar estado de exibição persiste o valor de Texto Na Horizontal postagens.Em cada postagem, a página é recriada e valores são restaurados do estado de exibição.Se a Texto Valor não foram armazenados em estado de exibição, o valor seria definido como o padrão, EmptyEm cada postagem Voltar.O ViewState Propriedade herdadas WebControl é um dicionário que salva os valores de dados.Os valores são inseridos e recuperada usando um String Chave.Nesse caso, "Texto" é usado como a chave.Itens no dicionário são digitadas como Objectque você deve, em seguida, convertido em tipo de propriedade.Para obter mais informações, consulte Visão Geral sobre o Gerenciamento de Estado do ASP.NET.

O WelcomeLabel Controle renders seu Texto Propriedade por substituindo o herdadas [M:System.Web.UI.WebControls.WebControl.Renderconteúdo(System.Web.UI.HtmlTextWriter)] Método.O parâmetro passado em o [M:System.Web.UI.WebControls.WebControl.Renderconteúdo(System.Web.UI.HtmlTextWriter)] Método é um objeto do tipo HtmlTextWriterque é um utilitário de classe que tem métodos para processar as marcas HTML Outro (e HTML-Variant) marcação.

Observe que WelcomeLabel faz chamadas sucessivas para o HtmlTextWriter do objeto Gravar(String) Método em vez de executar concatenação de seqüência de caracteres e, em seguida, chamar o Gravar(String) Método.Isso melhora o desempenho porque a HtmlTextWriter Objeto grava diretamente para o fluxo de saída.Concatenação de seqüência de caracteres requer tempo e memória para criar a seqüência e, em seguida, grava o fluxo.Ao implementar o processamento em seus controles, você deve seguir o padrão ilustrado nessa explicação passo a passo.

Observação:

Em geral, quando o controle é derivado de WebControl e processa um Simples elemento, você deve substituir o [M:System.Web.UI.WebControls.WebControl.Renderconteúdo(System.Web.UI.HtmlTextWriter)] Método (e não o Render(HtmlTextWriter) Método) para processar o conteúdo nas marcas do controle.O Render(HtmlTextWriter) Método de WebControl Chama [M:System.Web.UI.WebControls.WebControl.Renderconteúdo(System.Web.UI.HtmlTextWriter)] Após o processamento de Abrindo marca para o controle e seus atributos de estilo.Se você substituir o Render(HtmlTextWriter) Método para gravar conteúdo, o controle perderá a estilo-Rendering lógica que está embutido na Render(HtmlTextWriter) Método de WebControl.Para obter mais informações sobre o processamento de um controle que é derivado de WebControlConsulte Exemplo de Processamento de Controle Web.

Os atributos aplicados a WelcomeLabel Conter Metadados que é usado pela Comum Idioma Tempo de execução e por ferramentas em tempo de design.

No nível de classe. WelcomeLabelestá marcado com os seguintes atributos:

  • AspNetHostingPermissionAttribute é um atributo de segurança de código de acesso.Isso faz com que o compilador JIT para Marcar que o código que os links para WelcomeLabel é concedido a AspNetHostingPermission Permissão.Todas as classes públicas ASP.NET são marcadas com esse atributo.Você deve aplicar AspNetHostingPermissionAttribute Para os controles como uma segurança parcialmente compará Confiável os chamadores.

  • DefaultPropertyAttribute é um atributo que especifica a propriedade padrão de um controle em tempo de design.Em designers visuais, o navegador de propriedade normalmente realça a propriedade padrão quando um desenvolvedor de página clica no controle sobre a superfície de design.

  • ToolboxDataAttribute Especifica a seqüência Formatarar para o elemento.A seqüência de caracteres torna-se a marcação do controle quando é clicado duas vezes sobre o controle na caixa de ferramentas ou quando ele é arrastado da caixa de ferramentas até a superfície de design.Para WelcomeLabela seqüência de caracteres cria esse elemento:

    < aspExemplo:WelcomeRótulo runat = "server" > < / aspSample:WelcomeLabel >

O WelcomeLabel Controle também herda dois atributos a partir de WebControl classe base, ParseChildrenAttribute e PersistChildrenAttribute.Elas são aplicadas como ParseChildren(Verdadeiro) e PersistChildren(FALSE).Esses dois atributos funcionam juntos e com o ToolboxDataAttribute Atributo de modo que elementos filho são interpretados como propriedades e as propriedades são persistentes como atributos.

Os seguintes atributos aplicados ao Texto Propriedade de WelcomeLabel São os atributos padrão de tempo de design que você irá geralmente Aplicar para todas as propriedades Públicos de seus controles:

  • BindableAttributeespecificado como verdadeiro ou falseEspecifica para designers visuais se é significativo para Ligar a propriedade a dados.Por exemplo, em Visual Studio 2005Se uma propriedade é marcada com Bindable(True)a propriedade é exibida na DataBindings caixa de diálogo.Se uma propriedade não estiver marcada com esse atributo, o pesquisador de propriedades inferirá o valor a ser Bindable(FALSE).

  • CategoryAttribute Especifica como a categorizar a propriedade no Pesquisador de propriedades do designer visual.Por exemplo, Categoria("Aparência") Informa o Pesquisador de Propriedade para exibir a propriedade na Aparência categoria quando o desenvolvedor de página usa o modo de exibição de categoria do navegador da propriedade.Você pode especificar uma string argumento correspondente a uma categoria no navegador da propriedade existente ou criar sua própria categoria.

  • DescriptionAttribute Especifica uma breve descrição da propriedade.Em Visual Studio 2005o pesquisador de propriedades exibe a descrição da propriedade selecionada na parte inferior de Janela Propriedades.

  • DefaultValueAttribute Especifica um valor padrão para a propriedade.Este valor deve ser igual ao valor padrão que você retornar do assessor de propriedade (Getter).Em Visual Studio 2005o DefaultValueAttribute Permite que um desenvolvedor de página redefinir seu padrão por trazer até um valor da propriedade o Atalho menu na Propriedades janela e clicar na Reset Botão.

  • LocalizableAttributeespecificado como verdadeiro ou falseEspecifica para designers visuais se ele é significativo para localizar a propriedade.Quando uma propriedade está marcada Localizable(True)o designer visual inclui-lo ao serializar Recursos localizados.O designer irá persistir o valor da propriedade para o arquivo de recurso de cultura neutra ou outra fonte de localização quando o controle for monitorado para propriedades localizáveis.

    Observação:

    Você não pode aplicar LocalizableAttribute Para personalizar servidor controles ASP.NET versões 1.0 e 1.1 porque o modelo de localização do ASP.NET era diferente nessas versões.

Atributos de tempo de design aplicados a um controle e a seus membros não afetam o funcionamento do controle em tempo de execução, mas aumentam a experiência do desenvolvedor quando o controle é usado em um designer visual.Você pode ver um Concluir lista de atributos para controles de servidor em tempo de design, Parse-tempo e em tempo de execução Atributos Metadata para Controles de Servidor Personalizados.

Usando o diretório App_Code para testar controles sem compilação

Você pode usar o recurso de compilação dinâmica do ASP.NET para testar o seu controle em uma página sem compilar o controle em um conjunto de módulos (assembly).O ASP.NET compila dinamicamente código localizado no diretório App_Code na raiz de um site ASP.NET.Classes em arquivos de origem em App_Code podem, portanto, serem acessadas a partir de páginas sem serem compiladas manualmente em conjuntos de módulos (assemblies).Se você colocar os arquivos de origem para os controles no diretório App_Code, as alterações que você faz para código dos controles são imediatamente refletidas nas páginas que usam os controles.

Observação:

O diretório App_Code é um novo recurso que não estava disponível no ASP.NET 1.0 e 1.1.Usar o diretório App_Code para um teste inicial do controle é opcional.As etapas principais da criação de um controle de servidor são as mesmas que nas versões anteriores, conforme você verá na próxima seção, "Compilando o controle em um conjunto de módulos (assembly)".

Para criar o site ASP.NET e o diretório App_Code

  1. Criar um site chamado ServerControlsTest.Você pode criar o site no IIS como um diretório virtual chamado ServerControlsTest.Para obter detalhes sobre como criar e configurar um diretório virtual o IIS, consulte Como: Criar e configurar diretórios virtuais no IIS 5.0 e 6.0.

  2. Crie um diretório App_Code diretamente sob o diretório raiz de seu Web site (também chamado raiz do aplicativo Web).

  3. Copie o arquivo de origem para o controle (WelcomeLabel.cs ou WelcomeLabel.vb) e cole no diretório App_Code.

Criando um prefixo de marca

Um prefixo de marca é o prefixo, como "ASP" Em < ASP:Tabela / >que aparece antes de um controle Nome de Tipo quando o controle é criado declarativamente em uma página.Para permitir que seu controle seja usado declarativamente em uma página, o ASP.NET precisa um prefixo de marca que é mapeado para o espaço de nomes do seu controle.Um desenvolvedor de página pode fornecer um mapeamento de prefixo/Namespace de marca adicionando um @ Register Diretiva em cada página que usa o controle personalizado, as in o exemplo a seguir:

< % @ registrar tagPrefixo = "aspSample" NameEspaço="Exemplos.AspNet.CS.Controls"% >

[Visual Basic]

< % @ registrar tagPrefix = "aspSample" Namespace="Samples.AspNet.VB.Controls"% >
Observação:

O @ Register diretiva na ASP.NET 2.0 é o mesmo no ASP.NET 1.0 e 1.1 ASP.NET.Se você estiver familiarizado com o Registrar diretiva nas versões anteriores do ASP.NET, você poderá notar que o Assembly Atributo que especifica o nome do controle Assembly está ausente no anterior Registrar Diretiva.Quando o Assembly atributo estiver ausente, ASP.NET infere que o conjunto é compilado dinamicamente dos arquivos de origem no diretório App_Código.

Como um correspondesse Nativo a usar o @ Register Diretiva em cada página .aspx, o desenvolvedor de página pode especificar o mapeamento de prefixo/espaço para nome de marca no arquivo de Web.config.Isso é útil se o controle personalizado será usado em várias páginas em um aplicativo da Web.O procedimento a seguir descreve como especificar o mapeamento de prefixo de marca no arquivo web.config.

Para adicionar um mapeamento de prefixo de marca no arquivo web.config

  1. Crie um arquivo de texto denominado Web.config no diretório raiz do seu Web site, se esse arquivo ainda não existir.

  2. Se você criou um novo arquivo Web.config (vazio), copie o código a seguir para o arquivo e salve o arquivo.

    <? XML Versão = "1.0"? > < configuração > < system.web > < páginas > < controles >
     < Adicionar tagPrefix = "aspSample"        namespace="Samples.AspNet.CS.Controls" >     < > /Adicionar
     < / controla > < / páginas > < /system.web > < / configuração >

    <? XML Versão = "1.0"? > < configuração > < system.web > < páginas > < controles >
     < Adicionar tagPrefix = "aspSample"        namespace="Samples.AspNet.VB.Controls" >     < > /Adicionar
     < / controla > < / páginas > < /system.web > < / configuração >

    A seção realçada mostra uma entrada de prefixo de marca, que Mapas o marca o prefixo "aspSample" ao espaço para nome. Samples.AspNet.CS.Controls ou Samples.AspNet.VB.Controls.

  3. Se um arquivo Web.config AL Pronto existe, adicionar o texto realçado da etapa anterior como um filho das Controles Elemento da arquivo de configuração.Se a Controles e Páginas Elementos não existir no arquivo web.config, criar esses elementos como ilustrado na etapa anterior.

    Observação:

    A entrada de prefixo de marca deve ser um filho das Controles seção, que deve ser na Páginas seção, que em Ativar deve ser um filho de System.Web.

Após você tiver especificado o mapeamento de prefixo de marca no arquivo de configuração, você pode usar o WelcomeLabel Controle declarativamente (como < aspSample:WelcomeLabel / > em qualquer página no site.

Observação:

Uma entrada de configuração para o prefixo de marca é um novo recurso do ASP.NET 2.0.No ASP.NET 1.0 e 1.1 o mapeamento de prefixo de marca foi especificado na @ Register Diretiva em cada página que usado a controle personalizado.

Criando uma página para usar o controle

Para criar uma página que usa a controle personalizado

  1. Crie um arquivo de texto chamado WelcomeLabelTest.aspx no seu Web site.

  2. Copie a marcação a seguir para o arquivo WelcomeLabelTest.aspx e salve o arquivo.

    <%@ Page Language=%>
<!DOCTYPE html PUBLIC 
    >
<html xmlns= >
  <head id= runat=>
    <title>WelcomeLabel Test</title>
  </head>
  <body>
    <form id= runat=>
      <div>
        <aspSample:WelcomeLabel Text= ID= 
          runat= BackColor= ForeColor= />
      </div>
    </form>
  </body>
</html>

    <%@ Page Language=%>
<!DOCTYPE html PUBLIC "-
    "http:
<html xmlns="http:
  <head id= runat=>
    <title>WelcomeLabel Test</title>
  </head>
  <body>
    <form id= runat=>
      <div>
        <aspSample:WelcomeLabel Text= ID= 
          runat= BackColor= ForeColor= />
      </div>
    </form>
  </body>
</html>

  3. Exiba WelcomeLabelTest.aspx no seu navegador inserindo a URL a seguir na barra de endereços:

    https://localhost/ServerControlsTest/WelcomeLabelTest.aspx

  4. Faça alguma alteração no código-fonte do controle.Por exemplo, escrever uma seqüência de caracteres adicional, adicionando esta linha de código no final das [M:System.Web.UI.WebControls.WebControl.Renderconteúdo(System.Web.UI.HtmlTextWriter)] Método:

    Writer.Write ("Teste como o diretório App_Code funciona.");

    Writer.Write ("Teste como o diretório App_Code funciona.")

  5. Atualize a página WelcomeLabelTest.aspx no seu navegador.

    Você verá que as alterações no controle são refletidas na página mesmo que você não compile o controle.

Além disso, para o WelcomeLabel do controle Texto Propriedade que você explicitamente definido, você pode ver a instância de controle na página que ele tem BackColor e Forecolor Propriedades que você não Definir.O WelcomeLabel o controle obtém essas e outras propriedades estilo-relacionados por herança da WebControl classe base.Além disso, WelcomeLabel Pode ser atribuída uma capa e ser parte de um tema sem qualquer trabalho de sua parte.

Compilando o controle em um conjunto de módulos (assembly)

Embora o diretório App_Code permita que você teste seu controle sem compilá-lo, se você deseja distribuir o controle como Código de objeto para outros desenvolvedores, é necessário compilá-lo.Além disso, um controle não pode ser adicionado à caixa de ferramentas de um designer de visual, a menos que ele seja compilado em um conjunto de módulos (assembly).

Compilando o controle em um conjunto de módulos (assembly)

  1. Definir o ambiente do Windows PATH Variável de seu computador para incluir o caminho para a instalação do .NET Framework, seguindo estas etapas:

    1. No Windows, clique com o botão direito do mouse Meu computadorSelecione PropriedadesClique na Avançado Guia e clique na Environment Variables Botão.

    2. Na As variáveis do sistema Na lista, Duplo - clique na Path variável.

    3. Na O valor da variável caixa de texto, adicione um ponto-e-vírgula (;) ao final dos valores existentes no caixa de texto e, em seguida, tipo o caminho da sua instalação do .NET Framework.O .NET Framework é geralmente instalado em diretório de instalação o Windows em \Microsoft.NET\Framework\NúmeroVersão.

    4. Clique em OK Para fechar cada caixa de diálogo.

  2. Execute o seguinte comando a partir do diretório que você criou para arquivos de origem no primeiro procedimento dessa explicação passo a passo.

    Observação:

    Isso é diferente do diretório App_Code onde você copiou o arquivo de origem do controle para teste.

    		 
    CSC /t:Biblioteca /out:Exemplos.AspNet.CS.Controles.dll /r:Sistema.dll /r:Sistema.Web.dll *.cs

    VBC /t:library /out:Samples.AspNet.VB.Controls.dll /r:System.dll /r:System.Web.dll *.vb

    O /t:Library opção de compilador informa o compilador para criar uma biblioteca, em vez de uma Executável conjunto de módulos (assembly).O /out opção fornece um nome para o conjunto e a /r opção Listas os conjuntos de módulos (assemblies) que estão vinculados a seu conjunto de módulos (assembly).

Para manter o exemplo independente, essa explicação passo a passo solicita que você criar um conjunto de módulos (assembly) com um único controle.Em geral, as diretrizes de design do .NET Framework recomendam que você não crie conjuntos de módulos (assemblies) que contêm apenas algumas classes.Para facilitar a implantação, você deve criar menor número de conjuntos de módulos (assemblies) possível.

Incorporando um ícone no conjunto de módulos do controle

Um designer visual, como Visual Studio 2005 Normalmente usa um ícone padrão (como uma imagem de um trem de pouso) para exibir um Controlarar na Caixa de ferramentas.Como uma opção para o seu controle, você pode personalizar a aparência do seu controle na caixa de ferramentas, incorporando um bitmap 16x16 pixels no conjunto de módulos (assembly) do seu controle.Por convenção, designers visuais usam o pixel esquerdo mais baixo do bitmap como a cor transparente.

Para incorporar um ícone no assembly do controle

  1. Criar ou obter um bitmap 16x16 pixels como o ícone da caixa de ferramentas para o seu controle.

  2. Nomeie o bitmap WelcomeLabel.bmp.

  3. Adicionar o arquivo de bitmap de diretório (CustomControlsCS ou CustomControlsVB) w aqui tiver os arquivos de origem para o WelcomeLabel o controle.

  4. Execute o seguinte comando a partir do diretório que contém os arquivos de origem:

    CSC /res:WelcomeRótulo.bmp,Samples.AspNet.CS.Controls.WelcomeRótulo.bmp /t:library /out:Samples.AspNet.CS.Controls.dll /r:System.dll /r:System.Web.dll *.cs

    VBC /res:WelcomeLabel.bmp,Samples.AspNet.VB.Controls.WelcomeLabel.bmp /t:library /out:Samples.AspNet.VB.Controls.dll /r:System.dll /r:System.Web.dll *.vb

    Esse comando compila o controle e incorpora o bitmap no conjunto de módulos (assembly) como um recurso.Você deve nomear o recurso de bitmap incorporado exatamente igual ao nome do espaço de nomes qualificado do controle com o qual ele está associado.Por exemplo, se for o nome do controle Samples.AspNet.CS.Controls.WelcomeLabelo nome do bitmap incorporado deve ser Samples.AspNet.CS.Controls.WelcomeLabel.bmp.Esta convenção de nomeclatura faz com que um designer visual use automaticamente o bitmap como ícone da caixa de ferramentas do seu controle.Se você não usar o convenção de nomeclatura, você deve aplicar o ToolboxBitmapAttribute Para o controle para especificar o nome do bitmap incorporado recurso.

Usando o TagPrefixAttribute para fornecer um mapeamento de prefixo de marca/Espaço de nome

Anteriormente nessa explicação passo a passo, ao usar o diretório App_Code, você viu como um desenvolvedor de página pode especificar um prefixo de marca na página ou no arquivo Web.config.Opcionalmente, você pode sugerir um prefixo de marca padrão que um designer visual deve usar para o controle, incluindo o Assembly - nível System.Web.UI.TagPrefixAttribute Atributo.O TagPrefixAttribute Atributo é útil porque ele fornece um prefixo de marca para um designer visual a ser usado se o designer não Localizar um mapeamento de prefixo de marca no arquivo web.config ou em um Registrar diretiva na página.O prefixo de marca é registrado com a página na primeira vez o controle é clicado duas vezes na caixa de ferramentas ou arrastado da caixa de ferramentas até a página.

Se você decidir usar o TagPrefixAttribute Atributo, você pode especificá-lo em um arquivo separado que é compilado com os controles.Por convenção, o arquivo é chamado AssemblyInformações.languageExtensionComo AssemblyInfo.cs ou AssembyInfo.vb.O procedimento a seguir descreve como especificar o TagPrefixAttribute Os metadados.

Observação:

Se você não especificar o TagPrefixAttribute No conjunto do controle e a página desenvolvedor não especifica o mapeamento de prefixo/Namespace de marca na página ou no arquivo web.config, o designer visual pode criar um prefixo de marca padrão.Por exemplo, Visual Studio 2005 criará sua própria marca (como cc1 para o controle quando o controle é arrastado da Caixa de ferramentas.

Para adicionar um mapeamento de prefixo de marca/espaço de nome usando o TagPrefixAttribute

  1. Crie um arquivo chamado AssemblyInfo.cs ou AssemblyInfo.vb no diretório de código-fonte e adicione o código a seguir para o arquivo.

    Usando o sistema; Usando System.Web.UI; [assembly: tagPrefixo ("Exemplos.AspNet.CS.Controls", "aspExemplo")]

    Importações sistema Importações System.Web.UI < assembly: tagPrefix ("Samples.AspNet.VB.Controls", "aspSample") >

    O atributo de prefixo de marca cria um mapeamento entre o espaço para nome Samples.AspNet.CS.Controls ou Samples.AspNet.VB.Controls e o prefixo aspSample.

  2. Recompile todos os arquivos de origem usando o comando de compilação utilizado anteriormente (com ou sem o recurso incorporado).

Usando o controle personalizado compilado em uma página ASP.NET

Para testar a versão compilada do seu controle personalizado, você deve tornar o conjunto de módulos (assembly) do controle acessível para páginas no Web site.

Para tornar o conjunto de módulos (assembly) do controle acessível para o site

  1. Crie um diretório Bin abaixo da raiz do site.

  2. Copie o conjunto de módulos do controle (Samples.AspNet.CS.Controls.dll ou Samples.AspNet.VB.Controls.dll) para o diretório Bin.

  3. Exclua arquivo de origem do controle do diretório App_Code.

    Se você não excluir os arquivos de origem, o controle do tipo existirá em Ambos o assembly compilado e o assembly gerado dinamicamente criado pelo ASP.NET.Isso criará um ambíguo referência quando Carregando o controle e qualquer página na qual o controle é usado gerará um erro do compilador.

O conjunto que você criou nessa explicação passo a passo é chamaodo um conjunto de módulos particular porque ele deve ser colocado no diretório Bin de um site ASP.NET para habilitar páginas no Web site para usar o seu controle.O conjunto de módulos não pode ser acessado a partir de outros aplicativos, a menos que também esteja instalada uma cópia nesses aplicativos.Se você estiver criando controles para aplicativos compartilhados hospedados na Web, você geralmente irá empacotar os controles em um conjunto de módulos particular.No entanto, se você criar controles para usar em um ambiente de hospedagem dedicado ou um conjunto de controles que um provedor de serviços de Internet torna disponível para todos os seus clientes, você talvez precise empacotar os controles em um conjunto compartilhado (altamente nomeado) instalado na cache global de conjunto de módulos (assemblies).Para obter mais informações, consulte Trabalhando com Assemblies e o Cache Global de Assemblies.

Em seguida, você deve modificar o mapeamento do prefixo de marca que você criou em Web.config para especificar o nome do conjunto de módulos (assembly) do seu controle.

Para modificar o mapeamento de prefixo de marca em Web.config

  • Editar o arquivo web.config para adicionar um Assembly Atributo para a uma AdicionartagPrefix Elemento:

    < controles > < Adicionar tagPrefix = "aspSample" nameEspaço="Samples.AspNet.CS.Controls " 
    Assembly="Samples.AspNet.CS.Controls" > < > /Adicionar < / controla >

    < controles > < Adicionar tagPrefix = "aspSample" namespace="Samples.AspNet.VB.Controls " 
    Assembly="Samples.AspNet.VB.Controls" > < > /Adicionar < / controla >

O Assembly Atributo especifica que o nome do conjunto de módulos (assembly) o controle está em.Um AdicionartagPrefix Elemento Mapas um prefixo de marca para uma combinação de espaço para nome e conjunto de módulos (assembly).Quando o conjunto módulos é gerado dinamicamente pelo ASP.NET a partir dos arquivos de origem na pasta App_Code, o atributo de conjunto de módulos (assembly) não é necessário.Quando o atributo de conjunto de módulos (assembly) não é usado, o ASP.NET carrega o tipo do controle a partir dos conjuntos de módulos gerados dinamicamente do diretório App_Code.

Para exibir a página que usa a controle personalizado

  • Exiba a página WelcomeLabelTest.aspx no seu navegador inserindo a URL a seguir na barra de endereços:

    https://localhost/ServerControlsTest/WelcomeLabelTest.aspx

Se você usar o controle em um visual Designer como Visual Studio 2005Você poderá adicionar o controle à Caixa de ferramentas, arraste-o da caixa de ferramentas para o superfície de design e o acesso propriedades e eventos na Pesquisador de Propriedade.Além disso, no Visual Studio 2005o controle tem suporte completo IntelliSense em Exibir Source do criador da página e a editor de códigos.Isso inclui Preenchimento automático de instrução em um Script Bloquear, bem como a propriedade Suporte ao navegador quando um desenvolvedor de página clica marca do controle.

Observação:

Em muitos designers visuais, você pode adicionar controles personalizados para a caixa de ferramentas do designer.Para obter detalhes, consulte a documentação para o seu designer.

Próximas etapas

Essa explicação passo a passo mostrou como desenvolver um controle de servidor personalizado simples do ASP.NET e usá-lo em uma página.Você viu como definir uma propriedade e como compilar o seu controle em um conjunto de módulos (assembly).Para obter mais informações, incluindo informações sobre o processamento, definindo propriedades, manter o estado e implementar controles de composição, consulte Desenvolvendo Controles Personalizados ASP.NET Server.

Na explicação passo a passo, você viu que você pode fornecer um ícone da caixa de ferramentas personalizado para o seu controle.Você também aprendeu como você pode adicionar metadados em tempo de design para personalizar o suporte ao navegador de propriedade para o seu controle.Complexo controla como o GridView Controle mais aprimorar sua experiência em tempo de design Usando classes de designer visual que fornecem um diferentes interface do usuário tempo de design e tempo de execução.O modelo de objeto de designer do ASP.NET 2.0 para controles de servidor é significativamente diferente do modelo fornecido no ASP.NET 1.0 e 1.1.Para saber sobre a implementação Personalizar classes Designer para os controles em ASP.NET 2.0, consulte Visão Geral sobre os Designers de Controle do ASP.NET.

No ASP.NET 2.0, um controle de servidor pode definir diferentes comportamentos para navegadores clientes ou dispositivos usando classes de adaptador.Para obter mais informações, consulte Desenvolvimento de adaptadores para controles Servidor ASP.NET

Navegadores diferentes, e diferentes versões do mesmo navegador, suportam recursos diferentes.Controles de servidor ASP.NET irão automaticamente determinar o navegador que solicitou a página .aspx e formatar a marcação HTML que ele gera corretamente para o navegador.No entanto, alguns recursos de controle não podem ser processados em navegadores mais antigos, portanto, é uma boa idéia observar a saída de suas páginas no máximo de tipos de navegador possível para garantir que as páginas serão apresentadas para todos os navegadores da maneira como deseja que elas sejam.Para obter mais informações, consulte Controles de Servidor Web do ASP.NET e Recursos do Navegador.

Consulte também

Outros recursos

Desenvolvendo Controles Personalizados ASP.NET Server