Mise en cache

Article
07/13/2023

Une compréhension de la mise en cache est importante pour une application ASP.NET performante. ASP.NET 1.x offrait trois options différentes pour la mise en cache : mise en cache de sortie, mise en cache des fragments et API de cache.

Une compréhension de la mise en cache est importante pour une application ASP.NET performante. ASP.NET 1.x offrait trois options différentes pour la mise en cache : mise en cache de sortie, mise en cache des fragments et API de cache. ASP.NET 2.0 offre ces trois méthodes, mais ajoute des fonctionnalités supplémentaires significatives. Il existe plusieurs nouvelles dépendances de cache et les développeurs ont désormais la possibilité de créer également des dépendances de cache personnalisées. La configuration de la mise en cache a également été considérablement améliorée dans ASP.NET 2.0.

Nouvelles fonctionnalités

Profils de cache

Les profils de cache permettent aux développeurs de définir des paramètres de cache spécifiques qui peuvent ensuite être appliqués à des pages individuelles. Par exemple, si vous avez des pages qui doivent être expirées à partir du cache après 12 heures, vous pouvez facilement créer un profil de cache qui peut être appliqué à ces pages. Pour ajouter un nouveau profil de cache, utilisez la <section outputCacheSettings> dans le fichier de configuration. Par exemple, vous trouverez ci-dessous la configuration d’un profil de cache appelé deux jours qui configure une durée de cache de 12 heures.

<outputCacheSettings>
    <outputCacheProfiles>
        <add name="TwoDay" duration="43200" />
    </outputCacheProfiles>
</outputCacheSettings>

Pour appliquer ce profil de cache à une page particulière, utilisez l’attribut CacheProfile de la directive @ OutputCache, comme indiqué ci-dessous :

<%@ OutputCache CacheProfile="TwoDay" %>

Dépendances de cache personnalisées

ASP.NET les développeurs 1.x ont demandé des dépendances de cache personnalisées. Dans ASP.NET 1.x, la classe CacheDependency a été scellée, ce qui empêchait les développeurs d’en dériver leurs propres classes. Dans ASP.NET 2.0, cette limitation est supprimée et les développeurs sont libres de développer leurs propres dépendances de cache personnalisées. La classe CacheDependency permet de créer une dépendance de cache personnalisée basée sur des fichiers, des répertoires ou des clés de cache.

Par exemple, le code ci-dessous crée une dépendance de cache personnalisée basée sur un fichier appelé stuff.xml situé à la racine de l’application web :

System.Web.Caching.CacheDependency dep = new
    System.Web.Caching.CacheDependency(Server.MapPath("stuff.xml"));
Response.AddCacheDependency(dep);
Cache.Insert("key", "value");

Dans ce scénario, lorsque le fichier stuff.xml change, l’élément mis en cache est invalidé.

Il est également possible de créer une dépendance de cache personnalisée à l’aide de clés de cache. À l’aide de cette méthode, la suppression de la clé de cache invalidera les données mises en cache. L'exemple suivant illustre ce mécanisme :

// insert a value into cache that will serve
// as the cache key
Cache["CacheKey"] = "something";

// create an array of cache keys
string[] keys = new String[1];
keys[0] = "CacheKey";

CacheDependency dep = new CacheDependency(null, keys);

// insert an item into cache with a dependency on
// the above CacheDependency
Cache.Insert("Key", "Value", dep);

Pour invalider l’élément inséré ci-dessus, supprimez simplement l’élément qui a été inséré dans le cache pour agir comme clé de cache.

// Remove the cache item that serves as the cache key
Cache.Remove("CacheKey");

Notez que la clé de l’élément qui fait office de clé de cache doit être identique à la valeur ajoutée au tableau de clés de cache.

Polling-Based dépendances du cache SQL (également appelées dépendances Table-Based)

SQL Server 7 et 2000 utilisent le modèle basé sur l’interrogation pour les dépendances de cache SQL. Le modèle basé sur l’interrogation utilise un déclencheur sur une table de base de données qui est déclenché lorsque les données de la table changent. Ce déclencheur met à jour un champ changeId dans la table de notification que ASP.NET vérifie régulièrement. Si le champ changeId a été mis à jour, ASP.NET sait que les données ont changé et qu’il invalide les données mises en cache.

Notes

SQL Server 2005 peut également utiliser le modèle basé sur l’interrogation, mais étant donné que le modèle basé sur l’interrogation n’est pas le modèle le plus efficace, il est recommandé d’utiliser un modèle basé sur les requêtes (abordé plus loin) avec SQL Server 2005.

Pour qu’une dépendance de cache SQL utilisant le modèle basé sur l’interrogation fonctionne correctement, les notifications des tables doivent être activées. Cette opération peut être effectuée par programmation à l’aide de la classe SqlCacheDependencyAdmin ou de l’utilitaire aspnet_regsql.exe.

La ligne de commande suivante inscrit la table Products dans la base de données Northwind située sur une SQL Server instance nommée dbase pour la dépendance du cache SQL.

aspnet_regsql -S dbase -ed -d Northwind -E -et -t Products

Voici une explication des commutateurs de ligne de commande utilisés dans la commande ci-dessus :

Commutateur de ligne de commande	Objectif
-S server	Spécifie le nom du serveur.
-Ed	Spécifie que la base de données doit être activée pour la dépendance du cache SQL.
-d database_name	Spécifie le nom de la base de données qui doit être activé pour la dépendance du cache SQL.
-E	Spécifie que aspnet_regsql devez utiliser Authentification Windows lors de la connexion à la base de données.
-et	Spécifie que nous activons une table de base de données pour la dépendance du cache SQL.
-t table_name	Spécifie le nom de la table de base de données à activer pour la dépendance de cache SQL.

Notes

D’autres commutateurs sont disponibles pour aspnet_regsql.exe. Pour obtenir la liste complète, exécutez aspnet_regsql.exe -? à partir d’une ligne de commande.

Lorsque cette commande s’exécute, les modifications suivantes sont apportées à la base de données SQL Server :

Une table AspNet_SqlCacheTablesForChangeNotification est ajoutée. Cette table contient une ligne pour chaque table de la base de données pour laquelle une dépendance de cache SQL a été activée.
Les procédures stockées suivantes sont créées à l’intérieur de la base de données :

AspNet_SqlCachePollingStoredProcedure	Interroge la table AspNet_SqlCacheTablesForChangeNotification et retourne toutes les tables activées pour la dépendance du cache SQL et la valeur changeId pour chaque table. Cette procédure stockée est utilisée pour l’interrogation afin de déterminer si les données ont changé.
AspNet_SqlCacheQueryRegisteredTablesStoredProcedure	Retourne toutes les tables activées pour la dépendance de cache SQL en interrogeant la table AspNet_SqlCacheTablesForChangeNotification et retourne toutes les tables activées pour la dépendance de cache SQL.
AspNet_SqlCacheRegisterTableStoredProcedure	Inscrit une table pour la dépendance du cache SQL en ajoutant l’entrée nécessaire dans la table de notification et ajoute le déclencheur.
AspNet_SqlCacheUnRegisterTableStoredProcedure	Annule l’inscription d’une table pour la dépendance du cache SQL en supprimant l’entrée dans la table de notification et supprime le déclencheur.
AspNet_SqlCacheUpdateChangeIdStoredProcedure	Mises à jour la table de notification en incrémentant la valeur changeId de la table modifiée. ASP.NET utilise cette valeur pour déterminer si les données ont changé. Comme indiqué ci-dessous, cette procédure stockée est exécutée par le déclencheur créé lorsque la table est activée.

Un déclencheur SQL Server appelé table_name_AspNet_SqlCacheNotification_Trigger est créé pour la table. Ce déclencheur exécute le AspNet_SqlCacheUpdateChangeIdStoredProcedure lorsqu’une opération INSERT, UPDATE ou DELETE est effectuée sur la table.
Un rôle SQL Server appelé aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess est ajouté à la base de données.

Le rôle SQL Server aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess dispose d’autorisations EXEC sur le AspNet_SqlCachePollingStoredProcedure. Pour que le modèle d’interrogation fonctionne correctement, vous devez ajouter votre compte de processus au rôle aspnet_ChangeNotification_ReceiveNotificationsOnlyAccess. L’outil aspnet_regsql.exe ne le fera pas pour vous.

Configuration des dépendances de cache SQL Polling-Based

Plusieurs étapes sont nécessaires pour configurer les dépendances de cache SQL basées sur l’interrogation. La première étape consiste à activer la base de données et la table comme indiqué ci-dessus. Une fois cette étape terminée, le reste de la configuration se présente comme suit :

Configuration du fichier de configuration ASP.NET.
Configuration de SqlCacheDependency

Configuration du fichier de configuration ASP.NET

En plus d’ajouter une chaîne de connexion comme indiqué dans un module précédent, vous devez également configurer un <élément de cache> avec un <élément sqlCacheDependency> , comme indiqué ci-dessous :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="Pubs"
    connectionString="Data Source=(local);
      Initial Catalog=pubs;Integrated Security=true;"
    providerName="System.Data.SqlClient" />
  </connectionStrings>
  <system.web>
    <caching>
      <sqlCacheDependency enabled = "true" pollTime = "60000" >
        <databases>
          <add name="pubs" connectionStringName = "pubs" pollTime = "9000000" />
        </databases>
      </sqlCacheDependency>
    </caching>
  </system.web>
</configuration>

Cette configuration active une dépendance de cache SQL sur la base de données pubs . Notez que l’attribut pollTime dans l’élément <sqlCacheDependency> est défini par défaut sur 6 0000 millisecondes ou 1 minute. (Cette valeur ne peut pas être inférieure à 500 millisecondes.) Dans cet exemple, l’élément <add> ajoute une nouvelle base de données et remplace pollTime, en lui affectant la valeur 9000000 millisecondes.

Configuration de SqlCacheDependency

L’étape suivante consiste à configurer SqlCacheDependency. Le moyen le plus simple d’y parvenir consiste à spécifier la valeur de l’attribut SqlDependency dans la directive @ Outcache comme suit :

<%@ OutputCache duration="60"
    VaryByParam="none" SqlDependency="pubs:authors" %>

Dans la directive @ OutputCache ci-dessus, une dépendance de cache SQL est configurée pour la table authors dans la base de données pubs . Plusieurs dépendances peuvent être configurées en les séparant par un point-virgule comme suit :

<%@ OutputCache duration="60"
    VaryByParam="none"
    SqlDependency="database_name:table_name;database_name:table_name" %>

Une autre méthode de configuration de SqlCacheDependency consiste à le faire par programmation. Le code suivant crée une nouvelle dépendance de cache SQL sur la table authors dans la base de données pubs .

SqlCacheDependency dep = new SqlCacheDependency("pubs", "authors");

L’un des avantages de la définition par programmation de la dépendance de cache SQL est que vous pouvez gérer toutes les exceptions qui peuvent se produire. Par exemple, si vous tentez de définir une dépendance de cache SQL pour une base de données qui n’a pas été activée pour la notification, une exception DatabaseNotEnabledForNotificationException est levée. Dans ce cas, vous pouvez tenter d’activer la base de données pour les notifications en appelant la méthode SqlCacheDependencyAdmin.EnableNotifications et en lui transmettant le nom de la base de données.

De même, si vous tentez de définir une dépendance de cache SQL pour une table qui n’a pas été activée pour la notification, une exception TableNotEnabledForNotificationException sera levée. Vous pouvez ensuite appeler la méthode SqlCacheDependencyAdmin.EnableTableForNotifications en lui transmettant le nom de la base de données et le nom de la table.

L’exemple de code suivant montre comment configurer correctement la gestion des exceptions lors de la configuration d’une dépendance de cache SQL.

try {
    SqlCacheDependency SqlDep = new
    SqlCacheDependency("pubs", "authors");
} catch (DatabaseNotEnabledForNotificationException exDBDis) {
    try {
        SqlCacheDependencyAdmin.EnableNotifications("pubs");
    } catch (UnauthorizedAccessException exPerm) {
        Response.Redirect("ErrorPage.htm");
    }
} catch (TableNotEnabledForNotificationException exTabDis) {
    try {
        SqlCacheDependencyAdmin.EnableTableForNotifications("pubs",
        "authors");
    } catch (System.Data.SqlClient.SqlException exc) {
        Response.Redirect("ErrorPage.htm");
    }
} finally {
    Cache.Insert("SqlSource", Source1, SqlDep);
}

Plus d’informations : https://msdn.microsoft.com/library/t9x04ed2.aspx

dépendances du cache SQL Query-Based (SQL Server 2005 uniquement)

Lorsque vous utilisez SQL Server 2005 pour la dépendance du cache SQL, le modèle basé sur l’interrogation n’est pas nécessaire. Lorsqu’elles sont utilisées avec SQL Server 2005, les dépendances du cache SQL communiquent directement via des connexions SQL au SQL Server instance (aucune autre configuration n’est nécessaire) à l’aide de SQL Server notifications de requête 2005.

Le moyen le plus simple d’activer la notification basée sur les requêtes consiste à le faire de manière déclarative en définissant l’attribut SqlCacheDependency de l’objet source de données sur CommandNotification et en définissant l’attribut EnableCaching sur true. À l’aide de cette méthode, aucun code n’est requis. Si le résultat d’une commande exécutée sur la source de données change, les données du cache sont invalidées.

L’exemple suivant configure un contrôle de source de données pour la dépendance du cache SQL :

<asp:SqlDataSource ID="ProductList" runat="server"
    ConnectionString="<%$ ConnectionStrings:Northwind %>"
    EnableCaching="true"
    SqlCacheDependency="CommandNotification"
    SelectCommand="SELECT * FROM [Products]" />

Dans ce cas, si la requête spécifiée dans SelectCommand retourne un résultat différent de celui d’origine, les résultats mis en cache sont invalidés.

Vous pouvez également spécifier que toutes vos sources de données soient activées pour les dépendances du cache SQL en définissant l’attribut SqlDependency de la directive @ OutputCache sur CommandNotification. L’exemple ci-dessous illustre cela.

<%@ OutputCache SqlDependency="CommandNotification" 
    duration="60" VaryByParam="none" %>

Notes

Pour plus d’informations sur les notifications de requête dans SQL Server 2005, consultez la documentation en ligne SQL Server.

Une autre méthode de configuration d’une dépendance de cache SQL basée sur une requête consiste à le faire par programmation à l’aide de la classe SqlCacheDependency. L’exemple de code suivant illustre la façon dont cela est effectué.

string sql = "SELECT ProductName, ProductID FROM Products";
SqlConnection conn = new
SqlConnection(ConfigurationManager.ConnectionStrings["Northwind"].ConnectionString);
SqlCommand cmd = new SqlCommand(sql, conn);
SqlCacheDependency dep = new SqlCacheDependency(cmd);
Response.AddCacheDependency(dep);

Plus d’informations : https://msdn.microsoft.com/library/default.asp?url=/library/enus/dnvs05/html/querynotification.asp

Post-Cache Substitution

La mise en cache d’une page peut augmenter considérablement les performances d’une application web. Toutefois, dans certains cas, vous avez besoin que la plupart de la page soit mise en cache et que certains fragments de la page soient dynamiques. Par exemple, si vous créez une page d’actualités entièrement statique pour des périodes définies, vous pouvez définir la page entière à mettre en cache. Si vous souhaitez inclure une bannière publicitaire tournante qui a changé à chaque demande de page, la partie de la page contenant la publicité doit être dynamique. Pour vous permettre de mettre en cache une page, mais de remplacer dynamiquement du contenu, vous pouvez utiliser ASP.NET substitution post-cache. Avec la substitution post-cache, la page entière est mise en cache avec des parties spécifiques marquées comme exemptées de mise en cache. Dans l’exemple de bannières publicitaires, le contrôle AdRotator vous permet de tirer parti de la substitution post-cache afin que les annonces créées dynamiquement pour chaque utilisateur et pour chaque page soient actualisées.

Il existe trois façons d’implémenter la substitution post-cache :

De manière déclarative, à l’aide du contrôle Substitution.
Par programme, à l’aide de l’API de contrôle substitution.
Implicitement, à l’aide du contrôle AdRotator.

Contrôle de substitution

Le contrôle substitution ASP.NET spécifie une section d’une page mise en cache qui est créée dynamiquement plutôt que mise en cache. Vous placez un contrôle substitution à l’emplacement de la page où vous souhaitez que le contenu dynamique s’affiche. Au moment de l’exécution, le contrôle Substitution appelle une méthode que vous spécifiez avec la propriété MethodName. La méthode doit retourner une chaîne, qui remplace ensuite le contenu du contrôle Substitution. La méthode doit être une méthode statique sur le contrôle Page ou UserControl contenant. L’utilisation du contrôle de substitution entraîne la modification de la mise en cache côté client à la mise en cache du serveur, de sorte que la page ne soit pas mise en cache sur le client. Cela garantit que les futures demandes adressées à la page appellent à nouveau la méthode pour générer du contenu dynamique.

Substitution API

Pour créer du contenu dynamique pour une page mise en cache par programme, vous pouvez appeler la méthode WriteSubstitution dans votre code de page, en lui transmettant le nom d’une méthode en tant que paramètre. La méthode qui gère la création du contenu dynamique prend un seul paramètre HttpContext et retourne une chaîne. La chaîne de retour est le contenu qui sera remplacé à l’emplacement donné. L’un des avantages de l’appel de la méthode WriteSubstitution au lieu d’utiliser le contrôle Substitution de manière déclarative est que vous pouvez appeler une méthode de n’importe quel objet arbitraire plutôt que d’appeler une méthode statique de l’objet Page ou UserControl.

L’appel de la méthode WriteSubstitution entraîne la modification de la mise en cache côté client à la mise en cache du serveur, de sorte que la page ne soit pas mise en cache sur le client. Cela garantit que les futures demandes adressées à la page appellent à nouveau la méthode pour générer du contenu dynamique.

Contrôle AdRotator

Le contrôle serveur AdRotator implémente la prise en charge de la substitution post-cache en interne. Si vous placez un contrôle AdRotator sur votre page, il affiche des publicités uniques sur chaque requête, que la page parente soit mise en cache ou non. Par conséquent, une page qui inclut un contrôle AdRotator est uniquement mise en cache côté serveur.

Classe ControlCachePolicy

La classe ControlCachePolicy permet le contrôle par programmation de la mise en cache de fragments à l’aide de contrôles utilisateur. ASP.NET incorpore des contrôles utilisateur dans un instance BasePartialCachingControl. La classe BasePartialCachingControl représente un contrôle utilisateur pour lequel la mise en cache de sortie est activée.

Lorsque vous accédez à la propriété BasePartialCachingControl.CachePolicy d’un contrôle PartialCachingControl , vous recevez toujours un objet ControlCachePolicy valide. Toutefois, si vous accédez à la propriété UserControl.CachePolicy d’un contrôle UserControl , vous recevez un objet ControlCachePolicy valide uniquement si le contrôle utilisateur est déjà encapsulé par un contrôle BasePartialCachingControl. S’il n’est pas encapsulé, l’objet ControlCachePolicy retourné par la propriété lève des exceptions lorsque vous tentez de le manipuler, car il n’a pas de BasePartialCachingControl associé. Pour déterminer si un instance UserControl prend en charge la mise en cache sans générer d’exceptions, examinez la propriété SupportsCaching.

L’utilisation de la classe ControlCachePolicy est l’une des nombreuses façons d’activer la mise en cache de sortie. La liste suivante décrit les méthodes que vous pouvez utiliser pour activer la mise en cache de sortie :

Utilisez la directive @ OutputCache pour activer la mise en cache de sortie dans des scénarios déclaratifs.
Utilisez l’attribut PartialCachingAttribute pour activer la mise en cache d’un contrôle utilisateur dans un fichier code-behind.
Utilisez la classe ControlCachePolicy pour spécifier les paramètres de cache dans les scénarios programmatiques dans lesquels vous utilisez des instances BasePartialCachingControl qui ont été activées pour le cache à l’aide de l’une des méthodes précédentes et chargées dynamiquement à l’aide de la méthode System.Web.UI.TemplateControl.LoadControl .

Une instance ControlCachePolicy ne peut être manipulée correctement qu’entre les phases Init et PreRender du cycle de vie du contrôle. Si vous modifiez un objet ControlCachePolicy après la phase PreRender, ASP.NET lève une exception, car les modifications apportées après le rendu du contrôle ne peuvent pas affecter réellement les paramètres du cache (un contrôle est mis en cache pendant la phase rendu). Enfin, un instance de contrôle utilisateur (et donc son objet ControlCachePolicy) n’est disponible pour la manipulation par programme que lorsqu’il est réellement rendu.

Modifications apportées à la configuration de mise en cache - Élément <de mise en> cache

Plusieurs modifications sont apportées à la configuration de la mise en cache dans ASP.NET 2.0. L’élément <de> mise en cache est nouveau dans ASP.NET 2.0 et vous permet d’apporter des modifications de configuration de mise en cache dans le fichier de configuration. Les attributs suivants sont disponibles.

Element	Description
Cache	Élément facultatif. Définit les paramètres globaux du cache d’application.
outputCache	Élément facultatif. Spécifie les paramètres du cache de sortie à l’échelle de l’application.
outputCacheSettings	Élément facultatif. Spécifie les paramètres de cache de sortie qui peuvent être appliqués aux pages de l’application.
sqlCacheDependency	Élément facultatif. Configure les dépendances de cache SQL pour une application ASP.NET.

Élément cache <>

Les attributs suivants sont disponibles dans l’élément cache <> :

Attribut	Description
disableMemoryCollection	Attribut booléen facultatif. Obtient ou définit une valeur indiquant si la collection de mémoire cache qui se produit lorsque l’ordinateur est sous pression mémoire est désactivée.
disableExpiration	Attribut booléen facultatif. Obtient ou définit une valeur indiquant si l’expiration du cache est désactivée. Lorsqu’ils sont désactivés, les éléments mis en cache n’expirent pas et le repérage en arrière-plan des éléments de cache expirés ne se produit pas.
privateBytesLimit	Attribut Int64 facultatif. Obtient ou définit une valeur indiquant la taille maximale des octets privés d’une application avant que le cache ne commence à vider les éléments expirés et à tenter de récupérer la mémoire. Cette limite inclut à la fois la mémoire utilisée par le cache et la surcharge de mémoire normale de l’application en cours d’exécution. Un paramètre de zéro indique que ASP.NET utilisera ses propres heuristiques pour déterminer quand commencer à récupérer la mémoire.
percentagePhysicalMemoryUsedLimit	Attribut Int32 facultatif. Obtient ou définit une valeur indiquant le pourcentage maximal de la mémoire physique d’un ordinateur qui peut être consommée par une application avant que le cache ne commence à vider les éléments expirés et à tenter de récupérer la mémoire Cette utilisation de la mémoire inclut à la fois la mémoire utilisée par le cache et l’utilisation normale de la mémoire de l’application en cours d’exécution. Un paramètre de zéro indique que ASP.NET utilisera ses propres heuristiques pour déterminer quand commencer à récupérer la mémoire.
privateBytesPollTime	Attribut TimeSpan facultatif. Obtient ou définit une valeur indiquant l’intervalle de temps entre l’interrogation de l’utilisation de la mémoire d’octets privés de l’application.

Élément <outputCache>

Les attributs suivants sont disponibles pour l’élément <outputCache> .

Attribut	Description
enableOutputCache	Attribut booléen facultatif. Active/désactive le cache de sortie de page. Si cette option est désactivée, aucune page n’est mise en cache, quels que soient les paramètres programmatiques ou déclaratifs. La valeur par défaut est true.
enableFragmentCache	Attribut booléen facultatif. Active/désactive le cache de fragments d’application. Si cette option est désactivée, aucune page n’est mise en cache, quels que soient la directive @ OutputCache ou le profil de mise en cache utilisé. Inclut un en-tête de contrôle de cache indiquant que amont serveurs proxy ainsi que les clients de navigateur ne doivent pas essayer de mettre en cache la sortie de page. La valeur par défaut est false.
sendCacheControlHeader	Attribut booléen facultatif. Obtient ou définit une valeur indiquant si l’en-tête cache-control:private est envoyé par le module de cache de sortie par défaut. La valeur par défaut est false.
omitVaryStar	Attribut booléen facultatif. Active/désactive l’envoi d’un en-tête Http « Vary: </strong>» dans la réponse. Avec le paramètre par défaut false, un en-tête « Vary: » est envoyé pour les pages mises en cache de sortie. Lorsque l’en-tête Vary est envoyé, il permet de mettre en cache différentes versions en fonction de ce qui est spécifié dans l’en-tête Vary. Par exemple, Vary:User-Agents stocke différentes versions d’une page en fonction de l’agent utilisateur qui émet la demande. La valeur par défaut est **false.

Élément <outputCacheSettings>

L’élément <outputCacheSettings> permet de créer des profils de cache comme décrit précédemment. Le seul élément enfant de l’élément <outputCacheSettings> est l’élément <outputCacheProfiles pour la configuration des> profils de cache.

Élément <sqlCacheDependency>

Les attributs suivants sont disponibles pour l’élément <sqlCacheDependency> .

Attribut	Description
activé	Attribut booléen obligatoire. Indique si les modifications sont interrogées ou non.
pollTime	Attribut Int32 facultatif. Définit la fréquence à laquelle SqlCacheDependency interroge la table de base de données pour les modifications. Cette valeur correspond au nombre de millisecondes entre les interrogations successives. Il ne peut pas être défini sur moins de 500 millisecondes. La valeur par défaut est 1 minute.

Informations complémentaires

Vous devez connaître certaines informations supplémentaires concernant la configuration du cache.

Si la limite d’octets privés du processus de travail n’est pas définie, le cache utilise l’une des limites suivantes :
- x86 2 Go : 800 Mo ou 60 % de RAM physique, selon la valeur la moins élevée
- x86 3 Go : 1800 Mo ou 60 % de RAM physique, selon la valeur la moins élevée
- x64 : 1 téraoctet ou 60 % de ram physique, selon la valeur la moins élevée
Si la limite d’octets privés du processus worker et <le cache privateBytesLimit/> sont définis, le cache utilise le minimum des deux.
Comme dans la version 1.x, nous abandonnons les entrées de cache et appelons GC. Collecter pour deux raisons :
- Nous sommes très proches de la limite d’octets privés
- La mémoire disponible est proche ou inférieure à 10 %
Vous pouvez désactiver efficacement le découpage et le cache pour les conditions de mémoire faible disponible en définissant <pourcentage de cachePhysicalMemoryUseLimit/> sur 100.
Contrairement à 1.x, la version 2.0 suspend les appels de découpage et de collecte si le dernier GC. Collect n’a pas réduit les octets privés ou la taille des tas managés de plus de 1 % de la limite de mémoire (cache).

Labo1 : Dépendances du cache personnalisé

Créez un site web.
Ajoutez un nouveau fichier XML appelé cache.xml et enregistrez-le à la racine de l’application web.

Ajoutez le code suivant à la méthode Page_Load dans le code-behind de default.aspx :

System.Web.Caching.CacheDependency dep = new
    System.Web.Caching.CacheDependency(Server.MapPath("cache.xml"));
Response.AddCacheDependency(dep);
Cache.Insert("time", DateTime.Now.ToString());
Response.Write(Cache["time"]);

Ajoutez ce qui suit en haut de default.aspx en mode source :
```
<%@ OutputCache Duration="240" VaryByParam="None" %>
```
Accédez à Default.aspx. Que dit le temps ?
Actualisez le navigateur. Que dit le temps ?
Ouvrez cache.xml et ajoutez le code suivant :
```
<anElement></anElement>
```
Enregistrez cache.xml.
Actualisez votre navigateur. Que dit le temps ?
Expliquez pourquoi l’heure mise à jour au lieu d’afficher les valeurs précédemment mises en cache :

Labo 2 : Utilisation des dépendances du cache Polling-Based

Ce labo utilise le projet que vous avez créé dans le module précédent qui permet de modifier les données de la base de données Northwind via un contrôle GridView et DetailsView.

Ouvrez le projet dans Visual Studio 2005.
Exécutez l’utilitaire aspnet_regsql sur la base de données Northwind pour activer la base de données et la table Products. Utilisez la commande suivante à partir d’une invite de commandes Visual Studio :
```
aspnet_regsql -S server -ed -d Northwind -E -et -t Products
```

Ajoutez les éléments suivants à votre fichier web.config :

<caching>
    <sqlCacheDependency enabled = "true" pollTime = "60000" >
        <databases>
            <add name="Northwind" connectionStringName = "Northwind" pollTime = "9000000" />
        </databases>
    </sqlCacheDependency>
</caching>

Ajoutez un nouveau formulaire web appelé showdata.aspx.

Ajoutez la directive @ outputcache suivante à la page showdata.aspx :

<%@ OutputCache SqlDependency="Northwind:Products" Duration="480" VaryByParam="None"%>

Ajoutez le code suivant au Page_Load de showdata.aspx :

Response.Write(DateTime.Now.ToString() + "<br><br>");

Ajoutez un nouveau contrôle SqlDataSource à showdata.aspx et configurez-le pour utiliser la connexion de base de données Northwind. Cliquez sur Suivant.
Cochez les cases ProductName et ProductID, puis cliquez sur Suivant.
Cliquez sur Finish.
Ajoutez un nouveau GridView à la page showdata.aspx.
Choisissez SqlDataSource1 dans la liste déroulante.
Enregistrez et parcourez showdata.aspx. Notez l’heure affichée.

Partager via

Mise en cache

Nouvelles fonctionnalités

Profils de cache

Dépendances de cache personnalisées

Polling-Based dépendances du cache SQL (également appelées dépendances Table-Based)

Configuration des dépendances de cache SQL Polling-Based

Configuration du fichier de configuration ASP.NET

Configuration de SqlCacheDependency

dépendances du cache SQL Query-Based (SQL Server 2005 uniquement)

Post-Cache Substitution

Contrôle de substitution

Substitution API

Contrôle AdRotator

Classe ControlCachePolicy

Modifications apportées à la configuration de mise en cache - Élément <de mise en> cache

Élément cache <>

Élément <outputCache>

Élément <outputCacheSettings>

Élément <sqlCacheDependency>

Informations complémentaires

Labo1 : Dépendances du cache personnalisé

Labo 2 : Utilisation des dépendances du cache Polling-Based

Commentaires

Ressources supplémentaires