Mise en cache de données avec ObjectDataSource (C#)

par Scott Mitchell

Télécharger le PDF

La mise en cache peut faire la différence entre une application web lente et une application web rapide. Ce tutoriel est le premier des quatre qui examinent en détail la mise en cache dans ASP.NET. Découvrez les concepts clés de la mise en cache et comment appliquer la mise en cache à la couche de présentation via le contrôle ObjectDataSource.

Introduction

En informatique, la mise en cache est le processus consistant à prendre des données ou des informations coûteuses à obtenir et à stocker une copie de ces données dans un emplacement plus rapide d’accès. Pour les applications pilotées par les données, les requêtes volumineuses et complexes consomment généralement la majorité du temps d’exécution de l’application. Ces performances d’application peuvent souvent être améliorées en stockant les résultats des requêtes de base de données coûteuses dans la mémoire de l’application.

ASP.NET 2.0 offre diverses options de mise en cache. Une page web entière ou un balisage rendu contrôle utilisateur peut être mis en cache via la mise en cache de sortie. Les contrôles ObjectDataSource et SqlDataSource fournissent également des fonctionnalités de mise en cache, ce qui permet aux données d’être mises en cache au niveau du contrôle. Et ASP.NET cache de données fournit une API de mise en cache riche qui permet aux développeurs de pages de mettre en cache des objets par programmation. Dans ce tutoriel et les trois suivants, nous allons examiner l’utilisation des fonctionnalités de mise en cache d’ObjectDataSource, ainsi que du cache de données. Nous allons également découvrir comment mettre en cache des données à l’échelle de l’application au démarrage et comment maintenir les données mises en cache à jour grâce à l’utilisation de dépendances de cache SQL. Ces tutoriels n’explorent pas la mise en cache de sortie. Pour obtenir un aperçu détaillé de la mise en cache de sortie, consultez Mise en cache de sortie dans ASP.NET 2.0.

La mise en cache peut être appliquée à n’importe quel endroit de l’architecture, de la couche d’accès aux données jusqu’à la couche présentation. Dans ce tutoriel, nous allons examiner l’application de la mise en cache à la couche de présentation via le contrôle ObjectDataSource. Dans le tutoriel suivant, nous allons examiner la mise en cache des données au niveau de la couche logique métier.

Concepts de mise en cache clés

La mise en cache peut considérablement améliorer les performances globales et la scalabilité d’une application en utilisant des données coûteuses à générer et en stockant une copie de celle-ci dans un emplacement accessible plus efficacement. Étant donné que le cache ne contient qu’une copie des données sous-jacentes réelles, il peut devenir obsolète ou obsolète si les données sous-jacentes changent. Pour lutter contre ce problème, un développeur de pages peut indiquer les critères selon lesquels l’élément de cache sera supprimé du cache, à l’aide de l’une des options suivantes :

• Critères basés sur le temps un élément peut être ajouté au cache pour une durée absolue ou glissante. Par exemple, un développeur de pages peut indiquer une durée de, par exemple, 60 secondes. Avec une durée absolue, l’élément mis en cache est supprimé 60 secondes après son ajout au cache, quelle que soit la fréquence d’accès. Avec une durée glissante, l’élément mis en cache est supprimé 60 secondes après le dernier accès.
• Critères basés sur les dépendances qu’une dépendance peut être associée à un élément lorsqu’elle est ajoutée au cache. Lorsque la dépendance de l’élément change, elle est supprimée du cache. La dépendance peut être un fichier, un autre élément de cache ou une combinaison des deux. ASP.NET 2.0 autorise également les dépendances de cache SQL, ce qui permet aux développeurs d’ajouter un élément au cache et de le faire supprimer lorsque les données de base de données sous-jacentes changent. Nous allons examiner les dépendances du cache SQL dans le tutoriel Utilisation des dépendances du cache SQL .

Quels que soient les critères d’éviction spécifiés, un élément du cache peut être récupéré avant que les critères basés sur le temps ou basés sur les dépendances soient remplis. Si le cache a atteint sa capacité, les éléments existants doivent être supprimés avant de pouvoir en ajouter de nouveaux. Par conséquent, lorsque vous utilisez des données mises en cache par programmation, il est essentiel de toujours supposer que les données mises en cache ne sont pas présentes. Nous allons examiner le modèle à utiliser lors de l’accès aux données à partir du cache par programmation dans notre tutoriel suivant, Mise en cache des données dans l’architecture.

La mise en cache offre un moyen économique de presser plus de performances à partir d’une application. Comme l’explique Steven Smith dans son article ASP.NET Caching : Techniques and Best Practices :

La mise en cache peut être un bon moyen d’obtenir des performances suffisantes sans nécessiter beaucoup de temps et d’analyse. La mémoire est bon marché. Par conséquent, si vous pouvez obtenir les performances dont vous avez besoin en mettant en cache la sortie pendant 30 secondes au lieu de passer un jour ou une semaine à essayer d’optimiser votre code ou base de données, utilisez la solution de mise en cache (en supposant que les données anciennes de 30 secondes sont correctes) et passez à autre chose. Finalement, une conception médiocre vous rattrapera probablement, donc bien sûr, vous devriez essayer de concevoir vos applications correctement. Mais si vous avez simplement besoin d’obtenir suffisamment de performances aujourd’hui, la mise en cache peut être une excellente [approche], vous permettant de refactoriser votre application à une date ultérieure lorsque vous avez le temps de le faire.

Bien que la mise en cache puisse apporter des améliorations appréciables en matière de performances, elle n’est pas applicable dans toutes les situations, par exemple avec les applications qui utilisent des données en temps réel, fréquemment mises à jour, ou lorsque même des données obsolètes à courte durée de vie sont inacceptables. Toutefois, pour la majorité des applications, la mise en cache doit être utilisée. Pour plus d’informations sur la mise en cache dans ASP.NET 2.0, reportez-vous à la section Mise en cache pour les performances des didacticiels de démarrage rapide ASP.NET 2.0.

Étape 1 : Création des pages web de mise en cache

Avant de commencer notre exploration des fonctionnalités de mise en cache d’ObjectDataSource, prenons d’abord un moment pour créer les pages ASP.NET dans notre projet de site web dont nous aurons besoin pour ce didacticiel et les trois suivants. Commencez par ajouter un nouveau dossier nommé Caching. Ensuite, ajoutez les pages ASP.NET suivantes à ce dossier, en veillant à associer chaque page à la Site.master page master :

• Default.aspx
• ObjectDataSource.aspx
• FromTheArchitecture.aspx
• AtApplicationStartup.aspx
• SqlCacheDependencies.aspx

Figure 1 : Ajouter les pages ASP.NET pour les didacticiels Caching-Related

Comme dans les autres dossiers, Default.aspx le Caching dossier répertorie les didacticiels dans sa section. Rappelez-vous que le SectionLevelTutorialListing.ascx contrôle utilisateur fournit cette fonctionnalité. Par conséquent, ajoutez ce contrôle utilisateur à Default.aspx en le faisant glisser du Explorateur de solutions vers le mode Création de la page.

Figure 2 : Figure 2 : Ajouter le SectionLevelTutorialListing.ascx contrôle utilisateur à Default.aspx (Cliquer pour afficher l’image en taille réelle)

Enfin, ajoutez ces pages en tant qu’entrées au Web.sitemap fichier. Plus précisément, ajoutez le balisage suivant après l’utilisation des données binaires <siteMapNode>:

<siteMapNode title="Caching" url="~/Caching/Default.aspx" 
    description="Learn how to use the caching features of ASP.NET 2.0.">
    <siteMapNode url="~/Caching/ObjectDataSource.aspx" 
        title="ObjectDataSource Caching" 
        description="Explore how to cache data directly from the 
            ObjectDataSource control." />
    <siteMapNode url="~/Caching/FromTheArchitecture.aspx" 
        title="Caching in the Architecture" 
        description="See how to cache data from within the 
            architecture." />
    <siteMapNode url="~/Caching/AtApplicationStartup.aspx" 
        title="Caching Data at Application Startup" 
        description="Learn how to cache expensive or infrequently-changing 
            queries at the start of the application." />
    <siteMapNode url="~/Caching/SqlCacheDependencies.aspx" 
        title="Using SQL Cache Dependencies" 
        description="Examine how to have data automatically expire from the 
            cache when its underlying database data is modified." />
</siteMapNode>

Après la mise à jour Web.sitemap, prenez un moment pour afficher le site web des tutoriels via un navigateur. Le menu de gauche inclut désormais des éléments pour les didacticiels de mise en cache.

Figure 3 : Le plan de site inclut désormais des entrées pour les didacticiels de mise en cache

Étape 2 : Affichage d’une liste de produits dans une page web

Ce tutoriel explique comment utiliser les fonctionnalités de mise en cache intégrées du contrôle ObjectDataSource. Toutefois, avant de pouvoir examiner ces fonctionnalités, nous avons d’abord besoin d’une page à partir de laquelle travailler. Créons une page web qui utilise un GridView pour répertorier les informations de produit récupérées par un ObjectDataSource à partir de la ProductsBLL classe .

Commencez par ouvrir la ObjectDataSource.aspx page dans le Caching dossier . Faites glisser un GridView de la boîte à outils sur le Designer, définissez sa ID propriété Productssur , puis, à partir de sa balise active, choisissez de le lier à un nouveau contrôle ObjectDataSource nommé ProductsDataSource. Configurez ObjectDataSource pour qu’il fonctionne avec la ProductsBLL classe .

Figure 4 : Configurer ObjectDataSource pour utiliser la ProductsBLL classe (cliquer pour afficher l’image en taille réelle)

Pour cette page, nous allons créer un GridView modifiable afin que nous puissions examiner ce qui se passe lorsque les données mises en cache dans ObjectDataSource sont modifiées via l’interface de GridView. Laissez la liste déroulante de l’onglet SELECT définie sur sa valeur par défaut, GetProducts(), mais remplacez l’élément sélectionné sous l’onglet UPDATE par la UpdateProduct surcharge qui accepte productName, unitPriceet productID comme paramètres d’entrée.

Figure 5 : Définissez la liste des Drop-Down de l’onglet UPDATE sur la surcharge appropriée UpdateProduct (cliquez pour afficher l’image en taille réelle)

Enfin, définissez les listes déroulantes dans les onglets INSERT et DELETE sur (Aucun), puis cliquez sur Terminer. À l’issue de l’Assistant Configuration de la source de données, Visual Studio affecte à la propriété ObjectDataSource OldValuesParameterFormatString la valeur original_{0}. Comme indiqué dans le didacticiel Vue d’ensemble de l’insertion, de la mise à jour et de la suppression de données, cette propriété doit être supprimée de la syntaxe déclarative ou revenir à sa valeur par défaut, {0}, pour que notre workflow de mise à jour se poursuive sans erreur.

En outre, à la fin de l’Assistant, Visual Studio ajoute un champ à GridView pour chacun des champs de données de produit. Supprimez tous les objets sauf , ProductNameCategoryNameet UnitPrice BoundFields. Ensuite, mettez à jour les HeaderText propriétés de chacun de ces objets BoundFields sur Product, Category et Price, respectivement. Étant donné que le ProductName champ est obligatoire, convertissez l’objet BoundField en templateField et ajoutez un RequiredFieldValidator au EditItemTemplate. De même, convertissez l’objet UnitPrice BoundField en templateField et ajoutez un CompareValidator pour vous assurer que la valeur entrée par l’utilisateur est une valeur monétaire valide supérieure ou égale à zéro. En plus de ces modifications, n’hésitez pas à effectuer des modifications esthétiques, telles que l’alignement à droite de la UnitPrice valeur ou la spécification de la mise en forme du UnitPrice texte dans ses interfaces de lecture seule et d’édition.

Rendez gridView modifiable en cochant la case Activer la modification dans la balise active de GridView. Vous case activée également les cases à cocher Activer la pagination et Activer le tri.

Notes

Vous avez besoin d’un examen de la façon de personnaliser l’interface d’édition de GridView ? Si c’est le cas, reportez-vous au didacticiel Personnalisation de l’interface de modification des données .

Figure 6 : Activer la prise en charge de GridView pour l’édition, le tri et la pagination (cliquer pour afficher l’image en taille réelle)

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

<asp:GridView ID="Products" runat="server" AutoGenerateColumns="False" 
    DataKeyNames="ProductID" DataSourceID="ProductsDataSource" 
    AllowPaging="True" AllowSorting="True">
    <Columns>
        <asp:CommandField ShowEditButton="True" />
        <asp:TemplateField HeaderText="Product" SortExpression="ProductName">
            <EditItemTemplate>
                <asp:TextBox ID="ProductName" runat="server" 
                    Text='<%# Bind("ProductName") %>'></asp:TextBox>
                <asp:RequiredFieldValidator 
                    ID="RequiredFieldValidator1" Display="Dynamic" 
                    ControlToValidate="ProductName" SetFocusOnError="True"
                    ErrorMessage="You must provide a name for the product."
                    runat="server">*</asp:RequiredFieldValidator>
            </EditItemTemplate>
            <ItemTemplate>
                <asp:Label ID="Label2" runat="server" 
                    Text='<%# Bind("ProductName") %>'></asp:Label>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:BoundField DataField="CategoryName" HeaderText="Category" 
            ReadOnly="True" SortExpression="CategoryName" />
        <asp:TemplateField HeaderText="Price" SortExpression="UnitPrice">
            <EditItemTemplate>
                $<asp:TextBox ID="UnitPrice" runat="server" Columns="8" 
                    Text='<%# Bind("UnitPrice", "{0:N2}") %>'></asp:TextBox>
                <asp:CompareValidator ID="CompareValidator1"
                    ControlToValidate="UnitPrice" Display="Dynamic" 
                    ErrorMessage="You must enter a valid currency value with no 
                        currency symbols. Also, the value must be greater than 
                        or equal to zero."
                    Operator="GreaterThanEqual" SetFocusOnError="True" 
                    Type="Currency" runat="server" 
                    ValueToCompare="0">*</asp:CompareValidator>
            </EditItemTemplate>
            <ItemStyle HorizontalAlign="Right" />
            <ItemTemplate>
                <asp:Label ID="Label1" runat="server" 
                    Text='<%# Bind("UnitPrice", "{0:c}") %>' />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="ProductsDataSource" runat="server"
    OldValuesParameterFormatString="{0}" SelectMethod="GetProducts" 
    TypeName="ProductsBLL" UpdateMethod="UpdateProduct">
    <UpdateParameters>
        <asp:Parameter Name="productName" Type="String" />
        <asp:Parameter Name="unitPrice" Type="Decimal" />
        <asp:Parameter Name="productID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

Comme le montre la figure 7, le GridView modifiable répertorie le nom, la catégorie et le prix de chacun des produits de la base de données. Prenez un moment pour tester les fonctionnalités de la page pour trier les résultats, les parcourir et modifier un enregistrement.

Figure 7 : Le nom, la catégorie et le prix de chaque produit sont répertoriés dans un GridView triable, paginable et modifiable (cliquez pour afficher l’image en taille réelle)

Étape 3 : Examen du moment où objectDataSource demande des données

GridView Products récupère ses données à afficher en appelant la Select méthode de l’ObjetDataSource ProductsDataSource . Cet ObjetDataSource crée un instance de la classe de la couche de ProductsBLL logique métier et appelle sa GetProducts() méthode, qui à son tour appelle la méthode s de la couche d’accès ProductsTableAdapterGetProducts() aux données. La méthode DAL se connecte à la base de données Northwind et émet la requête configurée SELECT . Ces données sont ensuite retournées au DAL, qui les empaquette dans un NorthwindDataTable. L’objet DataTable est retourné à l’objet BLL, qui le renvoie à ObjectDataSource, qui le renvoie à GridView. GridView crée ensuite un GridViewRow objet pour chacun DataRow d’eux dans le DataTable, et chacun GridViewRow d’eux est finalement rendu dans le code HTML qui est retourné au client et affiché dans le navigateur du visiteur.

Cette séquence d’événements se produit chaque fois que GridView doit se lier à ses données sous-jacentes. Cela se produit lors de la première visite de la page, lors du déplacement d’une page de données à une autre, lors du tri de GridView ou lors de la modification des données de GridView via ses interfaces intégrées de modification ou de suppression. Si l’état d’affichage de GridView est désactivé, gridView sera également rebondi sur chaque publication. GridView peut également être explicitement rebondi sur ses données en appelant sa DataBind() méthode.

Pour apprécier pleinement la fréquence à laquelle les données sont récupérées à partir de la base de données, affichons un message indiquant quand les données sont récupérées à nouveau. Ajoutez un contrôle Label Web au-dessus de GridView nommé ODSEvents. Effacez sa Text propriété et définissez sa EnableViewState propriété sur false. Sous l’étiquette, ajoutez un contrôle Button Web et définissez sa Text propriété sur Postback .

Figure 8 : Ajouter une étiquette et un bouton à la page au-dessus du GridView (cliquer pour afficher l’image en taille réelle)

Pendant le flux de travail d’accès aux données, l’événement ObjectDataSource se Selecting déclenche avant la création de l’objet sous-jacent et l’appel de sa méthode configurée. Créez un gestionnaire d’événements pour cet événement et ajoutez le code suivant :

protected void ProductsDataSource_Selecting(object sender, 
    ObjectDataSourceSelectingEventArgs e)
{
    ODSEvents.Text = "-- Selecting event fired";
}

Chaque fois que l’ObjectDataSource effectue une demande à l’architecture pour des données, l’étiquette affiche le texte Sélection de l’événement déclenché.

Visitez cette page dans un navigateur. Lors de la première visite de la page, le texte Sélectionner l’événement déclenché s’affiche. Cliquez sur le bouton Publier et notez que le texte disparaît (en supposant que la propriété de EnableViewState GridView a la valeur true, valeur par défaut). Cela est dû au fait que, lors de la publication, le GridView est reconstruit à partir de son état d’affichage et ne se tourne donc pas vers ObjectDataSource pour ses données. Toutefois, le tri, la pagination ou la modification des données entraîne la liaison de GridView à sa source de données, et par conséquent, le texte déclenché de l’événement Selecting réapparaît.

Figure 9 : Chaque fois que l’objet GridView est rebondi vers sa source de données, la sélection de l’événement déclenché est affichée (Cliquez pour afficher l’image en taille réelle)

Figure 10 : Cliquer sur le bouton Publier entraîne la reconstruction du GridView à partir de son état d’affichage (cliquer pour afficher l’image en taille réelle)

Il peut sembler inutile de récupérer les données de la base de données chaque fois que les données sont paginées ou triées. Après tout, étant donné que nous utilisons la pagination par défaut, ObjectDataSource a récupéré tous les enregistrements lors de l’affichage de la première page. Même si GridView ne prend pas en charge le tri et la pagination, les données doivent être récupérées de la base de données chaque fois que la page est visitée pour la première fois par un utilisateur (et à chaque publication de publication, si l’état d’affichage est désactivé). Toutefois, si GridView affiche les mêmes données à tous les utilisateurs, ces demandes de base de données supplémentaires sont superflues. Pourquoi ne pas mettre en cache les résultats retournés par la GetProducts() méthode et lier gridView à ces résultats mis en cache ?

Étape 4 : Mise en cache des données à l’aide d’ObjectDataSource

En définissant simplement quelques propriétés, l’ObjetDataSource peut être configuré pour mettre automatiquement en cache ses données récupérées dans le cache de données ASP.NET. La liste suivante récapitule les propriétés liées au cache de l’ObjetDataSource :

• EnableCaching doit être défini sur true pour activer la mise en cache. Par défaut, il s’agit de false.
• CacheDuration de la durée, en secondes, pendant laquelle les données sont mises en cache. La valeur par défaut est 0. ObjectDataSource met en cache les données uniquement si EnableCaching a true la valeur et CacheDuration est définie sur une valeur supérieure à zéro.
• CacheExpirationPolicy peut être défini sur Absolute ou Sliding. Si la valeur est Absolute, l’ObjetDataSource met en cache ses données récupérées pendant CacheDuration quelques secondes ; si Sliding, les données expirent uniquement une fois qu’elles n’ont pas été consultées pendant CacheDuration quelques secondes. Par défaut, il s’agit de Absolute.
• CacheKeyDependency utilise cette propriété pour associer les entrées de cache d’ObjectDataSource à une dépendance de cache existante. Les entrées de données d’ObjectDataSource peuvent être supprimées prématurément du cache en arrivant à expiration de son associé CacheKeyDependency. Cette propriété est généralement utilisée pour associer une dépendance de cache SQL au cache d’ObjectDataSource, une rubrique que nous allons explorer dans le futur didacticiel Utilisation des dépendances du cache SQL .

Nous allons configurer ObjectDataSource ProductsDataSource pour mettre en cache ses données pendant 30 secondes à une échelle absolue. Définissez la propriété ObjectDataSource EnableCaching sur true et sa CacheDuration propriété sur 30. Laissez la CacheExpirationPolicy propriété définie sur sa valeur par défaut, Absolute.

Figure 11 : Configurer objectDataSource pour mettre en cache ses données pendant 30 secondes (cliquer pour afficher l’image en taille réelle)

Enregistrez vos modifications et revenez à cette page dans un navigateur. Le texte Sélection de l’événement déclenché s’affiche lorsque vous visitez la page pour la première fois, car initialement les données ne sont pas dans le cache. Toutefois, les publications ultérieures déclenchées en cliquant sur le bouton Publier, en triant, en paginant ou en cliquant sur les boutons Modifier ou Annuler, ne réaffichent pas le texte déclenché de l’événement Selecting. En effet, l’événement Selecting se déclenche uniquement lorsque l’ObjetDataSource obtient ses données à partir de son objet sous-jacent ; l’événement Selecting ne se déclenche pas si les données sont extraites du cache de données.

Après 30 secondes, les données sont supprimées du cache. Les données sont également supprimées du cache si les méthodes ObjectDataSource de Insert, Updateou Delete sont appelées. Par conséquent, après 30 secondes ou un clic sur le bouton Mettre à jour, le tri, la pagination ou le clic sur les boutons Modifier ou Annuler entraînent l’obtention de données par ObjectDataSource à partir de son objet sous-jacent, affichant le texte de l’événement Selecting déclenché lorsque l’événement Selecting se déclenche. Ces résultats retournés sont remis dans le cache de données.

Notes

Si vous voyez fréquemment le texte déclenché de l’événement Selecting, même si vous vous attendez à ce que ObjectDataSource fonctionne avec des données mises en cache, cela peut être dû à des contraintes de mémoire. S’il n’y a pas suffisamment de mémoire libre, les données ajoutées au cache par ObjectDataSource ont peut-être été supprimées. Si ObjectDataSource ne semble pas mettre correctement en cache les données ou ne met pas en cache uniquement les données de façon sporadique, fermez certaines applications pour libérer de la mémoire et réessayez.

La figure 12 illustre le workflow de mise en cache d’ObjectDataSource. Lorsque le texte déclenché de l’événement Sélection s’affiche à l’écran, c’est parce que les données n’étaient pas dans le cache et devaient être récupérées à partir de l’objet sous-jacent. Toutefois, lorsque ce texte est manquant, c’est parce que les données étaient disponibles à partir du cache. Lorsque les données sont retournées à partir du cache, il n’y a aucun appel à l’objet sous-jacent et, par conséquent, aucune requête de base de données n’est exécutée.

Figure 12 : ObjectDataSource stocke et récupère ses données à partir du cache de données

Chaque application ASP.NET a ses propres instance de cache de données qui sont partagés entre toutes les pages et les visiteurs. Cela signifie que les données stockées dans le cache de données par ObjectDataSource sont également partagées entre tous les utilisateurs qui visitent la page. Pour vérifier cela, ouvrez la ObjectDataSource.aspx page dans un navigateur. Lors de la première visite de la page, le texte Sélection de l’événement déclenché s’affiche (en supposant que les données ajoutées au cache par les tests précédents ont été supprimées). Ouvrez un deuxième navigateur instance et copiez et collez l’URL du premier navigateur instance au second. Dans le deuxième instance de navigateur, le texte Sélection de l’événement déclenché n’est pas affiché, car il utilise les mêmes données mises en cache que la première.

Lors de l’insertion de ses données récupérées dans le cache, ObjectDataSource utilise une valeur de clé de cache qui inclut : les valeurs de propriété CacheDuration et CacheExpirationPolicy ; le type de l’objet métier sous-jacent utilisé par ObjectDataSource, qui est spécifié via la TypeName propriété (ProductsBLL, dans cet exemple), la valeur de la SelectMethod propriété et le nom et les valeurs des paramètres de la SelectParameters collection ; ainsi que les valeurs de ses StartRowIndex propriétés et MaximumRows , qui sont utilisés lors de l’implémentation de la pagination personnalisée.

L’élaboration de la valeur de la clé de cache en combinaison de ces propriétés garantit une entrée de cache unique à mesure que ces valeurs changent. Par exemple, dans les didacticiels précédents, nous avons examiné l’utilisation de la ProductsBLL classe s GetProductsByCategoryID(categoryID), qui retourne tous les produits pour une catégorie spécifiée. Un utilisateur peut venir à la page et voir les boissons, qui a un CategoryID de 1. Si l’ObjetDataSource a mis en cache ses résultats sans tenir compte des SelectParameters valeurs, lorsqu’un autre utilisateur est venu sur la page pour afficher les condiments alors que les produits de boissons se trouvaient dans le cache, il voit les produits de boisson mis en cache plutôt que les condiments. En variant la clé de cache en fonction de ces propriétés, qui incluent les valeurs de SelectParameters, objectDataSource conserve une entrée de cache distincte pour les boissons et les condiments.

Problèmes liés aux données obsolètes

ObjectDataSource supprime automatiquement ses éléments du cache quand l’une de ses Insertméthodes , Updateou Delete est appelée. Cela permet de se protéger contre les données obsolètes en effaçant les entrées de cache lorsque les données sont modifiées via la page. Toutefois, il est possible pour un ObjectDataSource utilisant la mise en cache d’afficher toujours des données obsolètes. Dans le cas le plus simple, cela peut être dû au fait que les données changent directement dans la base de données. Peut-être qu’un administrateur de base de données a simplement exécuté un script qui modifie certains des enregistrements de la base de données.

Ce scénario pourrait également se dérouler de manière plus subtile. Alors que l’ObjectDataSource supprime ses éléments du cache quand l’une de ses méthodes de modification de données est appelée, les éléments mis en cache supprimés sont destinés à la combinaison particulière de valeurs de propriété d’ObjectDataSource (CacheDuration, TypeName, SelectMethod, etc.). Si vous avez deux ObjectDataSources qui utilisent différents SelectMethods ou SelectParameters, mais peuvent toujours mettre à jour les mêmes données, un ObjetDataSource peut mettre à jour une ligne et invalider ses propres entrées de cache, mais la ligne correspondante pour le deuxième ObjectDataSource sera toujours servie à partir du mis en cache. Je vous encourage à créer des pages pour présenter cette fonctionnalité. Créez une page qui affiche un GridView modifiable qui extrait ses données d’un ObjetDataSource qui utilise la mise en cache et qui est configuré pour obtenir des données à partir de la ProductsBLL méthode class s GetProducts() . Ajoutez un autre GridView et ObjectDataSource modifiable à cette page (ou à une autre), mais pour ce deuxième ObjectDataSource, utilisez la GetProductsByCategoryID(categoryID) méthode . Étant donné que les deux propriétés ObjectDataSources SelectMethod diffèrent, elles auront chacune leurs propres valeurs mises en cache. Si vous modifiez un produit dans une grille, la prochaine fois que vous lierez les données à l’autre grille (par pagination, tri, etc.), il servira toujours les anciennes données mises en cache et ne reflétera pas les modifications apportées à partir de l’autre grille.

En bref, utilisez uniquement les expirations basées sur le temps si vous êtes prêt à avoir le potentiel de données obsolètes, et utilisez des expirations plus courtes pour les scénarios où l’actualisation des données est importante. Si les données obsolètes ne sont pas acceptables, renoncez à la mise en cache ou utilisez des dépendances de cache SQL (en supposant qu’il s’agit de données de base de données que vous remettez en cache). Nous allons explorer les dépendances du cache SQL dans un prochain tutoriel.

Résumé

Dans ce tutoriel, nous avons examiné les fonctionnalités de mise en cache intégrées d’ObjectDataSource. En définissant simplement quelques propriétés, nous pouvons demander à ObjectDataSource de mettre en cache les résultats retournés SelectMethod par le spécifié dans le cache de données ASP.NET. Les CacheDuration propriétés et CacheExpirationPolicy indiquent la durée pendant laquelle l’élément est mis en cache et s’il s’agit d’une expiration absolue ou glissante. La CacheKeyDependency propriété associe toutes les entrées de cache d’ObjectDataSource à une dépendance de cache existante. Cela peut être utilisé pour supprimer les entrées d’ObjectDataSource du cache avant que l’expiration basée sur le temps ne soit atteinte, et est généralement utilisé avec les dépendances de cache SQL.

Étant donné que ObjectDataSource met simplement en cache ses valeurs dans le cache de données, nous pouvons répliquer la fonctionnalité intégrée d’ObjectDataSource par programme. Cela n’a pas de sens au niveau de la couche de présentation, car ObjectDataSource offre cette fonctionnalité prête à l’emploi, mais nous pouvons implémenter des fonctionnalités de mise en cache dans une couche distincte de l’architecture. Pour ce faire, nous devons répéter la même logique que celle utilisée par ObjectDataSource. Nous allons découvrir comment utiliser par programmation le cache de données à partir de l’architecture dans notre prochain tutoriel.

Bonne programmation !

En savoir plus

Pour plus d’informations sur les sujets abordés dans ce tutoriel, reportez-vous aux ressources suivantes :

• Mise en cache ASP.NET : techniques et meilleures pratiques
• Guide d’architecture de mise en cache pour les applications .NET Framework

À 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 comme consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 in 24 Heures. Il est accessible à l’adressemitchell@4GuysFromRolla.com . ou via son blog, qui peut être trouvé à l’adresse http://ScottOnWriting.NET.

Un merci spécial à

Cette série de tutoriels a été examinée par de nombreux réviseurs utiles. La réviseur principale de ce tutoriel était Teresa Murphy. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com.

Next