Partilhar via

Demonstra Passo a passo: Criando um controle de Web do ASP.NET personalizados ligados a dados para ASP.NET 2.0

  • Artigo

Essa explicação passo a passo mostra como criar um simples controle de servidor Web associado a dados no ASP.NET 2.0.Na versão ASP.NET 2.0, um novo modelo de fonte de dados permite que você acople controles associados a dados aos controles de fonte, permitindo que operações de dados comuns - como paginação, ordenação, e exclusão - sejam removidas do controle associado a dados em si.Esse modelo possibilita uma maior flexibilidade do controle associado a dados para desenvolvedores de páginas e aumenta o nível de reuso.O modelo fonte de dados ASP.NET 2.0 também oferece suporte à ligação diretamente para um objeto da coleção de dados.Para obter mais informações sobre o desenvolvimento personalizados controles ligados a dados para o modelo de dados ASP.NET 2.0, consulte Desenvolvendo Controles Personalizados de Servidores Web Vinculados a Dados para ASP.NET 2.0.

Nesta explicação passo a passo, você criará um controle associado a dados que pode se vincular a qualquer objeto que implementa a interface IEnumerable.

Tarefas ilustradas nesta explicação passo a passo incluem o seguinte:

  • A criação de um site para testar o controle associado a dados personalizado com compilação dinâmica.

  • Criar uma classe controle vinculado a dados que estende a classe base DataBoundControl.Essa classe exibe uma coluna de tabela que representa os dados associados.A seguir é uma visão geral sobre o que a classe controle associado a dados deve fornecer:

    • Uma substituição do método PerformSelect da classe base controle associado a dados.Dentro desse método, tarefas são executadas para iniciar a recuperação de dados.

    • Um método com um único parâmetro do tipo IEnumerable para receber os dados retornados.Qualquer processamento de dados que pode ser necessário é executada dentro desse método.Como última etapa, o método PerformDataBinding é chamado para iniciar associação de dados.

    • Uma substituição do método PerformDataBinding.Dentro desse método os dados recuperados são enumerados e controles filho são adicionados para representar os dados.

  • Registrando o controle no arquivo web.config.

  • Testando o controle em um página ASP.NET.

  • Compilando o controle de modo que você pode distribuí-lo como código binário.

  • Testando o controle personalizado de servidor associado a dados compilado.

Criando um site da Web para testar o controle

Você pode usar a compilação dinâmica do ASP.NET para testar o 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).

Observação:

O diretório App_Code não está 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 as versões anteriores do ASP.NET, conforme descrito na próxima seção "Compilando o controle em um conjunto de módulos (assembly)".

Para criar um site da Web para testar controles personalizados ligados a dados.

  1. Crie um site denominado ServerControlsTest.

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

  2. Crie um diretório App_Code diretamente sob a diretório raiz de seu Web site (a raiz do aplicativo Web).

Criando a classe SimpleDataBoundColumn

Nesta seção, você criará a classe controle associado a dados que estende a classe DataBoundControl.O novo controle exibe os dados associados a uma tabela de uma coluna.

Para criar a classe SimpleDataBoundColumn

  1. Na pasta App_Code, crie uma classe denominada SimpleDataBoundColumn.cs ou SimpleDataBoundColumn.vb.

  2. Adicione o seguinte código ao seu arquivo classe:

    Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.Security.Permissions
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls

Namespace Samples.AspNet.Controls.VB

    <AspNetHostingPermission(SecurityAction.Demand, _
        Level:=AspNetHostingPermissionLevel.Minimal), _
        AspNetHostingPermission(SecurityAction.InheritanceDemand, _
        Level:=AspNetHostingPermissionLevel.Minimal)> _
    Public Class SimpleDataBoundColumn
        Inherits DataBoundControl

        Public Property DataTextField() As String
            Get
                Dim o As Object = ViewState("DataTextField")
                If o Is Nothing Then
                    Return String.Empty
                Else
                    Return CStr(o)
                End If
            End Get
            Set(ByVal value As String)
                ViewState("DataTextField") = value
                If (Initialized) Then
                    OnDataPropertyChanged()
                End If
            End Set
        End Property

        Protected Overrides Sub PerformSelect()
            ' Call OnDataBinding here if bound to a data source using the
            ' DataSource property (instead of a DataSourceID), because the
            ' databinding statement is evaluated before the call to GetData.       
            If Not IsBoundUsingDataSourceID Then
                OnDataBinding(EventArgs.Empty)
            End If

            ' The GetData method retrieves the DataSourceView object from  
            ' the IDataSource associated with the data-bound control.            
            GetData().Select(CreateDataSourceSelectArguments(), _
                AddressOf OnDataSourceViewSelectCallback)

            ' The PerformDataBinding method has completed.
            RequiresDataBinding = False
            MarkAsDataBound()

            ' Raise the DataBound event.
            OnDataBound(EventArgs.Empty)

        End Sub

        Private Sub OnDataSourceViewSelectCallback(ByVal retrievedData As IEnumerable)
            ' Call OnDataBinding only if it has not already been 
            ' called in the PerformSelect method.
            If IsBoundUsingDataSourceID Then
                OnDataBinding(EventArgs.Empty)
            End If
            ' The PerformDataBinding method binds the data in the  
            ' retrievedData collection to elements of the data-bound control.
            PerformDataBinding(retrievedData)

        End Sub

        Protected Overrides Sub PerformDataBinding(ByVal retrievedData As IEnumerable)
            MyBase.PerformDataBinding(retrievedData)

            ' Verify data exists.
            If Not (retrievedData Is Nothing) Then
                Dim tbl As New Table()
                Dim row As TableRow
                Dim cell As TableCell
                Dim dataStr As String = String.Empty

                Dim dataItem As Object
                For Each dataItem In retrievedData
                    ' If the DataTextField was specified get the data
                    ' from that field, otherwise get the data from the first field. 
                    If DataTextField.Length > 0 Then
                        dataStr = DataBinder.GetPropertyValue(dataItem, DataTextField, Nothing)
                    Else
                        Dim props As PropertyDescriptorCollection = TypeDescriptor.GetProperties(dataItem)
                        If props.Count >= 1 Then
                            If Nothing <> props(0).GetValue(dataItem) Then
                                dataStr = props(0).GetValue(dataItem).ToString()
                            End If
                        End If
                    End If

                    row = New TableRow()
                    tbl.Rows.Add(row)
                    cell = New TableCell()
                    cell.Text = dataStr
                    row.Cells.Add(cell)
                Next dataItem

                Controls.Add(tbl)
            End If

        End Sub
    End Class
End Namespace

    using System;
using System.Collections;
using System.ComponentModel;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace Samples.AspNet.Controls.CS
{
    [AspNetHostingPermission(SecurityAction.Demand,
       Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand,
        Level = AspNetHostingPermissionLevel.Minimal)]
    public class SimpleDataBoundColumn : DataBoundControl
    {
        public string DataTextField
        {
            get
            {
                object o = ViewState["DataTextField"];
                return ((o == null) ? string.Empty : (string)o);
            }
            set
            {
                ViewState["DataTextField"] = value;
                if (Initialized)
                {
                    OnDataPropertyChanged();
                }
            }
        }

        protected override void PerformSelect()
        {
            // Call OnDataBinding here if bound to a data source using the
            // DataSource property (instead of a DataSourceID), because the
            // databinding statement is evaluated before the call to GetData.       
            if (!IsBoundUsingDataSourceID)
            {
                this.OnDataBinding(EventArgs.Empty);
            }

            // The GetData method retrieves the DataSourceView object from  
            // the IDataSource associated with the data-bound control.            
            GetData().Select(CreateDataSourceSelectArguments(),
                this.OnDataSourceViewSelectCallback);

            // The PerformDataBinding method has completed.
            RequiresDataBinding = false;
            MarkAsDataBound();

            // Raise the DataBound event.
            OnDataBound(EventArgs.Empty);
        }

        private void OnDataSourceViewSelectCallback(IEnumerable retrievedData)
        {
            // Call OnDataBinding only if it has not already been 
            // called in the PerformSelect method.
            if (IsBoundUsingDataSourceID)
            {
                OnDataBinding(EventArgs.Empty);
            }
            // The PerformDataBinding method binds the data in the  
            // retrievedData collection to elements of the data-bound control.
            PerformDataBinding(retrievedData);
        }

        protected override void PerformDataBinding(IEnumerable retrievedData)
        {
            base.PerformDataBinding(retrievedData);

            // Verify data exists.
            if (retrievedData != null)
            {
                Table tbl = new Table();
                TableRow row;
                TableCell cell;
                string dataStr = String.Empty;

                foreach (object dataItem in retrievedData)
                {
                    // If the DataTextField was specified get the data
                    // from that field, otherwise get the data from the first field. 
                    if (DataTextField.Length > 0)
                    {
                        dataStr = DataBinder.GetPropertyValue(dataItem,
                            DataTextField, null);
                    }
                    else
                    {
                        PropertyDescriptorCollection props =
                                TypeDescriptor.GetProperties(dataItem);
                        if (props.Count >= 1)
                        {
                            if (null != props[0].GetValue(dataItem))
                            {
                                dataStr = props[0].GetValue(dataItem).ToString();
                            }
                        }
                    }

                    row = new TableRow();
                    tbl.Rows.Add(row);
                    cell = new TableCell();
                    cell.Text = dataStr;
                    row.Cells.Add(cell);
                }

                this.Controls.Add(tbl); 
            }
        }
    }
}

Discussão de Código

A classe SimpleDataBoundColumn deriva da classe base DataBoundControl de associação de dados.A derivação deste classe base fornece propriedades de associação de dados DataSourceID, DataSource e DataMember expostos.Essas propriedades expostas permitem um desenvolvedor de página especificar a fonte de dados e um membro de dados específico para vincular a este controle personalizado.

Para ilustrar como adicionar propriedades personalizadas de associação de dados adicionais, uma propriedade DataTextField foi adicionada à classe SimpleDataBoundColumn.Quando o desenvolvedor de página define a propriedade DataTextField, o novo valor é armazenado em estado de exibição.Ele também chama o método OnDataPropertyChanged se o controle já foi inicializado.Isso força o controle associado a dados a reassociar os dados de forma que o controle pode usar a nova configuração de propriedades de associação de dados.

O método DataBind substituído é necessário, e inclui a lógica para enumerar o objeto na fonte de dados associada e criar controles filho.As seguintes tarefas devem ser executadas em controles associados a dados ASP.NET 2.0 no método DataBind substituído, conforme mostrado na classe SimpleDataBoundColumn:

  • A propriedade IsBoundUsingDataSourceID é verificada para um valor false para determinar se a fonte de dados está especificada na propriedade DataSource.

  • Se os dados a serem vinculados estão especificados na propriedade DataSource, o método OnDataBinding é chamado para vincular o membro de dados que é especificado na propriedade DataSource.

  • O método GetData é chamado para recuperar o objeto DataSourceView que está associado ao controle associado a dados.

  • O método Select do objeto DataSourceView recuperado é chamado para iniciar a recuperação de dados e especificar o método callback OnDataSourceViewSelectCallback que manipulará os dados recuperados.

  • Para indicar que as tarefas de recuperação de dados do método PerformSelect são completas, a propriedade RequiresDataBinding é definida como false e, em seguida, o método MarkAsDataBound é chamado.

  • O evento OnDataBound é gerado.

O método callback OnDataSourceViewSelectCallback recebe os dados recuperados.Esta método callback deve aceitar um único parâmetro do tipo IEnumerable.Qualquer processamento de dados deve ocorrer aqui se o controle personalizado requiser.Este controle personalizado usa os dados como estão.Portanto, nenhum processamento adicional de dados ocorre neste exemplo.Como última etapa, o método PerformDataBinding é chamado para iniciar o processo de vinculação de dados.

Na substituição do método PerformDataBinding, todos os controles filhos que representarão os dados são criados.A coleção de dados é enumerada e um novo objeto TableCell é criado para cada item de dados.Se a propriedade DataTextField é definida, ela é usada para determinar qual campo de dados está vinculado à propriedade Text da célula.Caso contrário, o primeiro campo é usado.

O controle Table pai é adicionado ao controle personalizado SimpleDataBoundColumn da coleção Controls.Qualquer controle que é adicionado à coleção Controls do controle é automaticamente processada enquanto o método Render herdado é executado.

Para obter mais informações sobre as implementações necessárias de uma controle de servidor Web de dados associados, consulte Desenvolvendo Controles Personalizados de Servidores Web Vinculados a Dados para ASP.NET 2.0.

Criando um prefixo de marca

Um prefixo de marca é o prefixo, como "ASP" na <asp:Table />, que aparece antes do nome do tipo de controle 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/espaço de nomes adicionando uma diretiva @ Register em cada página que usa o controle personalizado, como no exemplo a seguir:

<%@ Register TagPrefix="aspSample" 
    Namespace="Samples.AspNet.Controls.CS"%>

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

Observe que há nenhum atributo assembly que especifica o nome do conjunto de controle na diretiva @ Register.Quando o atributo assembly estiver faltando, o ASP.NET infere que o conjunto é compilado dinamicamente dos arquivos de origem no diretório App_Code.

As an alternative to using the @ Register directive in each .aspx page, the page developer can specify the tag prefix and namespace mapping in the Web.config file.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. Se o seu site da Web ainda não tiver um, crie um arquivo denominado Web.config na pasta raiz da página Web.

  2. Se você criou um novo arquivo Web.config, copie a marcação XML a seguir para o arquivo e salve o arquivo.Se o seu site já tiver um arquivo Web.config, adicione o seguinte elemento realçado a ele.

    Observação:

    A entrada de prefixo de marca deve ser um filho da seção controls, que deve estar na seção pages que, por sua vez deve ser um filho de system.web.

    		 
    <?xml version="1.0"?>
<configuration>
  <system.web>
    <pages>
      <controls>
        <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.CS" />
      </controls>
    </pages>
  </system.web>
</configuration>

    <?xml version="1.0"?>
<configuration>
  <system.web>
    <pages>
      <controls>
        <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.VB" />
      </controls>
    </pages>
  </system.web>
</configuration>

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

Depois de especificar o mapeamento de prefixo de marca no arquivo de configuração, você pode usar o controle SimpleDataBoundColumn declarativamente (como <aspSample:SimpleDataBoundColumn />) em qualquer página do site.

Observação:

No ASP.NET 1.0 e 1.1 o mapeamento do prefixo de marca foi especificado na diretiva @ Register em cada página que usou o controle personalizado.

Criando uma página para usar o controle personalizado de dados vinculados

Nesta seção da explicação passo a passo você criará uma marcação de página que vai permitir que você teste o controle personalizado associado a dados.

Para criar uma página que usa o controle personalizado associado a dados

  1. No seu site da Web, crie um arquivo chamado TestSimpleDataBoundColumn.aspx.

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

    <%@ Page Language="VB" Trace="true"%>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.Controls.VB" %>
<%@ Import Namespace="System.Data" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<script >
         Function CreateDataSource() As ICollection 

         ' Create sample data for the DataList control.
         Dim dt As DataTable = New DataTable()
         dim dr As DataRow

         ' Define the columns of the table.
         dt.Columns.Add(New DataColumn("IntegerValue", GetType(Int32)))
         dt.Columns.Add(New DataColumn("StringValue", GetType(String)))
         dt.Columns.Add(New DataColumn("CurrencyValue", GetType(Double)))
         dt.Columns.Add(New DataColumn("ImageValue", GetType(String)))

         ' Populate the table with sample values.
         Dim i As Integer

         For i = 0 To 8 

            dr = dt.NewRow()

            dr(0) = i
            dr(1) = "Description for item " & i.ToString()
            dr(2) = 1.23 * (i + 1)
            dr(3) = "Image" & i.ToString() & ".jpg"

            dt.Rows.Add(dr)

         Next i

         Dim dv As DataView = New DataView(dt)
         Return dv

      End Function

      Sub Page_Load(sender As Object, e As EventArgs) 

         ' Load sample data only once, when the page is first loaded.
         If Not IsPostBack Then 

            simpleDataBoundColumn1.DataSource = CreateDataSource()
            simpleDataBoundColumn1.DataBind()

         End If

      End Sub

</script>

<head >
    <title>SimpleDataBoundColumn test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundColumn  id="simpleDataBoundColumn1" DataTextField="CurrencyValue" BorderStyle="Solid"></aspSample:SimpleDataBoundColumn>
    </div>
    </form>
</body>
</html>

    <%@ Page Language="C#" Trace="true"%>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.Controls.CS" %>
<%@ Import Namespace="System.Data" %>

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

      ICollection CreateDataSource() 
      {
         DataTable dt = new DataTable();
         DataRow dr;

         dt.Columns.Add(new DataColumn("IntegerValue", typeof(Int32)));
         dt.Columns.Add(new DataColumn("StringValue", typeof(string)));
         dt.Columns.Add(new DataColumn("CurrencyValue", typeof(double)));

         for (int i = 0; i < 9; i++) 
         {
            dr = dt.NewRow();

            dr[0] = i;
            dr[1] = "Item " + i.ToString();
            dr[2] = 1.23 * (i + 1);

            dt.Rows.Add(dr);
         }

         DataView dv = new DataView(dt);
         return dv;
      }

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            simpleDataBoundColumn1.DataSource = CreateDataSource();
            simpleDataBoundColumn1.DataBind();
        }
    }
</script>

<head >
    <title>SimpleDataBoundColumn test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundColumn  id="simpleDataBoundColumn1" DataTextField="CurrencyValue" BorderStyle="Solid"></aspSample:SimpleDataBoundColumn>
    </div>
    </form>
</body>
</html>

  3. Execute a página SimpleDataBoundColumnTest.aspx.

  4. Faça algumas alteração no o código-fonte do controle personalizado.Por exemplo, escreva uma sequência de caracteres adicional, adicionando esta linha de código no final do método RenderContents:

    writer.Write("<br />Testing how the App_Code directory works.");

    writer.Write("<br />Testing how the App_Code directory works.")

  5. Atualize a página SimpleDataBoundColumnTest.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.

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

O diretório App_Code permite que você teste seu controle sem compilá-lo.No entanto, se você quiser distribuir o controle como código de objeto para outros desenvolvedores, você deve 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 a variável de ambiente do Windows PATH 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 em Meu computador, clique em Propriedades, clique na guia Avançado e, em seguida, clique no botão Variáveis de Ambiente.

    2. Na lista Variáveis do sistema, clique duas vezes na variável Path.

    3. Na caixa de texto Variable value, adicione um ponto-e-vírgula (;) até o final dos valores existentes na caixa de texto e digite o caminho da instalação do .NET Framework.Geralmente o .NET Framework é instalado na pasta de instalação do Windows no \\Microsoft .NET\\Framework\versionNumber.

    4. Clique OK para fechar cada caixa de diálogo.

  2. Execute o seguinte comando a partir do diretório App_Code que contém os arquivos de origem criados em um procedimento anterior dessa explicação passo a passo.Isso gera um conjunto de módulos (assembly) denominado Samples.AspNet.CS.dll ou Samples.AspNet.Controls.VB.dll na pasta App_Code.

    csc /t:library /out:Samples.AspNet.Controls.CS.dll /r:System.dll /r:System.Web.dll *.cs

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

    A opção /t:library do compilador informa a esse para criar uma biblioteca, em vez de um conjunto de módulos executável (Assembly).A opção /outfornece um nome para o conjunto de módulos e a opção /r lista os módulos que estão vinculados ao seu conjunto de módulos.

    Observação:

    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.

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

Anteriormente você viu como um desenvolvedor de página pode especificar um prefixo de marca na página ou no arquivo web.config.Quando você compila um controle, você pode, opcionalmente, sugerir um prefixo de marca padrão que um designer visual deve usar para o seu controle incluindo o atributo System.Web.UI.TagPrefixAttribute de nível de montagem.O atributo TagPrefixAttribute é útil porque ele fornece um prefixo de marca para um designer visual a ser usado se o designer não encontrar um mapeamento de prefixo de marca no arquivo web.config ou em uma diretiva @ Register 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 atributo TagPrefixAttribute, você pode especificá-lo em um arquivo separado que é compilado com seus controles.Por convenção, o arquivo é nomeado AssemblyInfo. languageExtension, sistema autônomo AssemblyInfo.cs ou AssembyInfo.vb.O procedimento a seguir descreve como especificar o TagPrefixAttribute metadados.

Observação:

Se você não especificar TagPrefixAttribute no conjunto de montagem do controle, e o desenvolvedor de página não especificar o mapeamento de prefixo de marca/namespace 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 seu controle quando o controle é arrastado da caixa de ferramentas.

Para adicionar um mapeamento de prefixo de marca utilizando um 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.

    using System;
using System.Web.UI;
[assembly: TagPrefix("Samples.AspNet.Controls.CS", "aspSample")]

    Imports System
Imports System.Web.UI
<Assembly: TagPrefix("Samples.AspNet.Controls.VB", "aspSample")>

    O atributo de prefixo de marca cria um mapeamento entre o namespace Samples.AspNet.Controls.CS ou Samples.AspNet.Controls.VB 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 compilado personalizado do servior de dados-vinculados 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. Arraste o controle de conjunto de módulos (assembly) (Samples.AspNet.Controls.CS.dll ou Samples.AspNet.Controls.VB.dll) a partir do diretório App_Code 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 fonte, o tipo do seu controle existirá no assembly compilado e no assembly gerado dinamicamente criado pelo ASP.NET.Isso criará uma referência ambígua ao carregar o controle e qualquer página na qual o controle é usado irá gerar um erro do compilador.

O conjunto que você criou nessa explicação passo a passo é referenciado como 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

  • Edite o arquivo Web.config para adicionar um atributo assembly a um elemento tagPrefixadd:

    <controls>
  <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.CS" assembly="Samples.AspNet.Controls.CS" />
</controls>

    <controls>
  <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.VB" assembly="Samples.AspNet.Controls.VB" />
</controls>

The assembly atributo especifica que o nome do assembly do controle é no. An addtagPrefix element maps a tag prefix to a namespace and assembly combination.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 SimpleDataBoundColumnTest.aspx no seu navegador inserindo o URL a seguir na barra de endereços:

    https://localhost/ServerControlsTest/SimpleDataBoundColumnTest.aspx

Se você usar o controle em um designer visual, como Visual Studio 2005,você poderá adicionar o controle à caixa de ferramentas, arraste-o da caixa de ferramentas para o superfície de design e acesse propriedades e eventos no navegador de propriedades.Além disso, no Visual Studio 2005, o controle possui suporte completo IntelliSense em Modo de exibição Source do criador da página e no editor de códigos.Isso inclui conclusão de instrução em um bloco script, bem como suporte ao navegador de propriedade quando um desenvolvedor de página clicar na 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

Este controle de servidor associado a dados simples, personalizado ilustra as etapas fundamentais usadas para criar um controle personalizado que fornece a um desenvolvedor de página uma maneira padrão, eficiente e flexível de acoplá-lo a uma fonte de dados externos.A partir daqui, você pode começar a explorar a estrutura fornecida no Visual Studio para ajudá-lo a criar os controles de servidor sofisticados, personalizados.Sugestões para explorar mais o assunto incluem o seguinte:

Consulte também

Tarefas

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

Conceitos

Desenvolvendo Controles Personalizados de Servidores Web Vinculados a Dados para ASP.NET 2.0

Visão geral de controle servidor Web com dados vinculados

Atributos Metadata para Controles de Servidor Personalizados

Visão Geral sobre os Designers de Controle do ASP.NET

Referência

HierarchicalDataBoundControlDesigner

Outros recursos

Desenvolvendo Controles Personalizados ASP.NET Server