Visão Geral sobre o Controle do Servidor Web ListView

  • Artigo

O controle ListView do ASP.NET permite que você vincule a itens de dados que são retornados de uma fonte de dados e exiba-os.Você pode exibir dados em páginas.Você pode exibir itens individualmente, ou você pode agrupá-los.

O controle ListView exibe dados em um formato que você define usando modelos e estilos.Ele é útil para dados em qualquer estrutura repetitiva, similar aos controles DataList e Repeater.No entanto, diferentemente desses controles, com o controle ListView você pode permitir que os usuários editem, insiram e excluam dados, e classifiquem e paginem dados, tudo sem código.

Esse tópico contém:

  • Vinculando dados ao controle ListView

  • Criando modelos para o controle ListView

  • Dados de paginação

  • Classificando Dados

  • Modificando Dados

  • Aplicando estilos a itens de ListView

  • Referência de Classe

  • Exemplos de código

  • Recursos adicionais

Vinculando dados ao controle ListView

Você pode vincular o controle ListView a dados das seguintes maneiras:

  • Usando a propriedade DataSourceID.Isso permite que você vincule o controle ListView a um controle da fonte de dados, como o controle SqlDataSource.Recomendamos essa abordagem, pois permite que o controle ListView aproveite os recursos do controle da fonte de dados.Ele também fornece funcionalidade interna para classificar, paginar, inserir, excluir e atualizar.Essa abordagem também permite que você utilize expressões de ligação bidirecional.Para mais informações sobre controles da fonte de dados, consulte Visão geral sobre controles fonte de dados.

  • Usando a propriedade DataSource.Isso permite que você vincule a vários objetos, o que inclui datasets ADO.NET e leitores de dados e estruturas de memória, como coleções.Essa abordagem requer que você escreva código para quaisquer funcionalidades adicionais como classificação, paginação e atualização.

Voltar ao topo

Criando modelos para o controle ListView

Itens que são exibidos por um controle ListView são definidos pelos modelos, da mesma forma que os controles DataList e Repeater.O controle ListView permite que você exiba dados como itens individuais ou em grupos.

Você define o layout principal (raiz) de um controle ListView criando um modelo LayoutTemplate.O LayoutTemplate deve incluir um controle que atua como um espaço reservado para os dados.Por exemplo, o modelo de layout pode incluir um controle ASP.NET Table, Panel, ou Label.(Ele também pode incluir elementos HTML table, div, ou span que tenham um atributo runat que esteja definido como "servidor"). Esses controles irão conter a saída para cada item como definido pelo modelo ItemTemplate, que podem ser agrupados no conteúdo definido pelo modelo GroupTemplate.

Você define o conteúdo para itens individuais no modeelo ItemTemplate.Este modelo geralmente contém controles que são colunas de dados ligadas a dados ou outros elementos de dados individuais.

Agrupando itens

Opcionalmente, você pode agrupar itens em um controle ListView usando o modelo GroupTemplate.Normalmente você agrupa itens para criar um layout de tabela lado a lado.Em um layout de tabela lado a lado, os itens são repetidos em uma linha o número de vezes especificado na propriedade GroupItemCount.Para poder criar um layout de tabela lado a lado, o modelo de layout pode conter um controle ASP.NET Table ou um elemento HTML table que tenha um atributo runat definido como "servidor".O modelo de grupo, em seguida, pode conter um controle ASP.NET TableRow (ou um elemento HTML tr).O modelo de item pode conter controles individuais que estejam dentro de um controle ASP.NET TableCell (ou um elemento HTML td).

Você pode usar o modelo EditItemTemplate para fornecer interface do usuário ligada a dados que permite aos usuários modificar itens de dados existentes.Você pode usar o modelo InsertItemTemplate para definir interface de usuário ligada a dados que permite aos usuários adicionar um novo item de dados .Para obter mais informações, consulte Modificando dados posteriormente neste tópico.

Modelos disponíveis

A tabela a seguir lista todos os modelos que são usados com o controle ListView.

  • LayoutTemplate
    Identifica o modelo da raiz que define o layout principal do controle.Ele contém um objeto de espaço reservado, como uma linha de tabela (tr), div, ou um elemento span.Este elemento será substituído pelo conteúdo que é definido no modelo ItemTemplate ou no modelo GroupTemplate.Ele também pode conter um objeto DataPager.

  • ItemTemplate
    Identifica o conteúdo ligado a dados a exibir para itens únicos.

  • ItemSeparatorTemplate
    Identifica o conteúdo a processar entre itens únicos.

  • GroupTemplate
    Identifica o conteúdo para o layout de grupo.Ele contém um objeto de espaço reservado, como uma célula de tabela (td), div, ou span que será substituído pelo conteúdo definido em outros modelos, como os modleos ItemTemplate e EmptyItemTemplate.

  • GroupSeparatorTemplate
    Identifica o conteúdo para processar entre grupos de itens.

  • EmptyItemTemplate
    Identifica o conteúdo a processar para um item vazio quando um modelo GroupTemplate é usado.Por exemplo, se a propriedade GroupItemCount é definida como 5, e o número total de itens retornados a partir da fonte de dados é 8, a última linha de dados exibida pelo controle ListView conterá três itens conforme especificado pelo modelo ItemTemplate, e dois itens conforme especificado pelo modelo EmptyItemTemplate.

  • EmptyDataTemplate
    Identifica o conteúdo a processar se a fonte de dados não retornar nenhum dado.

  • SelectedItemTemplate
    Identifica o conteúdo a processar para o item de dados selecionado a fim de diferenciar o item selecionado dos outros itens exibidos.

  • AlternatingItemTemplate
    Identifica o conteúdo a processar para itens alternados a fim de facilitar a distinção entre itens consecutivos.

  • EditItemTemplate
    Identifica o conteúdo a processar quando um item está sendo editado.O modelo EditItemTemplate é processado no lugar do modelo ItemTemplate para o item de dados que está sendo editado.

  • InsertItemTemplate
    Identifica o conteúdo a processar quando um item está sendo inserido.O modelo InsertItemTemplate é processado no lugar de um modelo ItemTemplate tanto no início dos itens exibidos pelo controle de ListView, quanto no final.Você pode especificar onde o modelo InsertItemTemplate é processado utilizando a propriedade InsertItemPosition do controle ListView.

Criando um modelo de item

O exemplo a seguir mostra a estrutura básica de um modelo de item.

<asp:ListView  ID="ListView1" 
    DataSourceID="SqlDataSource1">
  <LayoutTemplate>
    <table  id="table1"  >
      <tr  id="itemPlaceholder" ></tr>
    </table>
  </LayoutTemplate>
  <ItemTemplate>
    <tr runat="server>
      <td >
        <%-- Data-bound content. --%>
        <asp:Label ID="NameLabel"  
          Text='<%#Eval("Name") %>' />
      </td>
    </tr>
  </ItemTemplate>
</asp:ListView>

Para exibir itens individualmente, você adiciona um controle de lado de servidor para o modelo LayoutTemplate e define a propriedade ID do controle para itemPlaceholder.Esse controle é apenas um espaço reservado para os outros modelos, normalmente o modelo ItemTemplate.Como resultado, em tempo de execução, esse controle será substituído pelo conteúdo de outros modelos.

Observação:

Você pode alterar o valor da propriedade ID que é usada para identificar o contêiner do item, definindo a propriedade ItemPlaceholderID para um novo valor.

Após você definir o modelo de layout, você adiciona um modelo ItemTemplate que geralmente contém controles para exibir conteúdo ligado a dados.Você pode especificar a marcação a usar para exibir cada item utilizando o método Eval para vincular os controles a valores a partir da fonte de dados.Para mais informações sobre o método Eval, consulte Visão geral de expressões de ligação de dados.

Você pode fornecer conteúdo adicional a processar usando o modelo ItemSeparatorTemplate, que identifica o conteúdo a incluir entre itens.

A ilustração a seguir mostra um layout que exibe dados da fonte de dados usando várias linhas de tabela por item.

O exemplo a seguir mostra como criar o layout.

<asp:ListView  ID="EmployeesListView" 
    DataSourceID="EmployeesDataSource" 
    DataKeyNames="EmployeeID">
  <LayoutTemplate>
    <table cellpadding="2"  id="tblEmployees" 
        style="width:460px">
      <tr  id="itemPlaceholder">
      </tr>
    </table>
    <asp:DataPager  ID="DataPager" PageSize="3">
      <Fields>
        <asp:NumericPagerField
          ButtonCount="5"
          PreviousPageText="<--"
          NextPageText="-->" />
      </Fields>
    </asp:DataPager>
  </LayoutTemplate>
  <ItemTemplate>
     <tr >
       <td valign="top" colspan="2" align="center" 
           class="EmployeeName">
         <asp:Label ID="FirstNameLabel"  
           Text='<%#Eval("FirstName") %>' />
         <asp:Label ID="LastNameLabel"  
           Text='<%#Eval("LastName") %>' />
       </td>
     </tr>
     <tr style="height:72px" >
       <td valign="top" class="EmployeeInfo">
         <asp:Label ID="JobTitleLabel"  
             Text='<%#Eval("JobTitle") %>' />
         <br />
         <asp:HyperLink ID="EmailAddressLink"  
             Text='<%#Eval("EmailAddress") %>'  
             href='<%#"mailto:" + Eval("EmailAddress") %>' />
         <br />
         <asp:Label ID="PhoneLabel"  
             Text='<%#Eval("Phone") %>' />
       </td>
       <td valign="top" class="EmployeeAddress">
         <asp:Label ID="AddressLine1Label"  
             Text='<%#Eval("AddressLine1") %>' />
         <br />
         <asp:Panel ID="AddressLine2Panel"  
            Visible='<%#Eval("AddressLine2").ToString() != String.Empty %>'>
         <asp:Label ID="AddressLine2Label"  
            Text='<%#Eval("AddressLine2").ToString()%>'  />
         <br />
         </asp:Panel>
         <asp:Label ID="CityLabel"  
           Text='<%#Eval("City") %>' />,
         <asp:Label ID="StateProvinceNameLabel"  
           Text='<%#Eval("StateProvinceName") %>' />
         <asp:Label ID="PostalCodeLabel"  
           Text='<%#Eval("PostalCode") %>' />
         <br />
         <asp:Label ID="CountryRegionNameLabel"  
           Text='<%#Eval("CountryRegionName") %>' />
       </td>
     </tr>
   </ItemTemplate>
</asp:ListView>

Criando um modelo de grupo

O exemplo a seguir mostra como criar um modelo de grupo.

<asp:ListView  ID="ListView1" 
    DataSourceID="SqlDataSource1" 
    GroupItemCount="5">
  <LayoutTemplate>
    <table  id="table1">
      <tr  id="groupPlaceholder">
      </tr>
    </table>
  </LayoutTemplate>
  <GroupTemplate>
    <tr  id="tableRow">
      <td  id="itemPlaceholder" />
    </tr>
  </GroupTemplate>
  <ItemTemplate>
    <td >
      <%-- Data-bound content. --%>
      <asp:Label ID="NameLabel"  
          Text='<%#Eval("Name") %>' />
    </td>
  </ItemTemplate>
</asp:ListView>

Para exibir itens em grupos, você usa um controle de servidor no modelo LayoutTemplate para atuar como o espaço reservado para o grupo.Por exemplo, você pode usar um controle TableRow.Você define o espaço reservado para a propriedade ID do controle como groupPlaceholder.Em tempo de execução, esse controle do espaço reservado será substituído pelo conteúdo do modelo GroupTemplate.

Em seguida, você adiciona um controle de espaço reservado e define sua propriedade ID como itemPlaceholder.Esse controle é apenas um espaço reservado para os outros modelos, normalmente o modelo ItemTemplate.Como resultado, em tempo de execução, esse controle será substituído pelo conteúdo de outros modelos.O conteúdo é repetido o número de itens especificado pela propriedade GroupItemCount do controle ListView.

Finalmente, você adiciona um modelo ItemTemplate ao conteúdo ligado a dados para exibir dentro do controle que o contém para cada item.

Observação:

Você pode alterar o valor da propriedade ID que é usada para identificar o espaço reservado do grupo, definindo um novo valor para a propriedade GroupPlaceholderID.

Você pode especificar um separador entre os itens usando o modelo ItemSeparatorTemplate.Você pode especificar um separador entre grupos usando a propriedade GroupSeparatorTemplate.

A ilustração a seguir mostra um layout que exibe vários itens a partir da fonte de dados por linha.

O exemplo a seguir mostra como criar o layout.

<asp:ListView  ID="ProductsListView"
    GroupItemCount="3"
    DataSourceID="ProductsSqlDataSource" DataKeyNames="ProductID">
  <LayoutTemplate>
    <table cellpadding="2" 
           id="tblProducts" style="height:320px">
      <tr  id="groupPlaceholder">
      </tr>
    </table>
    <asp:DataPager  ID="DataPager"
                   PageSize="9">
       <Fields>
         <asp:NumericPagerField ButtonCount="3"
              PreviousPageText="<--"
              NextPageText="-->" />
       </Fields>
    </asp:DataPager>
  </LayoutTemplate>
  <GroupTemplate>
    <tr  id="productRow"
        style="height:80px">
      <td  id="itemPlaceholder">
      </td>
    </tr>
  </GroupTemplate>
  <ItemTemplate>
    <td valign="top" align="center" style="width:100" >
      <asp:Image ID="ProductImage" 
           ImageUrl='<%#"~/images/thumbnails/" + 
               Eval("ThumbnailPhotoFileName") %>'
           Height="49" /><br />
      <asp:HyperLink ID="ProductLink" 
           Target="_blank" Text='<% #Eval("Name")%>'
           href='<%#"ShowProduct.aspx?ProductID=" + 
              Eval("ProductID") %>' />
    </td>
  </ItemTemplate>
</asp:ListView>

Voltar ao topo

Dados de paginação

Para permitir que os usuários paginem através de dados em um controle ListView, você pode usar um controle DataPager.O controle DataPager pode estar dentro do modelo LayoutTemplate ou na página fora do controle ListView.Se o controle DataPager não estiver no controle ListView, você deve definir a propriedade PagedControlID como a identificação do controle ListView.

O controle DataPager suporta interface de usuário de paginação interna.Você pode usar o objeto NumericPagerField, que permite aos usuários selecionar uma página de dados pelo número da página.Você também pode usar o objeto NextPreviousPagerField.Isso permite aos usuários percorrer páginas de dados uma por vez, ou pular para a primeira ou para a última página de dados.O tamanho das páginas de dados é definido usando a propriedade PageSize do controle DataPager.Você pode usar um ou mais objetos de campo de paginação em um único controle DataPager.

Você também pode criar interface do usuário de paginação personalizada usando o objeto TemplatePagerField.No modelo TemplatePagerField, você pode fazer referência ao controle DataPager usando a propriedade Container.Essa propriedade fornece acesso às propriedades do controle DataPager.Essas propriedades incluem o índice da linha inicial, o tamanho da página e o número total de linhas atualmente vinculado ao controle ListView.

O exemplo a seguir mostra uma classe DataPager incluída no modelo LayoutTemplate de um controle ListView.

<asp:ListView  ID="ListView1" 
    DataSourceID="SqlDataSource1">
  <LayoutTemplate>
    <table  id=" table1">
      <tr  id="itemPlaceholder">
      </tr>
    </table>
    <asp:DataPager  ID="DataPager" PageSize="5">
        <Fields>
          <asp:NumericPagerField ButtonCount="10"
               PreviousPageText="<--"
               NextPageText="-->" />
        </Fields>
    </asp:DataPager>
  </LayoutTemplate>
  <ItemTemplate>
    <tr >
      <%-- Data-bound content. --%>
    </tr>
  </ItemTemplate>
</asp:ListView>

A ilustração a seguir mostra um layout que exibe links para páginas de dados com base no número de página, usando o objeto NumericPagerField.

O exemplo a seguir mostra como criar o layout.

<asp:DataPager  ID="DataPager" PageSize="10">
  <Fields>
    <asp:NumericPagerField ButtonCount="10"
         CurrentPageLabelCssClass="CurrentPage"
         NumericButtonCssClass="PageNumbers"
         NextPreviousButtonCssClass="PageNumbers" NextPageText=" > "
         PreviousPageText=" < " />
  </Fields>
</asp:DataPager>

A ilustração a seguir mostra interface de usuário de paginação que exibe links para a próxima, para a anterior, para a primeira e para a última página de dados usando o objeto NextPreviousPagerField.A interface de usuário de paginação também inclui conteúdo personalizado a partir de um modelo TemplatePagerField, que exibe o intervalo de números de item atual e o número total de itens.O modelo TemplatePagerField inclui uma caixa de texto onde os usuários podem inserir o número de um item para mover-se.O item especificado é exibido como o primeiro item na página.

O exemplo a seguir mostra como criar a interface de usuário de paginação.

<asp:DataPager  ID="EmployeesDataPager" PageSize="8">
  <Fields>
    <asp:TemplatePagerField>
      <PagerTemplate>
        &nbsp;
        <asp:TextBox ID="CurrentRowTextBox" 
             AutoPostBack="true"
             Text="<%# Container.StartRowIndex + 1%>" 
             Columns="1" 
             style="text-align:right" 
             OnTextChanged="CurrentRowTextBox_OnTextChanged" />
        to
        <asp:Label ID="PageSizeLabel"  Font-Bold="true"
             Text="<%# Container.StartRowIndex + Container.PageSize > Container.TotalRowCount ? Container.TotalRowCount : Container.StartRowIndex + Container.PageSize %>" />
        of
        <asp:Label ID="TotalRowsLabel"  Font-Bold="true"
             Text="<%# Container.TotalRowCount %>" />
      </PagerTemplate>
    </asp:TemplatePagerField>
    <asp:NextPreviousPagerField 
         ShowFirstPageButton="true" ShowLastPageButton="true"
         FirstPageText="|<< " LastPageText=" >>|"
         NextPageText=" > " PreviousPageText=" < " />
  </Fields>
</asp:DataPager>

O exemplo a seguir mostra o manipulador de eventos para o evento TextChanged do controle TextBox incluído no modelo TemplatePagerField.O código no manipulador move para o item de dados que é especificado pelo usuário.

Protected Sub CurrentRowTextBox_OnTextChanged(ByVal sender As Object, _
        ByVal e As EventArgs) 
    Dim t As TextBox = CType(sender, TextBox)
    Dim pager As DataPager = _
        CType(EmployeesListView.FindControl("EmployeesDataPager"), _
        DataPager)
    pager.SetPageProperties(Convert.ToInt32(t.Text) - 1, _
        pager.PageSize, True)
End Sub

protected void CurrentRowTextBox_OnTextChanged(object sender, 
    EventArgs e)
{
    TextBox t = (TextBox)sender;
    DataPager pager = 
        (DataPager)EmployeesListView.FindControl("EmployeesDataPager");
    pager.SetPageProperties(Convert.ToInt32(t.Text) - 1, 
         pager.PageSize, true);
}

Voltar ao topo

Classificando Dados

Você pode classificar os dados que são exibidos em um controle ListView adicionando um botão ao modelo LayoutTemplate e definindo a propriedade CommandName do botão como "Classificar".Você define a propriedade CommandArgument do botão como o nome da coluna que você deseja utilizar para classificar.Clicar no botão Classificar repetidamente alterna a direção da classificação entre Ascending e Descending.

Você pode especificar vários nomes de colunas na propriedade CommandArgument do botão de classificação.No entanto, o controle ListView aplica a direção de classificação à lista completa das colunas.Como resultado, apenas a última coluna da lista tem a direção de classificação aplicada.Por exemplo, se o CommandArgument contiver "Sobrenome, Nome", clicar no botão Classificar repetidamente produz uma expressão de classificação como "Sobrenome, Nome ASC" ou "Sobrenome, Nome DESC".

O exemplo a seguir mostra um controle ListView que inclui um botão de classificação para classificar os dados por sobrenome.

<asp:ListView  ID="ListView1" DataSourceID="SqlDataSource1">
  <LayoutTemplate>
    <asp:LinkButton  ID="SortButton" 
         Text="Sort" CommandName="Sort" CommandArgument="LastName" />
    <table  id="table1">
      <tr  id="itemPlaceholder">
      </tr>
    </table>
    <asp:DataPager  ID="DataPager" PageSize="20">
        <Fields>
          <asp:NumericPagerField ButtonCount="10"
               PreviousPageText="<--"
               NextPageText="-->" />
        </Fields>
    </asp:DataPager>
  </LayoutTemplate>
  <ItemTemplate>
    <tr >
      <td><asp:Label  ID="FirstNameLabel" 
               Text='<%# Eval("FirstName")' /></td>
      <td><asp:Label  ID="LastNameLabel" 
               Text='<%# Eval("LastName")' /></td>
    </tr>
  </ItemTemplate>
</asp:ListView>

Definir a expressão de classificação dinamicamente

Você pode criar classificação personalizada definindo a expressão de classificação de um controle ListView dinamicamente.Para fazer isso, você chama o método Sort ou manipula o evento Sorting.

O exemplo a seguir mostra um manipulador para o evento Sorting.O código aplica a mesma direção de classificação a todas as colunas na propriedade SortExpression.

Protected Sub ContactsListView_Sorting(ByVal sender As Object, _
        ByVal e As ListViewSortEventArgs)

    If (String.IsNullOrEmpty(e.SortExpression)) Then Return

    Dim direction As String = ""
    If Not (ViewState("SortDirection") Is Nothing) Then
        direction = ViewState("SortDirection").ToString()
    End If
    
    If direction = "ASC" Then
        direction = "DESC"
    Else
        direction = "ASC"
    End If

    ViewState("SortDirection") = direction

    Dim sortColumns As String() = e.SortExpression.Split(","c)
    Dim sortExpression As String = sortColumns(0) & " " & direction
    Dim i As Integer
    For i = 1 To sortColumns.Length - 1
        sortExpression += ", " & sortColumns(i) & " " & direction
    Next i
    e.SortExpression = sortExpression
    
  End Sub

protected void EmployeesListView_OnSorting(object sender, 
        ListViewSortEventArgs e)
{
    if (String.IsNullOrEmpty(e.SortExpression)) { return; }
    string direction = "";
    if (ViewState["SortDirection"] != null)
        direction = ViewState["SortDirection"].ToString();

    if (direction == "ASC")
        direction = "DESC";
    else
        direction = "ASC";

    ViewState["SortDirection"] = direction;

    string[] sortColumns = e.SortExpression.Split(',');
    string sortExpression = sortColumns[0] + " " + direction;
    for (int i = 1; i < sortColumns.Length; i++)
        sortExpression += ", " + sortColumns[i] + " " + direction;
    e.SortExpression = sortExpression;
}

Voltar ao topo

Modificando Dados

Você pode criar modelos para o controle ListView que permitem aos usuários editar, inserir ou excluir um único item de dados.

Para permitir aos usuários editar um item de dados, você pode adicionar um modelo EditItemTemplate ao controle ListView.Quando um item é alternado para modo de edição, o controle ListView exibe o item usando o modelo de edição.O modelo deve incluir controles ligados a dados onde o usuário pode editar os valores.Por exemplo, o modelo pode incluir caixas de texto onde os usuários podem editar valores existentes.

Para permitir aos usuários inserir um novo item, você pode adicionar um modelo InsertItemTemplate para o controle ListView.Como com o modelo de edição, o modelo de inserção deve incluir controles ligados a dados que permitam a entrada de dados.O modelo InsertItemTemplate é processado tanto no início quanto no final dos itens exibidos.Você especifica onde o modelo InsertItemTemplate é processado utilizando a propriedade InsertItemPosition do controle ListView.

Normalmente você adiciona botões aos modelos para permitir que os usuários especifiquem qual ação desejam realizar.Por exemplo, você pode adicionar um botão Excluir a um modelo de item para permitir que os usuários excluam esse item.

Você pode adicionar um botão Editar a um modelo de item para permitir que o usuário alterne para o modo de edição.Em EditItemTemplate você pode incluir um botão de atualização que permite aos usuários salvar as alterações.Você também pode incluir um botão Cancelar que permite aos usuários alternar de volta ao modo de exibição sem salvar as alterações.

Você define a ação que um botão terá, definindo a propriedade CommandName do botão.A tabela a seguir lista valores para a propriedade CommandName para os quais o controle ListView possui comportamento interno.

  • Select
    Exibe o conteúdo do modelo SelectedItemTemplate para o item selecionado.

  • Insert
    Em um modelo InsertItemTemplate, especifica que o conteúdo de controles ligados a dados deve ser salvo na fonte de dados.

  • Edit
    Especifica que o controle ListView deve alternar para modo de edição e exibir o item usando o modelo EditItemTemplate.

  • Update
    Em um modelo EditItemTemplate, especifica que o conteúdo de controles ligados a dados deve ser salvo na fonte de dados.

  • Delete
    Exclui o item da fonte de dados.

  • Cancel
    Cancela a ação atual.Quando o modelo EditItemTemplate for exibido, cancelar a ação exibe o modelo SelectedItemTemplate se o item for o item selecionado atual; caso contrário, o modelo ItemTemplate é exibido.Quando o modelo InsertItemTemplate é exibido, cancelar a ação exibe um modelo InsertItemTemplate vazio.

  • (Valor personalizado)
    Por padrão, não executa nenhuma ação.Você pode fornecer um valor personalizado para a propriedade CommandName.No evento ItemCommand, você poderá, então, testar o valor e executar a ação.

Para obter um exemplo de um controle ListView que esteja configurado para permitir a edição, exclusão e inserção, consulte Passo-a-passo: modificando dados usando o controle do servidor Web ListView.

Voltar ao topo

Aplicando estilos a itens de ListView

O controle ListView não dá suporte para propriedades de estilo como BackColor e Font.Para aplicar estilos ao controle ListView, você deve usar classes CSS (folhas de estilo em cascata) ou elementos de estilo embutido para controles individuais dentro dos modelos ListView.

Alguns objetos suportam propriedades que permitem que você estilize elementos de saída.Por exemplo, o objeto NumericPagerField inclui as seguintes propriedades:

  • Uma propriedade NumericButtonCssClass que permite que você especifique o nome da classe CSS para os botões que movem para páginas de dados por número.

  • Uma propriedade CurrentPageLabelCssClass que permite que você especifique o nome da classe CSS para o número de página atual.

  • Uma propriedade NextPreviousButtonCssClass que permite que você especifique o nome da classe CSS para os botões que movem para o próximo grupo de botões numérticos ou para o anterior.

Voltar ao topo

Referência de Classe

A tabela seguinte lista as classes chave que estão relacionadas ao controle ListView.

Classe

Descrição

ListView

Um controle de servidor que exibe os valores de uma fonte de dados usando modelos definidos pelo usuário.Você pode configurar o controle para que os usuários possam selecionar, classificar, excluir, editar e inserir registros.

ListViewItem

Um objeto que representa um item no controle ListView.

ListViewDataItem

Um objeto que representa um item de dados no controle ListView.

ListViewItemType

Uma enumeração que identifica a função dos itens em um controle ListView.

DataPager

Um controle de servidor que fornece funcionalidade de paginação para controles que implementam a interface IPageableItemContainer, como o controle ListView.

NumericPagerField

Um campo DataPager que permite aos usuários selecionar uma página de dados pelo número de página.

NextPreviousPagerField

Um campo DataPager que permite aos usuários percorrer páginas de dados uma por vez, ou pular para a primeira ou para a última página de dados.

TemplatePagerField

Um campo DataPager que permite aos usuários criar uma interface do usuário de paginação personalizada.

Voltar ao topo

Exemplos de código

As seções a seguir incluem exemplos de código para o uso do controle ListView.

Tópicos Como Fazer e Passo a passo

Passo-a-passo: Exibindo, paginando e classificando dados usando o controle do servidor Web ListView

Passo-a-passo: modificando dados usando o controle do servidor Web ListView

Voltar ao topo

Consulte também

Conceitos

Visão geral de controle servidor Web com dados vinculados

Ligando a bancos de dados

Visão geral sobre controles fonte de dados

Outros recursos

Globalização e Localização no ASP.NET

Acessibilidade do ASP.NET