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

por Scott Mitchell

Baixar PDF

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

Introdução

A paginação e a 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 de relatório, os controles GridView, DetailsView e FormView fornecem suporte de paginação interno que pode ser habilitado na marca 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 para 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 nos postbacks. Embora isso leve mais tempo e código do que com o 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 começarmos este tutorial, vamos primeiro reservar um momento para adicionar as ASP.NET páginas que precisaremos para este tutorial e o próximo. Comece criando uma nova pasta no projeto chamada PagingSortingDataListRepeater. Em seguida, adicione as cinco páginas ASP.NET a seguir a essa pasta, tendo todas elas configuradas para usar a página Site.mastermestra:

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

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

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. Esse Controle de Usuário, que criamos no tutorial Páginas Mestras e Navegação do 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 usuário a Default.aspx (clique para exibir a SectionLevelTutorialListing.ascx 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 marcação Editando e Excluindo com o 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 ASP.NET

Uma revisão de Paging

Em 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 marcando 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 visita à página 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 recorta 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 a paginação padrão em detalhes no tutorial Paginação e classificação de dados de relatório.

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

A paginação personalizada resolve as preocupações de desempenho da paginação padrão, capturando apenas o subconjunto preciso de registros a serem exibidos na página solicitada. Ao implementar a paginação personalizada, devemos escrever a consulta SQL que retornará com eficiência apenas o conjunto correto de registros. Vimos como criar essa consulta usando a nova ROW_NUMBER() palavra-chave do SQL Server 2005 no tutorial Paginação eficiente por meio de 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 PageSize CurrentPageIndex propriedades que indicam quantos registros mostrar por página e o índice de página atual. Depois que essas propriedades forem definidas, elas PagedDataSource poderão ser usadas como a fonte de dados de qualquer controle Web de dados. O PagedDataSource, quando enumerado, retornará apenas o subconjunto apropriado de registros de seu interno DataSource com base nas PageSize propriedades e CurrentPageIndex . A Figura 4 ilustra a funcionalidade da PagedDataSource classe.

Figura 4: Encapsula PagedDataSource 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 Repetidor 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 ProductsBLL uso de uma PagedDataSource paginação personalizada para porque já temos métodos BLL na 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: Adicionando um método de paginação padrão na camada de lógica de negócios

Atualmente, a ProductsBLL classe tem um método para retornar todas as informações GetProducts() do produto e outro 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 recebe dois parâmetros de entrada inteiros:

• 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 pageIndex pageSize passados. O método conclui retornando este configurado PagedDataSource:

[System.ComponentModel.DataObjectMethodAttribute
    (System.ComponentModel.DataObjectMethodType.Select, false)]
public PagedDataSource GetProductsAsPagedDataSource(int pageIndex, int pageSize)
{
    // Get ALL of the products
    Northwind.ProductsDataTable products = GetProducts();
    // Limit the results through a PagedDataSource
    PagedDataSource pagedData = new PagedDataSource();
    pagedData.DataSource = products.Rows;
    pagedData.AllowPaging = true;
    pagedData.CurrentPageIndex = pageIndex;
    pagedData.PageSize = pageSize;
    return pagedData;
}

Etapa 3: Exibindo informações do produto em uma lista de dados usando a 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 uma DataList da Caixa de Ferramentas para o Designer, definindo a DataList propriedade como ID ProductsDefaultPaging. Na marca inteligente da DataList, crie um novo ObjectDataSource nomeado 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 método (clique para exibir a GetProductsAsPagedDataSource () imagem em tamanho real)

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

Figura 6: Defina as listas suspensas 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 em 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 determinada página de dados seja marcada.

Em particular, use os campos querystring pageIndex e pageSize para os parâmetros e pageSize , respectivamente (consulte a pageIndex 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 o QueryString como a origem dos parâmetros e pageSize (clique para exibir a pageIndex 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 da DataList RepeatColumns como 2, its Width como 100% e its 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 da 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 da DataList para reduzir o tamanho da página renderizada.

Ao visitar inicialmente esta página por meio de um navegador, nem os parâmetros nem pageSize querystring pageIndex 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 diretos para um usuário navegar para 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:

• Em seguida, os usuários anteriores podem mover uma página por vez, para a próxima ou para a anterior.
• Próximo, Anterior, Primeiro, Último , além dos botões Próximo e Anterior, esta interface inclui os botões Primeiro e Último para mover para a primeira ou ú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 numéricos da página, inclui botões para mover para a primeira ou a última página.

Para a Lista de Dados e o Repetidor, somos responsáveis por decidir sobre uma interface de paginação e implementá-la. Isso envolve a criação dos controles da 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 desativados. Por exemplo, ao visualizar a primeira página de dados usando a interface Avançar, Anterior, Primeiro, Último, os botões Primeiro e Anterior seriam desativados.

Para este tutorial, vamos usar a interface Próximo, Anterior, Primeiro, Último. Adicione quatro controles Web de botão à página e defina seu 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 Buttons. 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 examinados

Independentemente da interface de paginação selecionada, precisamos calcular 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 habilitados. Na interface Próximo, Anterior, Primeiro, Último que estamos construindo, a contagem de páginas é usada de duas maneiras:

• Para determinar se estamos visualizando a última página, nesse caso, os botões Avançar e Último estão desativados.
• 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 dividido 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érica exibir; se nossa interface de paginação incluir os botões Avançar ou Último, a contagem de páginas será usada para determinar quando desativar 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 botão Último for clicado, possamos determinar o índice da última página. Para facilitar isso, crie uma TotalRowCount propriedade na classe code-behind da página ASP.NET que persista seu valor para exibir o estado:

private int TotalRowCount
{
    get
    {
        object o = ViewState["TotalRowCount"];
        if (o == null)
            return -1;
        else
            return (int)o;
    }
    set
    {
        ViewState["TotalRowCount"] = value;
    }
}

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

private int PageIndex
{
    get
    {
        if (!string.IsNullOrEmpty(Request.QueryString["pageIndex"]))
            return Convert.ToInt32(Request.QueryString["pageIndex"]);
        else
            return 0;
    }
}
private int PageSize
{
    get
    {
        if (!string.IsNullOrEmpty(Request.QueryString["pageSize"]))
            return Convert.ToInt32(Request.QueryString["pageSize"]);
        else
            return 4;
    }
}
private int PageCount
{
    get
    {
        if (TotalRowCount <= 0 || PageSize <= 0)
            return 1;
        else
            return ((TotalRowCount + PageSize) - 1) / PageSize;
    }
}

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

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

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

protected void ProductsDefaultPagingDataSource_Selected
    (object sender, ObjectDataSourceStatusEventArgs e)
{
    // Reference the PagedDataSource bound to the DataList
    PagedDataSource pagedData = (PagedDataSource)e.ReturnValue;
    // Remember the total number of records being paged through
    // across postbacks
    TotalRowCount = pagedData.DataSourceCount;
}

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 de dados solicitada, use Response.Redirect(url) 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, redirecionaríamos 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 . No manipulador de FirstPage Click eventos, chame RedirectUser(0), para enviá-los para a primeira página; no manipulador de PrevPage Click eventos, use PageIndex - 1 como índice de página; e assim por diante.

protected void FirstPage_Click(object sender, EventArgs e)
{
    // Send the user to the first page
    RedirectUser(0);
}
protected void PrevPage_Click(object sender, EventArgs e)
{
    // Send the user to the previous page
    RedirectUser(PageIndex - 1);
}
protected void NextPage_Click(object sender, EventArgs e)
{
    // Send the user to the next page
    RedirectUser(PageIndex + 1);
}
protected void LastPage_Click(object sender, EventArgs e)
{
    // Send the user to the last page
    RedirectUser(PageCount - 1);
}
private void RedirectUser(int sendUserToPageIndex)
{
    // Send the user to the requested page
    Response.Redirect(string.Format("Paging.aspx?pageIndex={0}&pageSize={1}",
        sendUserToPageIndex, PageSize));
}

Com os Click manipuladores de eventos concluídos, os registros do DataList podem ser paginados clicando nos botões. Reserve um momento para experimentá-lo!

Desativando controles de interface de paginação

Atualmente, todos os quatro botões estão ativados, independentemente da página que está sendo visualizada. No entanto, queremos desabilitar os botões Primeiro e Anterior ao mostrar a primeira página de dados e os botões Próximo e Último ao mostrar a última página. O PagedDataSource objeto retornado pelo método ObjectDataSource tem Select() 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 do Selected ObjectDataSource:

// Configure the paging interface based on the data in the PagedDataSource
FirstPage.Enabled = !pagedData.IsFirstPage;
PrevPage.Enabled = !pagedData.IsFirstPage;
NextPage.Enabled = !pagedData.IsLastPage;
LastPage.Enabled = !pagedData.IsLastPage;

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

Vamos completar a interface de paginação informando ao usuário qual página ele está visualizando 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 ObjectDataSource Selected de modo que inclua a página atual que está 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 foi 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 desativados. Clicar em Avançar exibe os próximos quatro registros (consulte a Figura 11); os botões Primeiro e Anterior agora estão ativados.

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 listando opções de tamanho de página como 5, 10, 25, 50 e Todos. Ao selecionar um tamanho de página, o usuário precisaria ser redirecionado de volta para Paging.aspx?pageIndex=0&pageSize=selectedPageSize. Deixo a implementação desse aprimoramento como um exercício para o leitor.

Usando a paginação personalizada

As páginas DataList percorrem 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 da paginação personalizada em uma DataList são os mesmos da paginação padrão. Com a paginação personalizada, use o ProductBLL método da GetProductsPaged classe (em vez de GetProductsAsPagedDataSource). Conforme discutido no tutorial Paginação eficiente por meio de grandes quantidades de dados , GetProductsPaged deve ser passado o índice da 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 PagedDataSource há 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 paginados. Para determinar se a primeira página de dados está sendo exibida, examine o índice da linha inicial se for zero e, em seguida, a primeira página está sendo exibida. A última página será exibida se o índice da linha inicial mais o máximo de linhas 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, associá-lo 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.

Além de recuperar o conjunto preciso de registros a serem exibidos para paginação personalizada ou todos os registros em uma PagedDataSource paginação padrão, também precisamos adicionar manualmente a interface de paginação. Para este tutorial, criamos uma interface Próximo, Anterior, Primeiro, Último com quatro controles Web de botão. Além disso, um controle Label exibindo o número da página atual e o número total de páginas foi adicionado.

No próximo tutorial, veremos como adicionar suporte à 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).

Boa programação!

Sobre o autor

Scott Mitchell, autor de sete livros ASP/ASP.NET e fundador da 4GuysFromRolla.com, trabalha com tecnologias da Web da Microsoft desde 1998. Scott trabalha como consultor, instrutor e escritor independente. 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 a

Esta série de tutoriais foi revisada por muitos revisores úteis. Os principais revisores deste tutorial foram Liz Shulok, Ken Pessa e Bernadette Leigh. Interessado em revisar meus próximos artigos do MSDN? Em caso afirmativo, envie-me uma mensagem para mitchell@4GuysFromRolla.com.

Próximo