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

Artigo
10/15/2014

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 Visão Geral sobre o Controle do Servidor Web GridView, Visão geral do controle DataList do servidor Web, e Visão geral controle de servidor da Web Repeater 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.

Na versão ASP.NET 2.0, um novo modelo de fonte de dados permite que você acople controles vinculados 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 vinculado a dados em si.Esse modelo possibilita uma maior flexibilidade do controle vinculado a dados para desenvolvedores de páginas e aumenta o nível de reúso.

Esse tópico introduz os passos básicos requeridos para implementar um controle personalizado de servidor ASP.NET 2.0 vinculado a dados.Para mais informações sobre a arquitetura geral e implementações de controles personalizados., veja Desenvolvendo Controles Personalizados ASP.NET Server e Explicação Passo a Passo: Desenvolvendo e Usando um Controle de Servidor Personalizado.Para mais informações sobre desenvolvimento controles compatíveis ASP.NET 1.1 vinculados a dados, veja Desenvolvendo Controles Personalizados de Servidores Web Vinculados a Dados para ASP.NET 1,1 e Demonstra Passo a passo: Criando um controle de Web do ASP.NET personalizados ligados a dados para ASP.NET 1,1.Para mais informações sobre controles da fonte de dados, consulte Visão geral sobre controles fonte de dados.

Quando Criar um Controle Personalizado Vinculado a Dados

Antes de criando seu próprio controle limite a dados personalizado, consulte os recursos dos controles ligados a dados já fornecidos com o ASP.NET.Controles existentes podem atender às suas necessidades, ou você pode optar por criar um controle personalizado que estende um controle existente que já fornece muitos dos recursos que necessários.Para mais informações sobre controles vinculados a dados inclusos em ASP.NET, veja Visão geral de controle servidor Web com dados vinculados.

Aqui estão algumas razões pelas quais você pode decidir criar um controle personalizado vinculado a dados:

Suas necessidades particulares requerem uma IU personalizada, recursos personalizados de ordenação de dados, ou recursos personalizados de edição de dados que não estão disponíveis nos controles existentes vinculados a dados.
Você quer criar um controle personalizado vinculado a dados, que seja pré-compilado e possível de redistribuir.
Você quer extender recursos de um controle vinculado a dados já existente em ASP.NET.
Você quer criar um controle vinculado a dados com um designer personalizado que preenche suas necessidades específicas.

Funcionalidades Básicas do Controle Personalizado Vinculado a Dados

Derivando uma das classes base de controle vinculado a dados, como a classe DataBoundControl ou a classe CompositeDataBoundControl, seu controle personalizado vinculado a dados herda muitos recursos internos, incluindo os seguintes:

Suporte a fontes de dados para a interface IDataSource e suas classes relacionadas DataSourceView, que proveem exibições de dados nomeados, a capacidade de pesquisar os tipos de operações suportados pelo armazenamento de dados, e funcionalidade de carregamento de dados por demanda.
Suporte a fontes de dados para as interfaces genéricas IEnumerable ou IListSource.
Suporte a expressões vinculadas a dados, que habilitam os desenvolvedores de páginas a criar vínculos expostos, especialmente marcados entre propriedades do seu controle e a fonte de dados.Para obter mais informações, consulte Visão geral de expressões de ligação de dados.
Suporte a vinculação automática de dados que invocam uma lógica de vinculação de dados o mais tardar possível durante o ciclo de vida de página e apenas quando necessário, ao invés de a cada postagem.Após uma página realizar o primeiro requerimento de vinculação a dados, requereimentos subsequentes tentam obter os dados de um estado de exibição.Isso melhora a performance evitando a necessidade de reconectar-se à fonte de dados a cada requerimento.

Utilizando Recursos Disponíveis em Tempo de Criação

Há recursos disponíveis em tempos de criação para todos os controles de servidor Web que você possa querer considerar para seu controle personalizado vinculado a dados.Você pode criar uma classe desenvolvedora e modelos de controle para seu controle personalizado.Esses recursos são chamados quando seu controle é usado em tempo de design em um ambiente de design visual, como a perspectiva Design no Visual Studio.

Criar um controlador de designer pode aumentar significativamente a utilidade do seu controle personalizado em tempo de design através de uma interface de design que habilita os desenvolvedores de páginas a personalizar as propriedades de seu controle.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.Para exemplos, veja HierarchicalDataBoundControlDesigner e Demonstra Passo a passo: Criando um criador controle básico para um controle de servidor Web.

Criando um controlador de modelos, você provê aos desenvolvedores de páginas a flexibilidade de especificar os controles e as marcações que definem uma interface de usuário de controle.Para um exemplo de um controle de modelo personalizado, consulte Exemplo de Modelo de Controle de Servidor.

Implementando um Controle Personalizado Vinculado a Dados em ASP.NET 2.0

A tabela seguinte resume os passos que especificam a implementação de um controle de servidor personalizado vinculado a dados em ASP.NET 2.0.Após a tabela, você irá encontrar informações mais detalhadas sobre cada um dos passos de implementação.

Por Etapa	Resumo dos Passos
Escolha um classe base de controle vinculado a dados.	Extenda uma classe já existente de controle vinculado a dados que já provê muitos dos recursos que você precisa, ou derive uma de uma das nossas classes base de controle vinculado a dados.
Exponha as propriedades vinculadas a dados.	Configure seu controle personalizado para expor as propriedades de vínculo de dados que estão alinhadas com as propriedades mínimas requeridas para vínculo de dados expostas pelas classes base de controle vinculado a dados.
Inicie a obtenção de dados.	Obtenha os dados que o desenvolvedor da página delegou ao seu controle fazendo o seguinte: Sobrescreva o método PerformSelect da classe base de controle vinculado a dados. Chame o método GetData da classe base vinculada a dados para obter a vista do código fonte do controlador Chame o método Select do objeto DataSourceView para iniciar a obtenção de dados e especificar o método de retorno que receberá os dados.
Armazene os dados obtidos.	Provenha o método de retorno que você especificou como parâmetro no método Select.O método de retorno deve ter um parâmetro único do tipo IEnumerable para receber os dados.Se qualquer processamento de dados for requerido pelo seu controle, ele deverá ocorrer juntamente com este método de retorno
Crie os objetos IU para representação dos dados	Sobrescreva o método PerformDataBinding/Você deve executar as seguintes tarefas juntamente com este método: Chame o método PerformDataBinding para permitir que qualquer outro código pertença a este método a executar. Enumere através da coletânea de dados e crie quaisquer controles de filho que irão representar os dados na exibição IU.

Escolha uma Classe Base de Controle Vinculado a Dados

Desenvolvedores de controladores podem extender uma das classes base de controle vinculado a dados para criar um controle personalizado vinculado a dados.A seguinte tabela provê uma lista de classes base vinculadas a dados disponíveis no ASP.NET 2.0.Reveja as descrições de cada classe e então determine quais classes base melhor se encaixam nos requerimentos de seu controle personalizado vinculado a dados.Para informações mais detalhadas sobre cada classe base para controladores vinculados a dados e exemplos de implementação, veja a documentação de referência de cada classe.Para mais informações sobre controles vinculados a dados provenientes de ASP.NET, consulte Visão geral de controle servidor Web com dados vinculados.

Classe	Descrição
BaseDataBoundControl	Esta é uma classe base para todos os controles vinculados a dados, que implementa o vínculo de dados e a validação de qualquer dado vinculado.
DataBoundControl	Esta é a classe ligados a dados base para criar controles ligados a dados padrão.DataBoundControl faz o seguinte: Provê implementações básicas compartilhadas por todos os controladores vinculados a dados. Contém a lógica de comunicação com os controlados de fontes de dados e seus containeres. Serve como a base dos controladores vinculados a dados, como TreeView e ListControl.
ListControl	Esta é a classe base para listagem dos controles e extente a classe DataBoundControl.Ela provê uma coletãnea Items e capacidades avançadas de renderização de layout.
CompositeDataBoundControl	Esta é a classe base que extende a classe DataBoundControl, provendo as seguintes funcionalidades: Implementa o código típico requerido por controladores de dispositivos, incluindo o código que reestabelece o controle da hierarquia do filho do controlador de acordo com uma vista externa após o envio de uma mensagem de retorno. Vincula-se ao código de dados IEnumerable e enumera os dados para a construção de uma árvore de controle. Serve como a base dos controladores vinculados a dados, como GridView e DetailsView.
HierarchicalDataBoundControl	Esta é a classe base para controladores que exibem seus dados em um formulário de hierarquia.Ela serve como a base para controladores vinculados a dados baseados em árvores, como TreeView e Menu.

Propriedades Provenientes do Vínculo a Dados

As classes base de controle vinculado a dados já proveem as propriedades de vínculo a dados exibidas necessárias para habilitar ao desenvolvedor da página vincular uma fonte de dados ao controle.Nenhum trabalho adicional é necessário por parte do autor do controlador.Derivando de DataBoundControl, por exemplo, um controle personalizado herda três propriedades de vinculação de dados expostas: DataSourceID, DataSource, e DataMember. Um desenvolvedor de página pode então especificar a fonte dos dados para a qual o controle irá vincular configurando os valores das propriedades DataSource ou DataSourceID.

A propriedade DataSourceID habilita o desenvolvedor da página a especificar o ID do controle que representa a fonte de dados da qual o controle vinculado a dados obtém os dados.

A propriedade DataSource permite ao desenvolvedor de página anexar um controle vinculado a dados diretamente dos objetos de dados desses dois tipos:

Um objeto que implementa a interface IEnumerable, como os objetos Array, ArrayList ou Hashtable.
Um objeto que implementa a interface IListSource, como o objeto DataSet.
Propriedades adicionais de dados vinculados, como a propriedade DataMember, permitem ao desenvolvedor de página especificar a porção da coletânea de dados a qual o controlador deveria vincular.
Para mais informações sobre as propriedades expostas no vínculo a dados provenientes de cada classe de controle vinculado a dados ou classe base vinculada a dados, veja a documentação referente a cada classe.

Expondo propriedades Personalizadas de Vínculo a Dados

Quando da exposição das suas próprias propriedades personalizadas de vínculo a dados em um controlador personalizado ou em propriedades existentes sobrescritas de vínculo a dados, você deve chamar o método OnDataPropertyChanged se o controlador já foi inicializado.Isto força o controlador vinculado a dados a revincular os dados de forma que assim ele possa usar a nova configuração de propriedades de vínculo a dados.

O exemplo de código a seguir mostra uma propriedade que pertence a uma classe derivada de controle vinculado a dados.O exemplo demonstra como um controle vinculado a dados pode chamar o método OnDataPropertyChanged que identifica a mudança de um código e dados após o controle vinculado a dados ter sido inicializado.

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

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();
            }
        }
    }

Inicialize a Obtenção de Dados

Obtenção de dados é inicializada com a sobrescrita do método PerformSelect herdados pelo seu controle vinculado a dados da base de controles.Com esta sobrescrita você pode obter os dados e especificar um método de retorno que irá manipular os dados assim que retornar.

Para obter dados, complete as seguintes tarefas no método sobrescrito PerformSelect:

Determine se o desenvolvedar da página usou a propriedade DataSource ou a propriedade DataSourceID para configurar os dados para serem vinculados ao controle.Isto é feito verificando a propriedade IsBoundUsingDataSourceID.Por exemplo, a configuração false para a propriedade IsBoundUsingDataSourceID indica que a propriedade DataSource foi usada para especificar a fonte de dados.
Se o desenvolvedor da página definido o DataSource propriedade e, em seguida, uma etapa extra é necessário: Chame o método OnDataBinding.
Chame o método GetData para obter o objeto DataSourceView associado a controle vinculado a dados.
Chame o método Select do obtido DataSourceView para iniciar a obtenção de dados e especifique o método de retorno que irá manipular os dados obtidos.O método Select opera de maneira assíncrona, então outro processamento é permitido enquando os dados estão sendo obtidos.
Indique o término da tarefa PerformSelect configurando a propriedade RequiresDataBinding para false e então chame o método MarkAsDataBound.
Crie o evento OnDataBound.

O exemplo de código a seguir ilustra as tarefas que precedem a obtenção de dados quando completadas juntamente o a sobrescrita do método PerformSelect.

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

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);
}

Manipule os Dados Obtidos

Crie seu próprio método de retorno para aceitar os dados obtidos.Este é o método de retorno que você especificou quando o método Select foi chamado juntamente com a sobrescrita do método PerformSelect.O método de retorno é exigido para conter um único parâmetro do tipo IEnumerable.No seu método de retorno você poderá realizar qualquer processamento dos dados retornados, se requerido pelo seu controle.Como último passo, chame o método PerformDataBinding.

O exemplo de código a seguir ilustra um método de retorno que tem um parâmetro do tipo IEnumerable e chama o método PerformDataBinding.

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

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);
}

Crie os Objetos UI Representandos os Dados

Juntamente com a sobrescrita do método PerformDataBinding, você cria os controles filho que irão representar os dados.A coletânea de dados é enumerada, e os controles de filho são criados e suas propriedades configuradas baseando-se em cada item de dado.Adicionando os controles da nova criança à coletânea de controles Controls, os controles da criança serão renderizados para você.A hierarquia de controle renderiza os controles herdados do método Render.Você poderá escolher sobrescrever os métodos Render para realizar uma renderização requerida pelo seu controlador personalizado, como a inclusão de elementos HTML adicionais ou renderização especial para exibição durante o modo design.

Para criar objetos representando dados, sobrescreva o método PerformDataBinding e complete as seguintes tarefas:

Chame o método PerformDataBinding para permitir que qualquer outro código pertença a este método a executar.
Enumere através da coletânea de dados e crie quaisquer controles de filho que irão representar os dados na exibição IU.Adicione cada controle de criança à coletânea de controle chamando o método de controle Add.

O exemplo de código a seguir ilustrar a sobrescrita do método PerformDataBinding.O método PerformDataBinding é chamado para permitir qualquer outro código pertencente ao método a ser executado.A coletânea de dados é enumerada e cada controle de criança criado para representar os dados na exibição IU.

        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

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); 
    }
}

Contruindo Seu Próprio Controle de Servidor

Para informações sobre contrução do seu controle personalizado de servidor Web vinculado a dados e uso na página Web, veja Construindo os Exemplos de Controle de Servidor Personalizado.

Consulte também

Compartilhar via