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

par Scott Mitchell

Télécharger le PDF

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

Présentation

Dans l'informatique, la mise en cache est le processus de stockage d'une copie de données ou d'informations coûteuses à obtenir dans un emplacement plus rapidement accessible. 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 alors ê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 une variété d’options de mise en cache. Une page web entière ou un balisage rendu par le 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 enrichie 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 les données au niveau de l’application au démarrage et comment conserver les données mises en cache à l’aide des dépendances de cache SQL. Ces didacticiels n’explorent pas la mise en cache de sortie. Pour obtenir un aperçu détaillé de la mise en cache de sortie, consultez La 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, à partir 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 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 et l’extensibilité d’une application en prenant des données coûteuses pour générer et stocker une copie de celle-ci dans un emplacement qui peut être plus efficacement accessible. Étant donné que le cache ne contient qu’une copie des données réelles, sous-jacentes, elle peut devenir obsolète ou obsolète, si les données sous-jacentes changent. Pour lutter contre cela, 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 ou l’autre des options suivantes :

• Les critères temporels d'ajout d'un élément au cache incluent une durée absolue ou une durée glissante. Par exemple, un développeur de pages peut indiquer une durée de 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 à laquelle il a été accédé. 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 : 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, qui permettent aux développeurs d’ajouter un élément au cache et de les supprimer lorsque les données de base de données sous-jacentes changent. Nous allons examiner les dépendances de cache SQL dans le didacticiel à venir à l’aide des dépendances du cache SQL .

Quel que soit le critère d’éviction spécifié, un élément dans le cache peut être collecté avant que les critères basés sur le temps ou les dépendances ne soient satisfaits. Si le cache a atteint sa capacité, les éléments existants doivent être supprimés avant de pouvoir être ajoutés. Par conséquent, lorsque vous travaillez par programme avec des données mises en cache, il est essentiel que vous supposez toujours 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 d’enlever davantage de performances à partir d’une application. Comme Steven Smith s’exprime dans son article ASP.NET Caching : Techniques et Best Practices :

La mise en cache peut être un bon moyen d’obtenir suffisamment de performances 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 votre base de données, effectuez la solution de mise en cache (en supposant que les anciennes données de 30 secondes sont ok) et passez à l’étape suivante. 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 des performances adéquates aujourd'hui, la mise en cache peut être une excellente approche qui vous permet de gagner du temps pour refactoriser votre application ultérieurement, lorsque vous serez disponible pour le faire.

Bien que la mise en cache puisse offrir des améliorations de performance appréciables, elle n'est pas applicable dans toutes les situations, par exemple avec les applications qui utilisent des données mises à jour fréquemment et en temps réel, ou là où même les données obsolètes de courte durée 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 des 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, nous allons commencer par prendre 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 suivantes. Commencez par ajouter un nouveau dossier nommé Caching. Ensuite, ajoutez les ASP.NET pages suivantes à ce dossier, en veillant à associer chaque page à la Site.master page maître :

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

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

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

Figure 2 : Ajouter le SectionLevelTutorialListing.ascx contrôle utilisateur à Default.aspx (Cliquez 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 <siteMapNode>binaires :

<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 didacticiels via un navigateur. Le menu de gauche inclut désormais des éléments pour les didacticiels de mise en cache.

Figure 3 : La carte 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. Avant de pouvoir examiner ces fonctionnalités, nous avons tout 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 depuis la boîte à outils vers le Concepteur, définissez sa propriété ID à Products, et, à partir de sa balise intelligente, 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 classe (ProductsBLL de taille complète)

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

Figure 5 : Configurer 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. Une fois l’Assistant Configuration de la source de données terminé, Visual Studio définit la propriété OldValuesParameterFormatString de l’ObjectDataSource sur original_{0}. Comme indiqué dans le didacticiel Vue d’ensemble de l’insertion, de la mise à jour et de la suppression des données, cette propriété doit être supprimée de la syntaxe déclarative ou revenir à sa valeur par défaut, {0}afin que notre flux de travail de mise à jour continue sans erreur.

En outre, à l'achèvement de l'assistant, Visual Studio ajoute un champ à GridView pour chacun des champs de données de produit. Supprimez tous les éléments sauf les ProductName, CategoryName et UnitPrice BoundFields. Ensuite, mettez à jour les propriétés HeaderText de chacun de ces BoundFields à Product, Category et Price, respectivement. Étant donné que le ProductName champ est requis, convertissez BoundField en un TemplateField et ajoutez un RequiredFieldValidator à l’objet EditItemTemplate. De même, convertissez BoundField UnitPrice en modèleField 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 toutes les modifications esthétiques, telles que l’alignement droit de la UnitPrice valeur ou la spécification de la mise en forme du UnitPrice texte dans ses interfaces de lecture seule et de modification.

Pour rendre le GridView modifiable, cochez la case Activer l'édition dans la balise intelligente du GridView. Cochez également les cases Activer la pagination et Activer le tri.

Remarque

Vous avez besoin d’une révision de la personnalisation de 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 (cliquez pour afficher l’image de taille complète)

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, 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 : Chaque nom, catégorie et prix de chaque produit est répertorié dans une grille triable, paginable, modifiable (cliquez pour afficher l’image de taille complète)

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

Products GridView récupère ses données à afficher en appelant la Select méthode de ProductsDataSource ObjectDataSource. Cet objet DataSource crée une instance de la classe de la couche de logique métier ProductsBLL et appelle sa méthode GetProducts(), qui ensuite appelle la méthode ProductsTableAdapter de la couche d'accès aux données GetProducts(). 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é à la BLL, qui la renvoie à ObjectDataSource, qui la renvoie à GridView. GridView crée ensuite un GridViewRow objet pour chacun DataRow dans DataTable, et chacun GridViewRow est rendu dans le code HTML retourné au client et affiché sur le navigateur du visiteur.

Cette séquence d’événements se produit chaque fois que GridView doit être lié à ses données sous-jacentes. Cela se produit lorsque la page est d’abord visitée, lors du passage d’une page de données à une autre, lors du tri de GridView ou lors de la modification des données de GridView par le biais de sa modification intégrée ou de sa suppression d’interfaces. Si l’état d’affichage de GridView est désactivé, GridView sera réinitialisé à chaque retour. GridView peut également être explicitement lié à ses données en appelant la méthode DataBind().

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 Web Label au-dessus du GridView nommé ODSEvents. Effacez sa Text propriété et définissez sa EnableViewState propriété sur false. Sous le libellé, ajoutez un contrôle Web Button et définissez sa Text propriété sur "Postback".

Figure 8 : Ajouter une étiquette et un bouton à la page au-dessus de GridView (cliquez pour afficher l’image de taille complète)

Pendant le flux de travail d’accès aux données, l’événement ObjectDataSource se Selecting déclenche avant que l’objet sous-jacent ne soit créé et que sa méthode configurée ne soit invoqué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 ObjectDataSource envoie une requête à l’architecture des données, l’étiquette affiche le texte déclenché par l’événement Selecting .

Visitez cette page dans un navigateur. Lorsque la page est d’abord visitée, l’événement Sélection de texte déclenché s’affiche. Cliquez sur le bouton Postback et notez que le texte disparaît (en supposant que la propriété GridView EnableViewState est définie sur true, la valeur par défaut). Cela est dû au fait que, lors du postback, GridView est reconstruit à partir de son état d’affichage et ne se tourne donc pas vers ObjectDataSource pour ses données. Le tri, la pagination ou la modification des données entraîne toutefois le GridView à se reconnecter à sa source de données, et par conséquent, le texte lié à l'événement Selecting réapparaît.

Figure 9 : Chaque fois que le GridView est lié à sa source de données, l'événement de sélection déclenché est affiché (cliquez pour voir l’image en taille réelle)

Figure 10 : Le fait de cliquer sur le bouton Publier entraîne la reconstruction de GridView à partir de son état d’affichage (cliquez pour afficher l’image de taille complète)

Il peut sembler inutile de récupérer les données de 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 fournit pas de prise en charge du tri et de la pagination, les données doivent être récupérées à partir de la base de données chaque fois que la page est d’abord visitée par un utilisateur (et sur chaque publication, si l’état d’affichage est désactivé). Mais 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 de ObjectDataSource

En définissant simplement quelques propriétés, ObjectDataSource 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 ObjectDataSource :

• EnableCaching doit être défini à true pour activer la mise en cache. La valeur par défaut est false.
• CacheDuration du temps, en secondes, que les données sont mises en cache. La valeur par défaut est 0. ObjectDataSource ne met en cache les données que si EnableCaching est true et que CacheDuration est défini sur une valeur supérieure à zéro.
• CacheExpirationPolicy peut être défini sur Absolute ou Sliding. Si Absolute, ObjectDataSource met en cache ses données récupérées pendant CacheDuration des secondes ; si Sliding, les données expirent uniquement une fois qu’elles n’ont pas été consultées pendant CacheDuration des secondes. La valeur par défaut est Absolute.
• CacheKeyDependency utilise cette propriété pour associer les entrées de cache ObjectDataSource à une dépendance de cache existante. Les entrées de données de l'ObjectDataSource peuvent être supprimées prématurément du cache en expirant son CacheKeyDependency associé. Cette propriété est couramment utilisée pour associer une dépendance de cache SQL au cache ObjectDataSource, une rubrique que nous allons explorer à l’avenir à l’aide du didacticiel sur les dépendances du cache SQL .

Nous allons configurer ProductsDataSource ObjectDataSource pour mettre en cache ses données pendant 30 secondes sur 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 (cliquez pour afficher l’image de taille complète)

Enregistrez vos modifications et revisitez cette page dans un navigateur. Le texte sélectionné déclenché par l’événement s’affiche lors de la première visite de la page, car initialement les données ne figurent pas dans le cache. Toutefois, les publications suivantes déclenchées en cliquant sur le bouton Publier, le tri, la pagination ou le fait de cliquer sur les boutons Modifier ou Annuler ne réaffichent pas le texte déclenché par l’événement Selecting. Cela est dû au fait que l’événement Selecting se déclenche uniquement lorsque ObjectDataSource obtient ses données 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 objectDataSource s Insert, Updateou Delete les méthodes sont appelées. Par conséquent, après 30 secondes ou après avoir cliqué sur le bouton Mettre à jour, le tri, la pagination ou le clic sur les boutons Modifier ou Annuler entraînera l'ObjectDataSource à obtenir ses données de son objet sous-jacent, affichant le texte 'événement Selection déclenché' lorsque l'événement Selecting se déclenche. Ces résultats retournés sont placés dans le cache de données.

Remarque

Si vous voyez fréquemment le texte déclenché par l’événement Selecting, même si vous attendez 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 n’apparaît pas correctement mettre en cache les données ou met uniquement en cache les données de manière sporadique, fermez certaines applications pour libérer de la mémoire et réessayez.

La figure 12 illustre le flux de travail de mise en cache d’ObjectDataSource. Lorsque le texte de l'événement 'Selecting' s’affiche sur votre écran, cela signifie que les données n’étaient pas dans le cache et ont dû être récupérées à partir de l’objet sous-jacent. Toutefois, lorsque ce texte est manquant, il s’agit du fait que les données étaient disponibles à partir du cache. Lorsque les données sont retournées à partir du cache, il n’y a pas d’appel à l’objet sous-jacent et, par conséquent, aucune requête de base de données exécutée.

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

Chaque application ASP.NET possède sa propre instance de cache de données partagée sur 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 déclenché par l’événement Selecting s’affiche (en supposant que les données ajoutées au cache par les tests précédents ont été supprimées). Ouvrez une deuxième instance de navigateur et copiez et collez l’URL de la première instance de navigateur vers la seconde. Dans la deuxième instance du navigateur, le texte déclenché de l’événement Selecting 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 CacheDuration valeurs et CacheExpirationPolicy les valeurs de propriété ; le type de l’objet métier sous-jacent utilisé par ObjectDataSource, qui est spécifié via la TypeName propriété (ProductsBLLdans cet exemple), la valeur de la SelectMethod propriété et le nom et les valeurs des paramètres de la SelectParameters collection ; et les valeurs de ses StartRowIndex propriétés MaximumRows , qui sont utilisés lors de l’implémentation de la pagination personnalisée.

L’élaboration de la valeur de clé de cache en tant que 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 des ProductsBLL classes s GetProductsByCategoryID(categoryID), qui retourne tous les produits pour une catégorie spécifiée. Un utilisateur peut venir à la page et afficher les boissons, dont la valeur est de 1. Si ObjectDataSource a mis en cache ses résultats sans tenir compte des valeurs SelectParameters, lorsqu’un autre utilisateur accédait à la page pour voir les condiments alors que les produits de boisson étaient dans le cache, ils verraient les produits de boisson mis en cache plutôt que les condiments. En modifiant la clé de cache par ces propriétés, qui incluent les valeurs du 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 lorsque l'une de ses méthodes Insert, Update, ou Delete est appelée. Cela permet de se protéger contre les données obsolètes en désactivant les entrées du cache lorsque les données sont modifiées via la page. Toutefois, il est possible qu’un ObjectDataSource utilise la mise en cache pour toujours afficher des données obsolètes. Dans le cas le plus simple, cela peut être dû à la modification des données directement dans la base de données. Peut-être qu’un administrateur de base de données vient d’exécuter un script qui modifie certains enregistrements de la base de données.

Ce scénario pourrait également se dérouler de manière plus subtile. Bien que 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 concernent la combinaison particulière de valeurs de propriété (, , CacheDurationTypeNameet ainsi de suite) deSelectMethod ObjectDataSource. Si vous avez deux ObjectDataSources qui utilisent des données différentes SelectMethods ou SelectParameters, mais peuvent toujours mettre à jour les mêmes données, un ObjectDataSource peut mettre à jour une ligne et invalider ses propres entrées de cache, mais la ligne correspondante pour la deuxième ObjectDataSource sera toujours servie à partir du cache. Je vous encourage à créer des pages pour exposer cette fonctionnalité. Créez une page qui affiche un GridView modifiable, lequel extrait ses données d'un ObjectDataSource utilisant la mise en cache et configuré pour obtenir des données à partir de la méthode ProductsBLL de la classe GetProducts(). Ajoutez un autre GridView modifiable et ObjectDataSource à cette page (ou un 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 ont chacune leurs propres valeurs mises en cache. Si vous modifiez un produit dans une grille, la prochaine fois que vous liez les données à l’autre grille (en paginant, en triant, etc.), elle servira toujours les anciennes données mises en cache et ne reflète pas la modification apportée à 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ù la fraîcheur des données est importante. Si les données obsolètes ne sont pas acceptables, évitez 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 mettez en cache). Nous allons explorer les dépendances de cache SQL dans un prochain tutoriel.

Résumé

Dans ce tutoriel, nous avons examiné les fonctionnalités de mise en cache intégrées de ObjectDataSource. En définissant simplement quelques propriétés, nous pouvons indiquer à l'ObjectDataSource de mettre en cache les résultats retournés par 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 ObjectDataSource à une dépendance de cache existante. Cela peut être utilisé pour supprimer les entrées ObjectDataSource du cache avant que l’expiration basée sur le temps soit atteinte et est généralement utilisée avec les dépendances du cache SQL.

Étant donné que ObjectDataSource met simplement en cache ses valeurs dans le cache de données, nous pourrions répliquer les fonctionnalités intégrées de ObjectDataSource par programmation. Il n’est pas judicieux de le faire au niveau de la couche 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 travailler par programmation avec le cache de données à partir de l’architecture dans notre tutoriel suivant.

Bonne programmation !

Pour aller plus loin

Pour plus d’informations sur les sujets abordés dans ce tutoriel, consultez les 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 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. Le réviseur principal 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.

Prochain