Paginação de dados de relatório em um controle DataList ou Repeater (VB)

por Scott Mitchell

Baixar PDF

Embora nem o DataList nem o Repeater ofereçam suporte automático de paginação ou classificação, este tutorial mostra como adicionar suporte de paginação ao DataList ou Repeater, o que permite interfaces de paginação e exibição de dados muito mais flexíveis.

Introdução

Paginação e classificação são dois recursos muito comuns ao exibir dados em um aplicativo online. Por exemplo, ao pesquisar livros ASP.NET em uma livraria online, pode haver centenas desses livros, mas o relatório que lista os resultados da pesquisa lista apenas dez correspondências por página. Além disso, os resultados podem ser classificados por título, preço, contagem de páginas, nome do autor e assim por diante. Como discutimos no tutorial Paginação e Classificação de Dados do Relatório , os controles GridView, DetailsView e FormView fornecem suporte interno à paginação que pode ser habilitado no tique de uma caixa de seleção. O GridView também inclui suporte à classificação.

Infelizmente, nem o DataList nem o Repeater oferecem suporte automático de paginação ou classificação. Neste tutorial, examinaremos como adicionar suporte à paginação ao DataList ou Repeater. Devemos criar manualmente a interface de paginação, exibir a página apropriada de registros e lembrar a página que está sendo visitada entre postbacks. Embora isso leve mais tempo e código do que com GridView, DetailsView ou FormView, o DataList e o Repeater permitem interfaces de paginação e exibição de dados muito mais flexíveis.

Observação

Este tutorial se concentra exclusivamente na paginação. No próximo tutorial, voltaremos nossa atenção para a adição de recursos de classificação.

Etapa 1: adicionando as páginas da Web do tutorial de paginação e classificação

Antes de iniciarmos este tutorial, primeiro vamos demorar um pouco para adicionar as páginas de ASP.NET que precisaremos para este tutorial e o próximo. Comece criando uma nova pasta no projeto chamado PagingSortingDataListRepeater. Em seguida, adicione as cinco páginas ASP.NET a seguir a essa pasta, configurando todas elas para usar a página Site.mastermaster :

• Default.aspx
• Paging.aspx
• Sorting.aspx
• SortingWithDefaultPaging.aspx
• SortingWithCustomPaging.aspx

Figura 1: Criar uma PagingSortingDataListRepeater pasta e adicionar o tutorial ASP.NET páginas

Em seguida, abra a Default.aspx página e arraste o SectionLevelTutorialListing.ascx Controle de Usuário da UserControls pasta para a superfície Design. Este Controle de Usuário, que criamos no tutorial Páginas Mestras e Navegação no Site , enumera o mapa do site e exibe esses tutoriais na seção atual em uma lista com marcadores.

Figura 2: Adicionar o controle de SectionLevelTutorialListing.ascx usuário a Default.aspx (clique para exibir a imagem em tamanho real)

Para que a lista com marcadores exiba os tutoriais de paginação e classificação que criaremos, precisamos adicioná-los ao mapa do site. Abra o Web.sitemap arquivo e adicione a seguinte marcação após a edição e exclusão com a marcação do nó do mapa do site DataList:

<siteMapNode
    url="~/PagingSortingDataListRepeater/Default.aspx"
    title="Paging and Sorting with the DataList and Repeater"
    description="Paging and Sorting the Data in the DataList and Repeater Controls">
    <siteMapNode
        url="~/PagingSortingDataListRepeater/Paging.aspx"
        title="Paging"
        description="Learn how to page through the data shown
                     in the DataList and Repeater controls." />
    <siteMapNode
        url="~/PagingSortingDataListRepeater/Sorting.aspx"
        title="Sorting"
        description="Sort the data displayed in a DataList or
                     Repeater control." />
    <siteMapNode
        url="~/PagingSortingDataListRepeater/SortingWithDefaultPaging.aspx"
        title="Sorting with Default Paging"
        description="Create a DataList or Repeater control that is paged using
                     default paging and can be sorted." />
    <siteMapNode
        url="~/PagingSortingDataListRepeater/SortingWithCustomPaging.aspx"
        title="Sorting with Custom Paging"
        description="Learn how to sort the data displayed in a DataList or
                     Repeater control that uses custom paging." />
</siteMapNode>

Figura 3: Atualizar o mapa do site para incluir as novas páginas de ASP.NET

Uma revisão de paginação

Nos tutoriais anteriores, vimos como percorrer os dados nos controles GridView, DetailsView e FormView. Esses três controles oferecem uma forma simples de paginação chamada paginação padrão que pode ser implementada simplesmente verificando a opção Habilitar Paginação na marca inteligente do controle. Com a paginação padrão, cada vez que uma página de dados é solicitada na primeira página visita ou quando o usuário navega para uma página diferente de dados, o controle GridView, DetailsView ou FormView solicita novamente todos os dados do ObjectDataSource. Em seguida, ele captura o conjunto específico de registros a serem exibidos, considerando o índice de página solicitado e o número de registros a serem exibidos por página. Discutimos detalhadamente a paginação padrão no tutorial Paginação e Classificação de Dados do Relatório .

Como a paginação padrão solicita novamente todos os registros para cada página, não é prático ao paginar quantidades suficientemente grandes de dados. Por exemplo, imagine paginação por meio de 50.000 registros com um tamanho de página de 10. Cada vez que o usuário se move para uma nova página, todos os 50.000 registros devem ser recuperados do banco de dados, embora apenas dez deles sejam exibidos.

A paginação personalizada resolve as preocupações de desempenho da paginação padrão, agarrando apenas o subconjunto preciso de registros a serem exibidos na página solicitada. Ao implementar a paginação personalizada, devemos gravar a consulta SQL que retornará com eficiência apenas o conjunto correto de registros. Vimos como criar essa consulta usando SQL Server novo ROW_NUMBER() palavra-chave de 2005 no tutorial Paginação eficiente por grandes quantidades de dados.

Para implementar a paginação padrão nos controles DataList ou Repeater, podemos usar a PagedDataSource classe como um wrapper em torno do ProductsDataTable cujo conteúdo está sendo paginado. A PagedDataSource classe tem uma DataSource propriedade que pode ser atribuída a qualquer objeto enumerável e PageSizeCurrentPageIndex propriedades que indicam quantos registros mostrar por página e o índice de página atual. Depois que essas propriedades tiverem sido definidas, o PagedDataSource poderá ser usado como a fonte de dados de qualquer controle da Web de dados. O PagedDataSource, quando enumerado, retornará apenas o subconjunto apropriado de registros de seu interior DataSource com base nas PageSize propriedades e CurrentPageIndex . A Figura 4 ilustra a funcionalidade da PagedDataSource classe .

Figura 4: o PagedDataSource encapsula um objeto enumerável com uma interface paginável

O PagedDataSource objeto pode ser criado e configurado diretamente da Camada lógica de negócios e associado a um DataList ou Repeater por meio de um ObjectDataSource ou pode ser criado e configurado diretamente na classe code-behind da página ASP.NET. Se a última abordagem for usada, devemos renunciar ao uso do ObjectDataSource e, em vez disso, associar os dados paginados ao DataList ou Repeater programaticamente.

O PagedDataSource objeto também tem propriedades para dar suporte à paginação personalizada. No entanto, podemos ignorar o uso de um PagedDataSource para paginação personalizada porque já temos métodos BLL na ProductsBLL classe projetada para paginação personalizada que retornam os registros precisos a serem exibidos.

Neste tutorial, examinaremos a implementação da paginação padrão em um DataList adicionando um novo método à ProductsBLL classe que retorna um objeto configurado PagedDataSource adequadamente. No próximo tutorial, veremos como usar a paginação personalizada.

Etapa 2: Adicionar um método de paginação padrão na camada de lógica de negócios

Atualmente ProductsBLL , a classe tem um método para retornar todas as informações GetProducts() do produto e um para retornar um subconjunto específico de produtos em um índice GetProductsPaged(startRowIndex, maximumRows)inicial . Com a paginação padrão, os controles GridView, DetailsView e FormView usam o GetProducts() método para recuperar todos os produtos, mas usam um PagedDataSource internamente para exibir apenas o subconjunto correto de registros. Para replicar essa funcionalidade com os controles DataList e Repeater, podemos criar um novo método na BLL que imita esse comportamento.

Adicione um método à ProductsBLL classe chamada GetProductsAsPagedDataSource que usa dois parâmetros de entrada de inteiro:

• pageIndex o índice da página a ser exibida, indexado em zero e
• pageSize o número de registros a serem exibidos por página.

GetProductsAsPagedDataSource começa recuperando todos os registros de GetProducts(). Em seguida, ele cria um PagedDataSource objeto, definindo suas CurrentPageIndex propriedades e PageSize para os valores dos parâmetros e pageSize passadospageIndex. O método conclui retornando este configurado PagedDataSource:

<System.ComponentModel.DataObjectMethodAttribute _
    (System.ComponentModel.DataObjectMethodType.Select, False)> _
Public Function GetProductsAsPagedDataSource(ByVal pageIndex As Integer, _
    ByVal pageSize As Integer) As PagedDataSource
    ' Get ALL of the products
    Dim products As Northwind.ProductsDataTable = GetProducts()
    ' Limit the results through a PagedDataSource
    Dim pagedData As New PagedDataSource()
    pagedData.DataSource = products.Rows
    pagedData.AllowPaging = True
    pagedData.CurrentPageIndex = pageIndex
    pagedData.PageSize = pageSize
    Return pagedData
End Function

Etapa 3: exibindo informações do produto em uma DataList usando paginação padrão

Com o GetProductsAsPagedDataSource método adicionado à ProductsBLL classe , agora podemos criar um DataList ou Repeater que fornece paginação padrão. Comece abrindo a Paging.aspx página na PagingSortingDataListRepeater pasta e arraste um DataList da Caixa de Ferramentas para o Designer, definindo a propriedade ProductsDefaultPagingDataList como ID . Na marca inteligente DataList, crie um novo ObjectDataSource chamado ProductsDefaultPagingDataSource e configure-o para que ele recupere dados usando o GetProductsAsPagedDataSource método .

Figura 5: Criar um ObjectDataSource e configurá-lo para usar o GetProductsAsPagedDataSource() método (clique para exibir a imagem em tamanho real)

Defina as listas suspensas nas guias UPDATE, INSERT e DELETE como (Nenhum).

Figura 6: Definir o Drop-Down Listas nas guias UPDATE, INSERT e DELETE como (Nenhum) (Clique para exibir a imagem em tamanho real)

Como o GetProductsAsPagedDataSource método espera dois parâmetros de entrada, o assistente nos solicita a origem desses valores de parâmetro.

Os valores de índice de página e tamanho de página devem ser lembrados entre postbacks. Eles podem ser armazenados no estado de exibição, persistidos na querystring, armazenados em variáveis de sessão ou lembrados usando alguma outra técnica. Para este tutorial, usaremos a querystring, que tem a vantagem de permitir que uma página específica de dados seja marcada como indicador.

Em particular, use os campos querystring pageIndex e pageSize para os pageIndex parâmetros e pageSize , respectivamente (consulte a Figura 7). Reserve um momento para definir os valores padrão para esses parâmetros, pois os valores de querystring não estarão presentes quando um usuário visitar esta página pela primeira vez. Para pageIndex, defina o valor padrão como 0 (que mostrará a primeira página de dados) e pageSize o valor padrão de s como 4.

Figura 7: Usar QueryString como a origem dos pageIndex parâmetros e pageSize (clique para exibir a imagem em tamanho real)

Depois de configurar o ObjectDataSource, o Visual Studio cria automaticamente um ItemTemplate para o DataList. Personalize o ItemTemplate para que apenas o nome, a categoria e o fornecedor do produto sejam mostrados. Defina também a propriedade DataList como RepeatColumns 2, ela como Width 100%, e sua ItemStyle s Width como 50%. Essas configurações de largura fornecerão espaçamento igual para as duas colunas.

Depois de fazer essas alterações, a marcação de DataList e ObjectDataSource deve ser semelhante à seguinte:

<asp:DataList ID="ProductsDefaultPaging" runat="server" Width="100%"
    DataKeyField="ProductID" DataSourceID="ProductsDefaultPagingDataSource"
    RepeatColumns="2" EnableViewState="False">
    <ItemTemplate>
        <h4><asp:Label ID="ProductNameLabel" runat="server"
            Text='<%# Eval("ProductName") %>'></asp:Label></h4>
        Category:
        <asp:Label ID="CategoryNameLabel" runat="server"
            Text='<%# Eval("CategoryName") %>'></asp:Label><br />
        Supplier:
        <asp:Label ID="SupplierNameLabel" runat="server"
            Text='<%# Eval("SupplierName") %>'></asp:Label><br />
        <br />
        <br />
    </ItemTemplate>
    <ItemStyle Width="50%" />
</asp:DataList>
<asp:ObjectDataSource ID="ProductsDefaultPagingDataSource" runat="server"
    OldValuesParameterFormatString="original_{0}" TypeName="ProductsBLL"
    SelectMethod="GetProductsAsPagedDataSource">
    <SelectParameters>
        <asp:QueryStringParameter DefaultValue="0" Name="pageIndex"
             QueryStringField="pageIndex" Type="Int32" />
        <asp:QueryStringParameter DefaultValue="4" Name="pageSize"
             QueryStringField="pageSize" Type="Int32" />
    </SelectParameters>
</asp:ObjectDataSource>

Observação

Como não estamos executando nenhuma funcionalidade de atualização ou exclusão neste tutorial, você pode desabilitar o estado de exibição de DataList para reduzir o tamanho da página renderizada.

Ao visitar inicialmente essa página por meio de um navegador, nem os pageIndex parâmetros de querystring nem pageSize são fornecidos. Portanto, os valores padrão de 0 e 4 são usados. Como mostra a Figura 8, isso resulta em uma DataList que exibe os quatro primeiros produtos.

Figura 8: Os quatro primeiros produtos estão listados (clique para exibir a imagem em tamanho real)

Sem uma interface de paginação, atualmente não há meios simples para um usuário navegar até a segunda página de dados. Criaremos uma interface de paginação na etapa 4. Por enquanto, porém, a paginação só pode ser realizada especificando diretamente os critérios de paginação na querystring. Por exemplo, para exibir a segunda página, altere a URL na barra de endereços do navegador de Paging.aspx para Paging.aspx?pageIndex=2 e pressione Enter. Isso faz com que a segunda página de dados seja exibida (consulte a Figura 9).

Figura 9: a segunda página de dados é exibida (clique para exibir a imagem em tamanho real)

Etapa 4: Criando a interface de paginação

Há uma variedade de interfaces de paginação diferentes que podem ser implementadas. Os controles GridView, DetailsView e FormView fornecem quatro interfaces diferentes para escolher entre:

• Em seguida, os usuários anteriores podem mover uma página de cada vez para a próxima ou anterior.
• Em seguida, anterior, primeiro, último além dos botões Avançar e Anterior, essa interface inclui os botões Primeiro e Último para mover para a primeira ou muito última página.
• Numérico lista os números de página na interface de paginação, permitindo que um usuário pule rapidamente para uma página específica.
• Numérico, Primeiro, Último além dos números de página numéricos, inclui botões para mover para a primeira ou última página.

Para DataList e Repeater, somos responsáveis por decidir sobre uma interface de paginação e implementá-la. Isso envolve a criação dos controles Web necessários na página e a exibição da página solicitada quando um botão de interface de paginação específico é clicado. Além disso, determinados controles de interface de paginação podem precisar ser desabilitados. Por exemplo, ao exibir a primeira página de dados usando a interface Next, Previous, First, Last, os botões Primeiro e Anterior seriam desabilitados.

Para este tutorial, vamos usar a interface Next, Previous, First, Last. Adicione quatro controles Web de botão à página e defina seus ID s como FirstPage, PrevPage, NextPagee LastPage. Defina as Text propriedades como << First, < Prev, Next >e Last >> .

<asp:Button runat="server" ID="FirstPage" Text="<< First" />
<asp:Button runat="server" ID="PrevPage" Text="< Prev" />
<asp:Button runat="server" ID="NextPage" Text="Next >" />
<asp:Button runat="server" ID="LastPage" Text="Last >>" />

Em seguida, crie um manipulador de eventos para cada um Click desses Botões. Em um momento, adicionaremos o código necessário para exibir a página solicitada.

Lembrando o número total de registros que estão sendo paginado

Independentemente da interface de paginação selecionada, precisamos computar e lembrar o número total de registros que estão sendo paginados. A contagem total de linhas (em conjunto com o tamanho da página) determina quantas páginas totais de dados estão sendo paginadas, o que determina quais controles de interface de paginação são adicionados ou estão habilitados. Na interface Next, Previous, First, Last que estamos criando, a contagem de páginas é usada de duas maneiras:

• Para determinar se estamos exibindo a última página, nesse caso, os botões Avançar e Último estão desabilitados.
• Se o usuário clicar no botão Último, precisamos levá-lo para a última página, cujo índice é um a menos que a contagem de páginas.

A contagem de páginas é calculada como o teto da contagem total de linhas dividida pelo tamanho da página. Por exemplo, se estivermos paginando 79 registros com quatro registros por página, a contagem de páginas será 20 (o teto de 79/4). Se estivermos usando a interface de paginação numérica, essas informações nos informarão quantos botões de página numéricos serão exibidos; se nossa interface de paginação incluir botões Avançar ou Último, a contagem de páginas será usada para determinar quando desabilitar os botões Avançar ou Último.

Se a interface de paginação incluir um botão Último, é imperativo que o número total de registros que estão sendo paginados seja lembrado entre postbacks para que, quando o último botão for clicado, possamos determinar o último índice de página. Para facilitar isso, crie uma TotalRowCount propriedade na classe code-behind da página ASP.NET que persiste seu valor para exibir o estado:

Private Property TotalRowCount() As Integer
    Get
        Dim o As Object = ViewState("TotalRowCount")
        If (o Is Nothing) Then
            Return -1
        Else
            Return Convert.ToInt32(o)
        End If
    End Get
    set(Value as Integer)
        ViewState("TotalRowCount") = value
    End Set
End Property

Além de TotalRowCount, leve um minuto para criar propriedades de nível de página somente leitura para acessar facilmente o índice de página, o tamanho da página e a contagem de páginas:

Private ReadOnly Property PageIndex() As Integer
    Get
        If (Not String.IsNullOrEmpty(Request.QueryString("pageIndex"))) Then
            Return Convert.ToInt32(Request.QueryString("pageIndex"))
        Else
            Return 0
        End If
    End Get
End Property
Private ReadOnly Property PageSize() As Integer
    Get
        If (Not String.IsNullOrEmpty(Request.QueryString("pageSize"))) Then
            Return Convert.ToInt32(Request.QueryString("pageSize"))
        Else
            Return 4
        End If
    End Get
End Property
Private ReadOnly Property PageCount() As Integer
    Get
        If TotalRowCount <= 0 OrElse PageSize <= 0 Then
            Return 1
        Else
            Return ((TotalRowCount + PageSize) - 1) / PageSize
        End If
    End Get
End Property

Determinando o número total de registros que estão sendo paginado

O PagedDataSource objeto retornado do método ObjectDataSource Select() tem dentro dele todos os registros do produto, embora apenas um subconjunto deles seja exibido na DataList. A PagedDataSource propriedade s Count retorna apenas o número de itens que serão exibidos na DataList; a DataSourceCount propriedade retorna o número total de itens dentro do PagedDataSource. Portanto, precisamos atribuir à propriedade da TotalRowCount página ASP.NET o valor da PagedDataSource propriedade s DataSourceCount .

Para fazer isso, crie um manipulador de eventos para o evento ObjectDataSource.Selected Selected No manipulador de eventos, temos acesso ao valor retornado do método ObjectDataSource nesse Select() caso, o PagedDataSource.

Protected Sub ProductsDefaultPagingDataSource_Selected(ByVal sender As Object, _
    ByVal e As System.Web.UI.WebControls.ObjectDataSourceStatusEventArgs) _
    Handles ProductsDefaultPagingDataSource.Selected
    ' Reference the PagedDataSource bound to the DataList
    Dim pagedData As PagedDataSource = CType(e.ReturnValue, PagedDataSource)
    ' Remember the total number of records being paged through across postbacks
    TotalRowCount = pagedData.DataSourceCount
End Sub

Exibindo a página de dados solicitada

Quando o usuário clica em um dos botões na interface de paginação, precisamos exibir a página de dados solicitada. Como os parâmetros de paginação são especificados por meio da querystring, para mostrar a página solicitada de uso Response.Redirect(url) de dados para que o navegador do usuário solicite novamente a Paging.aspx página com os parâmetros de paginação apropriados. Por exemplo, para exibir a segunda página de dados, redirecionamos o usuário para Paging.aspx?pageIndex=1.

Para facilitar isso, crie um RedirectUser(sendUserToPageIndex) método que redirecione o usuário para Paging.aspx?pageIndex=sendUserToPageIndex. Em seguida, chame esse método dos quatro manipuladores de eventos Button Click . FirstPageClick No manipulador de eventos, chame RedirectUser(0), para enviá-los para a primeira página; no PrevPageClick manipulador de eventos, use PageIndex - 1 como o índice de página; e assim por diante.

Protected Sub FirstPage_Click(ByVal sender As Object, ByVal e As EventArgs) _
    Handles FirstPage.Click
    ' Send the user to the first page
    RedirectUser(0)
End Sub
Protected Sub PrevPage_Click(ByVal sender As Object, ByVal e As EventArgs) _
    Handles PrevPage.Click
    ' Send the user to the previous page
    RedirectUser(PageIndex - 1)
End Sub
Protected Sub NextPage_Click(ByVal sender As Object, ByVal e As EventArgs) _
    Handles NextPage.Click
    ' Send the user to the next page
    RedirectUser(PageIndex + 1)
End Sub
Protected Sub LastPage_Click(ByVal sender As Object, ByVal e As EventArgs) _
    Handles LastPage.Click
    ' Send the user to the last page
    RedirectUser(PageCount - 1)
End Sub
Private Sub RedirectUser(ByVal sendUserToPageIndex As Integer)
    ' Send the user to the requested page
    Response.Redirect(String.Format("Paging.aspx?pageIndex={0}&pageSize={1}", _
        sendUserToPageIndex, PageSize))
End Sub

Com os Click manipuladores de eventos concluídos, os registros datalist podem ser paginado clicando nos botões. Tire um momento para experimentar!

Desabilitando controles de interface de paginação

Atualmente, todos os quatro botões estão habilitados independentemente da página ser exibida. No entanto, queremos desabilitar os botões Primeiro e Anterior ao mostrar a primeira página de dados e os botões Avançar e Último ao mostrar a última página. O PagedDataSource objeto retornado pelo método ObjectDataSource Select() tem propriedades IsFirstPage e IsLastPage que podemos examinar para determinar se estamos exibindo a primeira ou a última página de dados.

Adicione o seguinte ao manipulador de eventos ObjectDataSource Selected :

' Configure the paging interface based on the data in the PagedDataSource
FirstPage.Enabled = Not pagedData.IsFirstPage
PrevPage.Enabled = Not pagedData.IsFirstPage
NextPage.Enabled = Not pagedData.IsLastPage
LastPage.Enabled = Not pagedData.IsLastPage

Com essa adição, os botões Primeiro e Anterior serão desabilitados ao exibir a primeira página, enquanto os botões Avançar e Último serão desabilitados ao exibir a última página.

Vamos concluir a interface de paginação informando ao usuário qual página ele está exibindo no momento e quantas páginas totais existem. Adicione um controle Web Label à página e defina sua ID propriedade como CurrentPageNumber. Defina sua Text propriedade no manipulador de eventos Selected do ObjectDataSource de modo que inclua a página atual sendo exibida (PageIndex + 1) e o número total de páginas (PageCount).

' Display the current page being viewed...
CurrentPageNumber.Text = String.Format("You are viewing page {0} of {1}...", _
    PageIndex + 1, PageCount)

A Figura 10 mostra Paging.aspx quando visitado pela primeira vez. Como a querystring está vazia, o DataList usa como padrão mostrar os quatro primeiros produtos; os botões Primeiro e Anterior estão desabilitados. Clicar em Avançar exibe os próximos quatro registros (consulte Figura 11); os botões Primeiro e Anterior agora estão habilitados.

Figura 10: a primeira página de dados é exibida (clique para exibir a imagem em tamanho real)

Figura 11: a segunda página de dados é exibida (clique para exibir a imagem em tamanho real)

Observação

A interface de paginação pode ser aprimorada ainda mais permitindo que o usuário especifique quantas páginas exibir por página. Por exemplo, um DropDownList pode ser adicionado opções de tamanho de página de listagem, como 5, 10, 25, 50 e Todos. Ao selecionar um tamanho de página, o usuário precisará ser redirecionado de volta para Paging.aspx?pageIndex=0&pageSize=selectedPageSize. Saio da implementação desse aprimoramento como um exercício para o leitor.

Usando paginação personalizada

O DataList usa seus dados usando a técnica de paginação padrão ineficiente. Ao paginar quantidades suficientemente grandes de dados, é imperativo que a paginação personalizada seja usada. Embora os detalhes da implementação sejam ligeiramente diferentes, os conceitos por trás da implementação de paginação personalizada em uma DataList são os mesmos que com a paginação padrão. Com a paginação personalizada, use o ProductBLL método da classe s GetProductsPaged (em vez de GetProductsAsPagedDataSource). Conforme discutido no tutorial Paginação eficiente por meio de grandes quantidades de dados , GetProductsPaged deve ser passado o índice de linha inicial e o número máximo de linhas a serem retornadas. Esses parâmetros podem ser mantidos por meio da querystring, assim como os pageIndex parâmetros e pageSize usados na paginação padrão.

Como não há nenhum PagedDataSource com paginação personalizada, técnicas alternativas devem ser usadas para determinar o número total de registros que estão sendo paginados e se estamos exibindo a primeira ou a última página de dados. O TotalNumberOfProducts() método na ProductsBLL classe retorna o número total de produtos que estão sendo paginado. Para determinar se a primeira página de dados está sendo exibida, examine o índice de linha inicial se for zero e, em seguida, a primeira página está sendo exibida. A última página será exibida se o índice de linha inicial mais as linhas máximas a serem retornadas for maior ou igual ao número total de registros que estão sendo paginados.

Exploraremos a implementação da paginação personalizada com mais detalhes no próximo tutorial.

Resumo

Embora nem o DataList nem o Repeater ofereçam o suporte de paginação pronto para uso encontrado nos controles GridView, DetailsView e FormView, essa funcionalidade pode ser adicionada com o mínimo de esforço. A maneira mais fácil de implementar a paginação padrão é encapsular todo o conjunto de produtos em um PagedDataSource e, em seguida, associar o PagedDataSource ao DataList ou Repeater. Neste tutorial, adicionamos o GetProductsAsPagedDataSource método à ProductsBLL classe para retornar o PagedDataSource. A ProductsBLL classe já contém os métodos necessários para paginação GetProductsPaged personalizada e TotalNumberOfProducts.

Juntamente com a recuperação do conjunto preciso de registros a serem exibidos para paginação personalizada ou todos os registros em um PagedDataSource para paginação padrão, também precisamos adicionar manualmente a interface de paginação. Para este tutorial, criamos uma interface Next, Previous, First, Last com quatro controles Da Web de botão. Além disso, um controle Rótulo exibindo o número de página atual e o número total de páginas foi adicionado.

No próximo tutorial, veremos como adicionar suporte de classificação ao DataList e ao Repeater. Também veremos como criar uma DataList que pode ser paginada e classificada (com exemplos usando paginação padrão e personalizada).

Programação feliz!

Sobre o autor

Scott Mitchell, autor de sete livros do ASP/ASP.NET e fundador da 4GuysFromRolla.com, trabalha com tecnologias da Microsoft Web desde 1998. Scott trabalha como consultor independente, treinador e escritor. Seu último livro é Sams Teach Yourself ASP.NET 2.0 em 24 Horas. Ele pode ser contatado em mitchell@4GuysFromRolla.com. ou através de seu blog, que pode ser encontrado em http://ScottOnWriting.NET.

Agradecimentos Especiais

Esta série de tutoriais foi revisada por muitos revisores úteis. Os principais revisores deste tutorial foram Liz Shulok, Ken Pespisa e Berne Leigh. Interessado em revisar meus próximos artigos do MSDN? Nesse caso, deixe-me uma linha em mitchell@4GuysFromRolla.com.

AnteriorAvançar