Pagination des données d’un rapport dans un contrôle DataList ou Repeater (C#)

par Scott Mitchell

Télécharger le PDF

Bien que dataList et Repeater n’offrent pas de prise en charge automatique de la pagination ou du tri, ce didacticiel montre comment ajouter la prise en charge de la pagination à la liste de données ou au répéteur, ce qui permet d’obtenir des interfaces d’affichage de données et de pagination beaucoup plus flexibles.

Présentation

La pagination et le tri sont deux fonctionnalités très courantes lors de l’affichage de données dans une application en ligne. Par exemple, lorsque vous recherchez ASP.NET livres dans un magasin de livres en ligne, il peut y avoir des centaines de ces livres, mais le rapport répertoriant les résultats de recherche répertorie seulement dix correspondances par page. En outre, les résultats peuvent être triés par titre, prix, nombre de pages, nom de l’auteur, etc. Comme nous l’avons vu dans le didacticiel sur la pagination et le tri des données de rapport, les contrôles GridView, DetailsView et FormView fournissent tous une prise en charge intégrée de la pagination qui peut être activée à la coche d’une case. GridView inclut également la prise en charge du tri.

Malheureusement, ni dataList ni repeater n’offrent la prise en charge automatique de la pagination ou du tri. Dans ce tutoriel, nous allons examiner comment ajouter la prise en charge de la pagination à La liste de données ou au répéteur. Nous devons créer manuellement l’interface de pagination, afficher la page appropriée des enregistrements et mémoriser la page visitée dans les postbacks. Bien que cela prenne plus de temps et de code qu’avec GridView, DetailsView ou FormView, la Liste de données et le répéteur permettent d’obtenir des interfaces d’affichage de données et de pagination beaucoup plus flexibles.

Remarque

Ce tutoriel se concentre exclusivement sur la pagination. Dans le tutoriel suivant, nous allons attirer l’attention sur l’ajout de fonctionnalités de tri.

Étape 1 : Ajout des pages web du didacticiel de pagination et de tri

Avant de commencer ce didacticiel, nous allons commencer par prendre un moment pour ajouter les pages ASP.NET dont nous aurons besoin pour ce didacticiel et la suivante. Commencez par créer un dossier dans le projet nommé PagingSortingDataListRepeater. Ensuite, ajoutez les cinq pages ASP.NET suivantes à ce dossier, avec toutes ces pages configurées pour utiliser la page Site.mastermaître :

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

Figure 1 : Créer un PagingSortingDataListRepeater dossier et ajouter le didacticiel ASP.NET pages

Ensuite, ouvrez la Default.aspx page et faites glisser le SectionLevelTutorialListing.ascx contrôle utilisateur du UserControls dossier sur l’aire de conception. Ce contrôle utilisateur, que nous avons créé dans le didacticiel De navigation des pages maîtres et du site, énumère la carte de site et affiche ces didacticiels dans la section active dans une liste à puces.

Figure 2 : Ajouter le contrôle utilisateur à SectionLevelTutorialListing.ascx (Cliquez pour afficher l’image Default.aspxde taille complète)

Pour que la liste à puces affiche les didacticiels de pagination et de tri que nous allons créer, nous devons les ajouter à la carte de site. Ouvrez le Web.sitemap fichier et ajoutez le balisage suivant après la modification et la suppression avec le balisage de nœud de carte de 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>

Figure 3 : Mettre à jour la carte de site pour inclure les nouvelles pages de ASP.NET

Révision de la pagination

Dans les didacticiels précédents, nous avons vu comment parcourir les données dans les contrôles GridView, DetailsView et FormView. Ces trois contrôles offrent une forme simple de pagination appelée pagination par défaut qui peut être implémentée en vérifiant simplement l’option Activer la pagination dans la balise active du contrôle. Avec la pagination par défaut, chaque fois qu’une page de données est demandée sur la première visite de page ou lorsque l’utilisateur accède à une autre page de données, le contrôle GridView, DetailsView ou FormView demande à nouveau toutes les données de ObjectDataSource. Il supprime ensuite l’ensemble particulier d’enregistrements à afficher en fonction de l’index de page demandé et du nombre d’enregistrements à afficher par page. Nous avons abordé en détail la pagination par défaut dans le didacticiel sur la pagination et le tri des données de rapport.

Étant donné que la pagination par défaut demande tous les enregistrements pour chaque page, elle n’est pas pratique lors de la pagination par suffisamment grande quantité de données. Par exemple, imaginez la pagination à 50 000 enregistrements avec une taille de page de 10. Chaque fois que l’utilisateur passe à une nouvelle page, tous les 50 000 enregistrements doivent être récupérés à partir de la base de données, même si seulement dix d’entre eux sont affichés.

La pagination personnalisée résout les problèmes de performances de la pagination par défaut en saisissant uniquement le sous-ensemble précis d’enregistrements à afficher sur la page demandée. Lors de l’implémentation de la pagination personnalisée, nous devons écrire la requête SQL qui retourne efficacement le jeu d’enregistrements correct. Nous avons vu comment créer une telle requête à l’aide du nouveau ROW_NUMBER() mot clé de SQL Server 2005 dans le didacticiel Sur la pagination efficace via de grandes quantités de données .

Pour implémenter la pagination par défaut dans les contrôles DataList ou Repeater, nous pouvons utiliser la PagedDataSource classe comme wrapper autour du ProductsDataTable contenu en cours de pagination. La PagedDataSource classe a une DataSource propriété qui peut être affectée à n’importe quel objet énumérable et PageSize propriétés CurrentPageIndex qui indiquent le nombre d’enregistrements à afficher par page et l’index de page actif. Une fois ces propriétés définies, vous PagedDataSource pouvez l’utiliser comme source de données de n’importe quel contrôle Web de données. Le PagedDataSourcesous-ensemble approprié d’enregistrements de son interneDataSource, lorsqu’il est énuméré, ne retourne que le sous-ensemble approprié d’enregistrements basés sur les propriétés et PageSize les CurrentPageIndex propriétés. La figure 4 illustre les fonctionnalités de la PagedDataSource classe.

Figure 4 : PagedDataSource Wraps an Enumerable Object with a Pageable Interface

L’objet PagedDataSource peut être créé et configuré directement à partir de la couche logique métier et lié à un DataList ou Repeater via un ObjectDataSource, ou peut être créé et configuré directement dans la classe code-behind de la page ASP.NET. Si cette dernière approche est utilisée, nous devons renoncer à l’utilisation de ObjectDataSource et lier les données paginées à la liste de données ou au répéteur par programmation.

L’objet PagedDataSource a également des propriétés pour prendre en charge la pagination personnalisée. Toutefois, nous pouvons contourner l’utilisation d’un PagedDataSource pour la pagination personnalisée, car nous avons déjà des méthodes BLL dans la ProductsBLL classe conçues pour la pagination personnalisée qui retournent les enregistrements précis à afficher.

Dans ce tutoriel, nous allons examiner l’implémentation de la pagination par défaut dans une DataList en ajoutant une nouvelle méthode à la ProductsBLL classe qui retourne un objet configuré PagedDataSource de manière appropriée. Dans le tutoriel suivant, nous allons voir comment utiliser la pagination personnalisée.

Étape 2 : Ajout d’une méthode de pagination par défaut dans la couche logique métier

La ProductsBLL classe a actuellement une méthode pour renvoyer toutes les informations GetProducts() sur le produit et une pour renvoyer un sous-ensemble particulier de produits à un index GetProductsPaged(startRowIndex, maximumRows)de départ. Avec la pagination par défaut, les contrôles GridView, DetailsView et FormView utilisent toutes la GetProducts() méthode pour récupérer tous les produits, mais utilisez ensuite un PagedDataSource élément interne pour afficher uniquement le sous-ensemble correct d’enregistrements. Pour répliquer cette fonctionnalité avec les contrôles DataList et Repeater, nous pouvons créer une nouvelle méthode dans la BLL qui imite ce comportement.

Ajoutez une méthode à la ProductsBLL classe nommée GetProductsAsPagedDataSource qui prend deux paramètres d’entrée entiers :

• pageIndex index de la page à afficher, indexé à zéro et
• pageSize nombre d’enregistrements à afficher par page.

GetProductsAsPagedDataSource commence par récupérer tous les enregistrements à partir de GetProducts(). Il crée ensuite un PagedDataSource objet, en définissant ses propriétés et CurrentPageIndex ses PageSize propriétés sur les valeurs des paramètres et pageIndex du passagepageSize. La méthode conclut en retournant ce paramètre configuré 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;
}

Étape 3 : affichage des informations de produit dans une liste de données à l’aide de la pagination par défaut

Avec la GetProductsAsPagedDataSource méthode ajoutée à la ProductsBLL classe, nous pouvons maintenant créer une dataList ou un répéteur qui fournit la pagination par défaut. Commencez par ouvrir la Paging.aspx page dans le PagingSortingDataListRepeater dossier et faites glisser une DataList à partir de la boîte à outils sur le Concepteur, en définissant la propriété IDDataList sur ProductsDefaultPaging . À partir de la balise active dataList, créez un ObjetDataSource nommé ProductsDefaultPagingDataSource et configurez-le afin qu’il récupère des données à l’aide de la GetProductsAsPagedDataSource méthode.

Figure 5 : Créer un ObjectDataSource et le configurer pour utiliser la GetProductsAsPagedDataSource() méthode (Click pour afficher l’image de taille complète)

Définissez les listes déroulantes dans les onglets UPDATE, INSERT et DELETE sur (Aucun).

Figure 6 : Définir les listes déroulantes dans les onglets UPDATE, INSERT et DELETE sur (Aucun) (Cliquez pour afficher l’image de taille complète)

Étant donné que la GetProductsAsPagedDataSource méthode attend deux paramètres d’entrée, l’Assistant nous invite à entrer la source de ces valeurs de paramètres.

Les valeurs d’index de page et de taille de page doivent être mémorisées dans les postbacks. Ils peuvent être stockés dans l’état d’affichage, conservés dans la chaîne de requête, stockés dans des variables de session ou mémorisés à l’aide d’une autre technique. Pour ce didacticiel, nous allons utiliser la chaîne de requête, qui présente l’avantage de permettre à une page particulière de données d’être marquée par signet.

En particulier, utilisez les champs querystring pageIndex et pageSize pour les pageIndex paramètres, pageSize respectivement (voir la figure 7). Prenez un moment pour définir les valeurs par défaut de ces paramètres, car les valeurs de chaîne de requête ne seront pas présentes lorsqu’un utilisateur visite cette page pour la première fois. Pour pageIndex, définissez la valeur par défaut sur 0 (qui affiche la première page de données) et pageSize la valeur par défaut 4.

Figure 7 : Utiliser QueryString comme source pour les paramètres et pageIndex les pageSize paramètres (cliquez pour afficher l’image de taille complète)

Après avoir configuré ObjectDataSource, Visual Studio crée automatiquement un ItemTemplate objet DataList. Personnalisez ce ItemTemplate qui permet d’afficher uniquement le nom, la catégorie et le fournisseur du produit. Définissez également la propriété DataList sur RepeatColumns 2, son Width sur 100 %, et son ItemStyle s Width sur 50 %. Ces paramètres de largeur fournissent un espacement égal pour les deux colonnes.

Après avoir apporté ces modifications, le balisage DataList et ObjectDataSource doit ressembler à ce qui suit :

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

Remarque

Étant donné que nous n’effectuons aucune fonctionnalité de mise à jour ou de suppression dans ce didacticiel, vous pouvez désactiver l’état d’affichage de DataList pour réduire la taille de page rendue.

Lors de la visite initiale de cette page via un navigateur, ni les pageIndex paramètres de chaîne de requête ne pageSize sont fournis. Par conséquent, les valeurs par défaut de 0 et 4 sont utilisées. Comme le montre la figure 8, cela entraîne un DataList qui affiche les quatre premiers produits.

Figure 8 : Les quatre premiers produits sont répertoriés (cliquez pour afficher l’image de taille complète)

Sans interface de pagination, il n’existe actuellement aucun moyen simple pour un utilisateur d’accéder à la deuxième page de données. Nous allons créer une interface de pagination à l’étape 4. Pour l’instant, toutefois, la pagination ne peut être effectuée qu’en spécifiant directement les critères de pagination dans la chaîne de requête. Par exemple, pour afficher la deuxième page, modifiez l’URL de la barre Paging.aspx d’adresses du navigateur vers Paging.aspx?pageIndex=2 et appuyez sur Entrée. Cela entraîne l’affichage de la deuxième page de données (voir la figure 9).

Figure 9 : La deuxième page de données s’affiche (cliquez pour afficher l’image de taille complète)

Étape 4 : Création de l’interface de pagination

Il existe différentes interfaces de pagination qui peuvent être implémentées. Les contrôles GridView, DetailsView et FormView fournissent quatre interfaces différentes parmi lesquelles choisir :

• Ensuite, les utilisateurs précédents peuvent déplacer une page à la fois vers la page suivante ou précédente.
• Ensuite, Précédent, Premier, Dernier en plus des boutons Suivant et Précédent, cette interface inclut les boutons First et Last pour passer à la première ou la dernière page.
• Numérique répertorie les numéros de page dans l’interface de pagination, ce qui permet à un utilisateur de passer rapidement à une page particulière.
• Numérique, Premier, Dernier en plus des numéros de page numériques, inclut des boutons pour passer à la première ou la dernière page.

Pour DataList et Repeater, nous sommes chargés de décider d’une interface de pagination et de l’implémenter. Cela implique la création des contrôles Web nécessaires dans la page et l’affichage de la page demandée lorsqu’un bouton d’interface de pagination particulier est cliqué. En outre, certains contrôles d’interface de pagination doivent être désactivés. Par exemple, lors de l’affichage de la première page de données à l’aide de l’interface Suivant, Précédent, First, Last, les boutons First et Previous sont désactivés.

Pour ce tutoriel, nous allons utiliser l’interface Suivante, Précédente, Première, Dernière interface. Ajoutez quatre contrôles Web Button à la page et définissez leurs ID s sur FirstPage, PrevPage, NextPageet LastPage. Définissez les Text propriétés sur << First, < Prev, Next >et 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 >>" />

Ensuite, créez un gestionnaire d’événements Click pour chacun de ces boutons. Dans un instant, nous allons ajouter le code nécessaire pour afficher la page demandée.

Mémorisation du nombre total d’enregistrements paginés

Quelle que soit l’interface de pagination sélectionnée, nous devons calculer et mémoriser le nombre total d’enregistrements paginés. Le nombre total de lignes (conjointement avec la taille de page) détermine le nombre total de pages de données mises à jour, ce qui détermine les contrôles d’interface de pagination qui sont ajoutés ou activés. Dans la section Suivante, Previous, First, Last interface que nous créons, le nombre de pages est utilisé de deux manières :

• Pour déterminer si nous consultons la dernière page, auquel cas les boutons Suivant et Dernier sont désactivés.
• Si l’utilisateur clique sur le dernier bouton, nous devons les faire passer à la dernière page, dont l’index est un inférieur au nombre de pages.

Le nombre de pages est calculé en tant que plafond du nombre total de lignes divisé par la taille de page. Par exemple, si nous paginons jusqu’à 79 enregistrements avec quatre enregistrements par page, le nombre de pages est de 20 (le plafond de 79 / 4). Si nous utilisons l’interface de pagination numérique, ces informations nous indiquent le nombre de boutons de page numériques à afficher ; si notre interface de pagination inclut des boutons Suivant ou Dernier, le nombre de pages est utilisé pour déterminer quand désactiver les boutons Suivant ou Dernier.

Si l’interface de pagination inclut un bouton Last, il est impératif que le nombre total d’enregistrements en cours de pagination soit mémorisé dans les postbacks afin que lorsque le bouton Dernier soit cliqué, nous pouvons déterminer le dernier index de page. Pour faciliter cette opération, créez une TotalRowCount propriété dans la classe code-behind de la page ASP.NET qui conserve sa valeur pour afficher l’état :

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

En plus de TotalRowCount, prenez une minute pour créer des propriétés au niveau de la page en lecture seule pour accéder facilement à l’index de page, à la taille de page et au nombre de pages :

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

Détermination du nombre total d’enregistrements paginés

L’objet PagedDataSource retourné par la méthode ObjectDataSource Select() contient tous les enregistrements de produit, même si seul un sous-ensemble d’entre eux est affiché dans DataList. La PagedDataSource propriétéCount retourne uniquement le nombre d’éléments qui seront affichés dans DataList ; la DataSourceCount propriété retourne le nombre total d’éléments dans le PagedDataSourcefichier . Par conséquent, nous devons affecter la propriété ASP.NET page s TotalRowCount la valeur de la PagedDataSource propriété s DataSourceCount .

Pour ce faire, créez un gestionnaire d’événements pour l’événement ObjectDataSource Selected . Dans le Selected gestionnaire d’événements, nous avons accès à la valeur de retour de la méthode ObjectDataSource Select() dans ce cas, le 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;
}

Affichage de la page demandée des données

Lorsque l’utilisateur clique sur l’un des boutons de l’interface de pagination, nous devons afficher la page demandée des données. Étant donné que les paramètres de pagination sont spécifiés via la chaîne de requête, pour afficher la page demandée des données à Response.Redirect(url) utiliser pour que le navigateur de l’utilisateur demande à nouveau la Paging.aspx page avec les paramètres de pagination appropriés. Par exemple, pour afficher la deuxième page de données, nous redirigerions l’utilisateur vers Paging.aspx?pageIndex=1.

Pour faciliter cette opération, créez une RedirectUser(sendUserToPageIndex) méthode qui redirige l’utilisateur vers Paging.aspx?pageIndex=sendUserToPageIndex. Ensuite, appelez cette méthode à partir des quatre gestionnaires d’événements Button Click . Dans le FirstPageClick gestionnaire d’événements, appelez RedirectUser(0), pour les envoyer à la première page ; dans le PrevPageClick gestionnaire d’événements, utilisez PageIndex - 1 comme index de page ; et ainsi de suite.

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

Une fois les Click gestionnaires d’événements terminés, les enregistrements de DataList peuvent être paginés en cliquant sur les boutons. Prenez un moment pour l’essayer !

Désactivation des contrôles d’interface de pagination

Actuellement, les quatre boutons sont activés indépendamment de la page en cours d’affichage. Toutefois, nous voulons désactiver les boutons First et Previous lors de l’affichage de la première page de données, ainsi que les boutons Suivant et Dernier lors de l’affichage de la dernière page. L’objet PagedDataSource retourné par la méthode ObjectDataSource Select() a des propriétés IsFirstPage et IsLastPage que nous pouvons examiner pour déterminer si nous examinons la première ou la dernière page de données.

Ajoutez ce qui suit au gestionnaire d’événements 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;

Avec cet ajout, les boutons First et Previous seront désactivés lors de l’affichage de la première page, tandis que les boutons Suivant et Dernier seront désactivés lors de l’affichage de la dernière page.

Complétons l’interface de pagination en informant l’utilisateur de la page qu’il consulte actuellement et du nombre total de pages. Ajoutez un contrôle Label Web à la page et définissez sa ID propriété CurrentPageNumbersur . Définissez sa Text propriété dans le gestionnaire d’événements Selected de ObjectDataSource afin qu’elle inclut la page active affichée (PageIndex + 1) et le nombre total de pages (PageCount).

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

La figure 10 montre Paging.aspx la première visite. Étant donné que la chaîne de requête est vide, la liste de données affiche par défaut les quatre premiers produits ; Les boutons First et Previous sont désactivés. Cliquer sur Suivant affiche les quatre enregistrements suivants (voir la figure 11) ; Les boutons First et Previous sont désormais activés.

Figure 10 : La première page de données s’affiche (cliquez pour afficher l’image de taille complète)

Figure 11 : La deuxième page de données s’affiche (cliquez pour afficher l’image de taille complète)

Remarque

L’interface de pagination peut être améliorée en permettant à l’utilisateur de spécifier le nombre de pages à afficher par page. Par exemple, un DropDownList peut être ajouté à des options de taille de page de référencement telles que 5, 10, 25, 50 et Tous. Lors de la sélection d’une taille de page, l’utilisateur doit être redirigé vers Paging.aspx?pageIndex=0&pageSize=selectedPageSize. Je laisse l’implémentation de cette amélioration en tant qu’exercice pour le lecteur.

Utilisation de la pagination personnalisée

Les pages DataList via ses données à l’aide de la technique de pagination par défaut inefficace. Lors de la pagination par suffisamment de grandes quantités de données, il est impératif que la pagination personnalisée soit utilisée. Bien que les détails de l’implémentation diffèrent légèrement, les concepts derrière l’implémentation de la pagination personnalisée dans une DataList sont identiques à ceux de la pagination par défaut. Avec la pagination personnalisée, utilisez la ProductBLL méthode s de GetProductsPaged classe (au lieu de GetProductsAsPagedDataSource). Comme indiqué dans le didacticiel Sur la pagination efficace des grandes quantités de données , GetProductsPaged vous devez passer l’index de ligne de début et le nombre maximal de lignes à retourner. Ces paramètres peuvent être conservés via la chaîne de requête comme les pageIndexpageSize paramètres utilisés dans la pagination par défaut.

Étant donné qu’il n’existe aucune PagedDataSource pagination personnalisée, d’autres techniques doivent être utilisées pour déterminer le nombre total d’enregistrements paginés et déterminer si nous affichons la première ou la dernière page de données. La TotalNumberOfProducts() méthode de la ProductsBLL classe retourne le nombre total de produits paginés. Pour déterminer si la première page de données est en cours d’affichage, examinez l’index de ligne de début s’il est égal à zéro, puis la première page est en cours d’affichage. La dernière page est affichée si l’index de ligne de début et les lignes maximales à retourner sont supérieures ou égales au nombre total d’enregistrements paginés.

Nous allons explorer l’implémentation de la pagination personnalisée plus en détail dans le tutoriel suivant.

Résumé

Bien que les contrôles DataList et Repeater n’offrent pas la prise en charge de la pagination prête à l’emploi trouvée dans les contrôles GridView, DetailsView et FormView, ces fonctionnalités peuvent être ajoutées avec un effort minimal. Le moyen le plus simple d’implémenter la pagination par défaut consiste à encapsuler l’ensemble des produits au sein d’une PagedDataSource base de données, puis à lier la PagedDataSource liste de données ou le répéteur. Dans ce tutoriel, nous avons ajouté la GetProductsAsPagedDataSource méthode à la ProductsBLL classe pour retourner le PagedDataSource. La ProductsBLL classe contient déjà les méthodes nécessaires pour la pagination GetProductsPaged personnalisée et TotalNumberOfProducts.

En plus de récupérer l’ensemble précis d’enregistrements à afficher pour la pagination personnalisée ou tous les enregistrements d’une PagedDataSource pagination par défaut, nous devons également ajouter manuellement l’interface de pagination. Pour ce tutoriel, nous avons créé une interface Suivante, Précédente, First, Last avec quatre contrôles Web Button. En outre, un contrôle Label affichant le numéro de page actuel et le nombre total de pages ont été ajoutés.

Dans le tutoriel suivant, nous allons voir comment ajouter la prise en charge du tri à DataList et Repeater. Nous allons également voir comment créer une DataList qui peut être paginée et triée (avec des exemples utilisant la pagination par défaut et personnalisée).

Bonne programmation !

À propos de l’auteur

Scott Mitchell, auteur de sept livres ASP/ASP.NET et fondateur de 4GuysFromRolla.com, travaille avec les technologies Web Microsoft depuis 1998. Scott travaille en tant que consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 en 24 heures. On peut le joindre à mitchell@4GuysFromRolla.com.

Merci spécial à

Cette série de tutoriels a été examinée par de nombreux réviseurs utiles. Les réviseurs principaux de ce tutoriel étaient Liz Shulok, Ken Pespisa et Bernadette Leigh. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com.

Prochain