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

Artigo
10/15/2014

Essa explicação passo a passo mostra como criar um controle de servidor de dados-vinculados simples que expõe um fonte de dados unida.

Controles de servidores Web ASP.NET vinculados a dados proveem uma interface de usuário (IU) para uma fonte de dados representando uma coleção de registros ou itens.Os controles de servidor DataList e Repeater e são exemplos de controles de servidor Web vinculados a dados.Para mais informações sobre controles vinculados a dados inclusos em ASP.NET, veja Visão geral de controle servidor Web com dados vinculados.

Observação:
O controle ilustrado nessa explicação passo a passo é compatível com o ASP.NET versão 1.1.Para obter mais informações sobre a criação de controles personalizados ligados a dados da Web para ASP.NET 2.0, consulte Desenvolvendo Controles Personalizados de Servidores Web Vinculados a Dados para ASP.NET 2.0.

Um controle de servidor vinculado à dados do ASP.NET 1.1 pode se associar a qualquer um dos seguintes tipos:

IEnumerable (como um Array, um ArrayList ou um objeto Hashtable).
IListSource (como um objeto DataSet).

Essa 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:

Criação do site da Web para testar o controle personalizado associado a dados.
Criação de uma de controle associado a dados.A classe deve expor uma propriedade do tipo IListSource ou IEnumerable, permitindo ao desenvolvedor de página especificar o local dos dados que devem ser vinculados.Ele deve também substituir a classe base dos métodos DataBind e CreateChildControls.
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 os código localizado na pasta App_Code na raiz do site.Classes em arquivos de origem em App_Code, portanto, podem ser acessadas a partir de páginas sem serem compilado manualmente em conjuntos de módulos (assemblies).

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 s versões anteriores, conforme descrito na 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.

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.
Crie um diretório App_Code diretamente sob a diretório raiz de seu Web site.

Criando a classe SimpleDataBoundControl

A próxima etapa é para criar a classe de controle.

Para criar a classe SimpleDataBoundControl

Na pasta App_Code criada no procedimento anterior, crie uma classe denominada SimpleDataBoundControl.cs ou SimpleDataBoundControl.vb, dependendo de qual linguagem de programação você deseja usar.

Adicione o seguinte código para o seu arquivo de classe.

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

Namespace Samples.ASPNet.VB.Controls
    <DefaultProperty("DataSource")> _
        Public Class SimpleDataBoundControl
        Inherits WebControl

        Private _dataSource As IEnumerable
        Private _label As Label
        Private _button As Button
        Private _table As Table

        <Category("Data"), DefaultValue(""), Description("An exposed data source: A public member of type IEnumerable to bind to such as an Array, ArrayList or Hashtable.")> _
        Public Overridable Property DataSource() As IEnumerable
            Get
                Return _dataSource
            End Get
            Set(ByVal value As IEnumerable)
                If TypeOf value Is IEnumerable OrElse value Is Nothing Then
                    _dataSource = value
                Else
                    Throw New ArgumentException()
                End If
            End Set
        End Property

        Protected Overridable Function GetDataSource() As IEnumerable
            If _dataSource Is Nothing Then
                Return Nothing
            End If

            Dim resolvedDataSource As IEnumerable
            resolvedDataSource = _dataSource

            Return resolvedDataSource

        End Function 'GetDataSource

        Protected Overridable Sub CreateMyControlHeirarchy(ByVal useViewState As Boolean)
            Dim resolvedDataSource As IEnumerable = Nothing
            If useViewState Then
                If Not (ViewState("RowCount") Is Nothing) Then
                    resolvedDataSource = New Object(Fix(ViewState("RowCount"))) {}
                Else
                    Throw New Exception("Unable to retrieve expected data from ViewState")
                End If
            Else
                resolvedDataSource = GetDataSource()
            End If

            If Not (resolvedDataSource Is Nothing) Then
                ' Create a label that will indicate form which source the data has been provided.
                Dim s As String
                If useViewState Then
                    s = "Data collection retrieved from ViewState:"
                Else
                    s = "Data collection retrieved from bound data source:"
                End If
                _label = New Label()
                Me.Controls.Add(Me._label)
                _label.Text = s

                _button = New Button()
                Me.Controls.Add(Me._button)
                _button.Text = "Test re-binding of ViewState"

                _table = New Table()
                Me.Controls.Add(Me._table)

                Dim dataItem As Object
                For Each dataItem In resolvedDataSource
                    Dim row As New TableRow()
                    _table.Rows.Add(row)
                    Dim cell As New TableCell()
                    If Not useViewState Then
                        cell.Text = dataItem.ToString()
                    End If
                    row.Cells.Add(cell)
                Next dataItem

                ViewState("RowCount") = _table.Rows.Count
            End If

        End Sub 'CreateMyControlHeirarchy

        Protected Overrides Sub CreateChildControls()
            Controls.Clear()

            If Not (ViewState("RowCount") Is Nothing) Then
                Dim useViewState As Boolean = True
                CreateMyControlHeirarchy(useViewState)
            End If

        End Sub 'CreateChildControls

        Public Overrides Sub DataBind()
            MyBase.OnDataBinding(EventArgs.Empty)

            Controls.Clear()
            ClearChildViewState()
            TrackViewState()

            Dim useViewState As Boolean = False
            CreateMyControlHeirarchy(useViewState)

            ChildControlsCreated = True
        End Sub 'DataBind

        Protected Overrides Sub RenderContents(ByVal writer As HtmlTextWriter)
            Me._label.RenderControl(writer)
            Me._table.RenderControl(writer)
            Me._button.RenderControl(writer)
        End Sub 'RenderContents
    End Class 'SimpleDataBoundControl
End Namespace

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

namespace Samples.AspNet.CS.Controls
{
    [
        DefaultProperty("DataSource")
    ]
    public class SimpleDataBoundControl : WebControl
    {
        private IEnumerable _dataSource;
        private Label _label;
        private Button _button;
        private Table _table;

        [
        Category("Data"),
        DefaultValue(""),
        Description("An exposed data source: A public member of type IEnumerable to bind to such as an Array, ArrayList or Hashtable.")
        ]
        public virtual IEnumerable DataSource
        {
            get
            {
                return _dataSource;
            }
            set
            {
                if ((value is IEnumerable) || (value == null))
                {
                    _dataSource = value;
                }
                else
                {
                    throw new ArgumentException();
                }
            }
        }

        protected virtual IEnumerable GetDataSource()
        {
            if (_dataSource == null)
            {
                return null;
            }

            IEnumerable resolvedDataSource;
            resolvedDataSource = _dataSource as IEnumerable;

            return resolvedDataSource;
        }

        protected virtual void CreateMyControlHeirarchy(bool useViewState)
        {
            IEnumerable resolvedDataSource = null;
            if (useViewState)
            {
                if (ViewState["RowCount"] != null)
                {
                    resolvedDataSource = new object[(int)ViewState["RowCount"]];
                }
                else
                {
                    throw new Exception("Unable to retrieve expected data from ViewState");
                }
            }
            else
            {
                resolvedDataSource = GetDataSource();
            }

            if (resolvedDataSource != null)
            {
                // Create a label that will indicate form which source the data has been provided.
                String s;
                if (useViewState)
                {
                    s = "Data collection retrieved from ViewState:";
                }
                else
                {
                    s = "Data collection retrieved from bound data source:";
                }
                _label = new Label();
                this.Controls.Add(this._label);
                _label.Text = s;

                _button = new Button();
                this.Controls.Add(this._button);
                _button.Text = "Test re-binding of ViewState";

                _table = new Table();
                this.Controls.Add(this._table);

                foreach (object dataItem in resolvedDataSource)
                {
                    TableRow row = new TableRow();
                    _table.Rows.Add(row);
                    TableCell cell = new TableCell();
                    if (!useViewState)
                    {
                        cell.Text = dataItem.ToString();
                    }
                    row.Cells.Add(cell);
                }

                ViewState["RowCount"] = _table.Rows.Count;
            }
        }

        protected override void CreateChildControls()
        {
            Controls.Clear();

            if (ViewState["RowCount"] != null)
            {
                bool useViewState = true;
                CreateMyControlHeirarchy(useViewState);
            }
        }

        public override void DataBind()
        {
            base.OnDataBinding(EventArgs.Empty);

            Controls.Clear();

            ClearChildViewState();

            TrackViewState();

            bool useViewState = false;
            CreateMyControlHeirarchy(useViewState);

            ChildControlsCreated = true;
        }

        protected override void RenderContents(HtmlTextWriter writer)
        {
            this._label.RenderControl(writer);
            this._table.RenderControl(writer);
            this._button.RenderControl(writer);
        }
    }
}

Discussão de Código

A classe SimpleDataBoundControl processa uma tabela HTML com base na coleção de dados especificada na sua propriedade DataSource.O controle de servidor web associado a dados do ASP.NET 1.1 deve expor uma propriedade DataSource associável que pode ser definida tanto como IEnumerable ou como IListSource.

No código de exemplo, o assessor definido para a propriedade DataSource verifica se o valor a ser definido é null ou para um objeto do tipo IEnumerable.Portanto, nesse exemplo o desenvolvedor de página pode vincular a qualquer tipo de objeto IEnumerable, como um Array, ArrayList, ou Hashtable.O desenvolvedor pode deixar o conjunto DataSource inicialmente para o valor padrão null e definir a propriedade no código.

Os atributos metadados Category,DefaultValue e Description fornecem informações usadas por ferramentas de design, o analisador gramatical de página ASP.NET e a Common Language Runtime.

O método auxiliar CreateMyControlHeirarchy mantém a criação da hierarquia de controle filho do controle em um caminho comum de código.Ele é chamado tanto pelo método substituído DataBind quanto pelo CreateChildControls.O método substituído DataBind é necessário.Ele enumera o objeto da fonte de dados associada e cria os controles filhos.O método substituído CreateChildControls é necessário e recria a hierarquia de controles filhos com base nos dados salvos em estado de exibição.

O controle processa substituindo o método RenderContents herdado.Isso permite o controle processar dentro de suas próprias marcações.O parâmetro passado para o método RenderContents é um objeto do tipo HtmlTextWriter, que é um utilitário de classe que tem métodos para processar marcas e outra marcação HTML (e HTML-Variant).

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 1,1.

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.CS.Controls"%>

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

Observação:
The @ Register diretiva no ASP.NET 2.0 é o mesmo que no ASP.NET 1.0 e ASP.NET 1.1. Se você estiver familiarizado com a diretiva @ Register nas versões anteriores do ASP.NET, observe que o atributo assembly que especifica o nome do conjunto de controle está ausente na diretiva @ Register anterior.Quando o atributo assembly estiver faltando, o ASP.NET infere que o conjunto é compilado dinamicamente dos arquivos de origem no diretório App_Code.

The @ Register diretiva no ASP.NET 2.0 é o mesmo que no ASP.NET 1.0 e ASP.NET 1.1. Se você estiver familiarizado com a diretiva @ Register nas versões anteriores do ASP.NET, observe que o atributo assembly que especifica o nome do conjunto de controle está ausente na diretiva @ Register anterior.Quando o atributo assembly estiver faltando, o ASP.NET infere que o conjunto é compilado dinamicamente dos arquivos de origem no diretório App_Code.

Como alternativa para o uso da diretiva @ Register em cada página .aspx, o desenvolvedor de página pode especificar o mapeamento do prefixo e o espaço de nomes, no arquivo web.config.Isso é útil se o controle personalizado será usado em várias páginas em um aplicativo da Web.

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 do prefixo de marca foi especificado na diretiva @ Register em cada página que usou o controle personalizado.

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

Se o seu site da Web ainda não tiver um, crie um arquivo denominado Web.config na pasta raiz da página Web.
Se você criou um novo arquivo web.config (vazio), 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 do elemento <controls>, que deve estar na seção <pages> em <system.web>.
```
<?xml version="1.0"?>
<configuration>
  <system.web>    
   <pages>
     <controls>
       <add tagPrefix="aspSample"            namespace="Samples.AspNet.CS.Controls">       </add>
     </controls>
   </pages>
  </system.web>
</configuration>
```
```
<?xml version="1.0"?>
<configuration>
  <system.web>    
   <pages>
     <controls>
       <add tagPrefix="aspSample"            namespace="Samples.AspNet.VB.Controls">       </add>
     </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.CS.Controls ou Samples.AspNet.VB.Controls.

Observação:
A entrada de prefixo de marca deve ser um filho do elemento <controls>, que deve estar na seção <pages> em <system.web>.

After you have specified the tag prefix mapping in the configuration file, you can use the SimpleDataBoundControl control declaratively as <aspSample:SimpleDataBoundControl /> in any page in the Web site.

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 permite a você testar o controle personalizado associado a dados.

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

Crie um arquivo chamado TestSimpleDataBoundControl.aspx no seu site da Web.

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

<%@ Page Language="VB" %>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.VB.Controls" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script >
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
        If Not IsPostBack Then
            Dim a As New ArrayList()
            a.Add("One")
            a.Add("Two")
            a.Add("Three")
            a.Add("Four")

            simpleDataBoundControl1.DataSource = a
            simpleDataBoundControl1.DataBind()
        End If
    End Sub 'Page_Load
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" >
    <title>SimpleDataBoundControl test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundControl  id="simpleDataBoundControl1" BorderStyle="Solid" ></aspSample:SimpleDataBoundControl>
    </div>
    </form>
</body>
</html>

<%@ Page Language="C#" Trace="true" EnableViewState="true" %>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.CS.Controls" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script >
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            ArrayList a = new ArrayList();
            a.Add("One");
            a.Add("Two");
            a.Add("Three");
            a.Add("Four");

            simpleDataBoundControl1.DataSource = a;
            simpleDataBoundControl1.DataBind();
        }
    }
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head >
    <title>SimpleDataBoundControl test page</title>
</head>
<body>
    <form id="form1" >
    <div>
        <aspSample:SimpleDataBoundControl  id="simpleDataBoundControl1" BorderStyle="Solid" ></aspSample:SimpleDataBoundControl>
    </div>
    </form>
</body>
</html>

Execute a página TestSimpleDataBoundControl.aspx.
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.")
```
Atualize a página TestSimpleDataBoundControl.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)

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)

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.

Execute o seguinte comando a partir do diretório App_Code que contém os arquivos de origem que você criou anteriormente nessa explicação passo a passo.

Isso irá gerar um conjunto de módulos (assembly) denominado Samples.AspNet.CS.Controls.dll ou Samples.AspNet.VB.Controls.dll na pasta App_Code.

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

vbc /t:library /out:Samples.AspNet.VB.Controls.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.

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, incluir o atributo System.Web.UI.TagPrefixAttribute de nível de montagem, que sugere um prefixo de marca padrão que um designer visual deve usar para o seu controle.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.

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

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.CS.Controls", "aspSample")]
```
```
Imports System
Imports System.Web.UI
<Assembly: TagPrefix("Samples.AspNet.VB.Controls", "aspSample")> 
```
O atributo de prefixo de marca cria um mapeamento entre o namespace Samples.AspNet.CS.Controls ou Samples.AspNet.VB.Controls e o prefixo aspSample.
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 controle do conjunto de módulos (assembly) disponível para páginas no site da Web.

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

Se seu site ainda não possuir um, crie um diretório Bin sob a raiz da página Web.
Arraste (mover) o controle de conjunto de módulos (assembly) (Samples.AspNet.CS.Controls.dll ou Samples.AspNet.VB.Controls.dll) a partir do diretório App_Code para o diretório Bin.
Mova o arquivo de origem do controle da pasta App_Code para outra pasta no seu site.

Se você não mova os arquivos de fonte fora do diretório App_Code, 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 é um conjunto de módulos particular porque ele deve ser colocado no diretório Bin de um site ASP.NET da Web para habilitar páginas no site da Web para usar o 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 no arquivo web.config para especificar o nome do controle de conjunto de módulos (assembly).

Para modificar o mapeamento de prefixo de marca no arquivo web.config

Edit the Web.config file to add an assembly attribute to the an <add tagPrefix=name> element:

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

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

The assembly atributo especifica o nome do assembly que o controle está no. An <add tagPrefix=name> element maps a tag prefix to a namespace/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 do conjunto de módulos gerado dinamicamente no diretório App_Code.

Agora você pode testar o controle exibindo-o em uma página.

Para exibir a página que usa a controle personalizado

Exiba a página TestSimpleDataBoundControl.aspx no seu navegador inserindo o URL a seguir na barra de endereços:
```
https://localhost/ServerControlsTest/TestSimpleDataBoundControl.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.

Próximas etapas

Este simples controle personalizado de servidor associado a dados ilustra as etapas fundamentais usadas para criar um controle personalizado que fornece ao desenvolvedor uma maneira padrão de acoplá-lo a uma fonte de dados externa.A partir desse início, você pode começar a explorar como Visual Studio o ajuda a criar sofisticados controles personalizados de servidor.Sugestões para mais exemplos incluem:

Revise a introdução para a arquitetura geral de desenvolvimento de um controle personalizado de servidor associado a dados.Para obter detalhes, consulte:Desenvolvendo Controles Personalizados de Servidores Web Vinculados a Dados para ASP.NET 1,1.
Investigar as classes existentes de controles de servidores associado a dados que você pode estender e personalizar.Para obter uma visão geral dos controles de servidores Web associado a dados, consulte Visão geral de controle servidor Web com dados vinculados.Para obter informações sobre classes de controle de servidor Web com dados vinculados, consulte os seguintes tópicos de referência: GridView, DetailsView, FormView, Repeater, e DataList.
Aprenda mais sobre o processamento, definição de propriedades, mantimento de estado e implementação controles de compostos personalizados.Para obter detalhes, consulte Desenvolvendo Controles Personalizados ASP.NET Server, Exemplo de Estado de Controle versus Estado de Exibição, Gerenciamento de Estado Personalizado de Controle de Servidor.
Aprenda sobre os atributos de metadados que você pode aplicar para o ser controle personalizado de servidor associado a dados e a seus membros para fornecer informações que são usadas pelas ferramentas de design.Para obter detalhes, consulte:Atributos Metadata para Controles de Servidor Personalizados.
Crie um controle de designer para adicionar recursos em tempo de design, modelos ou estilos.Para obter um exemplo de um designer personalizado de controle associado a dados, consulte HierarchicalDataBoundControlDesigner e Demonstra Passo a passo: Criando um criador controle básico para um controle de servidor Web.Para obter uma visão geral de designers de controle do ASP.NET, consulte Visão Geral sobre os Designers de Controle do ASP.NET.
Trabalhe com um exemplo de um designer personalizado de controle associado a dados.Para obter detalhes, consulte o tópico HierarchicalDataBoundControlDesigner.
Explore uma demonstração de definição apropriada de atributos em tempo de design para disponibilizar um controle de servidor personalizado na Caixa de Ferramentas do Visual Studio.Para obter detalhes, consulte:Como: Usar controles de servidor ASP.NET personalizado no Visual Studio.

Consulte também

Partilhar via

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

Criando um site da Web para testar o controle

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

Criando a classe SimpleDataBoundControl

Para criar a classe SimpleDataBoundControl

Discussão de Código

Criando um prefixo de marca

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

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

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

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

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

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

Para adicionar um mapeamento de prefixo de marca utilizando um TagPrefixAttribute

Usando o controle compilado personalizado do servior de dados-vinculados em uma página ASP.NET

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

Para modificar o mapeamento de prefixo de marca no arquivo web.config

Para exibir a página que usa a controle personalizado

Próximas etapas

Consulte também

Tarefas

Conceitos

Referência

Outros recursos

Recursos adicionais