Mise en cache de données dans l’architecture (C#)

par Scott Mitchell

Télécharger le PDF

Dans le tutoriel précédent, nous avons appris à appliquer la mise en cache au niveau de la couche Présentation. Dans ce tutoriel, nous apprenons à tirer parti de notre architecture en couches pour mettre en cache les données au niveau de la couche logique métier. Pour ce faire, nous étendons l’architecture pour inclure une couche de mise en cache.

Présentation

Comme nous l’avons vu dans le tutoriel précédent, la mise en cache des données ObjectDataSource est aussi simple que la définition de deux propriétés. Malheureusement, ObjectDataSource applique la mise en cache au niveau de la couche présentation, qui associe étroitement les stratégies de mise en cache à la page ASP.NET. L’une des raisons de la création d’une architecture en couches consiste à permettre à ces couplages d’être rompus. La couche logique métier, par exemple, dissocie la logique métier des pages ASP.NET, tandis que la couche d’accès aux données dissocie les détails de l’accès aux données. Ce découplage des détails de la logique métier et de l’accès aux données est préféré, en partie, car il rend le système plus lisible, plus gérable et plus flexible pour changer. Il permet également la connaissance du domaine et la division du travail qu’un développeur travaillant sur la couche présentation n’a pas besoin d’être familiarisé avec les détails de la base de données afin de faire son travail. Le découplage de la stratégie de mise en cache de la couche Présentation offre des avantages similaires.

Dans ce tutoriel, nous allons augmenter notre architecture pour inclure une couche de mise en cache (ou CL pour un court terme) qui utilise notre stratégie de mise en cache. La couche de mise en cache inclut une ProductsCL classe qui fournit l’accès aux informations de produit avec des méthodes telles GetProducts()que , GetProductsByCategoryID(categoryID)et ainsi de suite, qui, lorsqu’elle est appelée, tente d’abord de récupérer les données à partir du cache. Si le cache est vide, ces méthodes appellent la méthode appropriée ProductsBLL dans la BLL, ce qui obtiendrait à son tour les données du dal. Les ProductsCL méthodes mettent en cache les données récupérées à partir de la BLL avant de les renvoyer.

Comme le montre la figure 1, le CL réside entre la présentation et les couches logiques métier.

Figure 1 : La couche de mise en cache (CL) est une autre couche dans notre architecture

Étape 1 : Création des classes de couche de mise en cache

Dans ce tutoriel, nous allons créer un CL très simple avec une classe ProductsCL unique qui n’a qu’une poignée de méthodes. La création d’une couche de mise en cache complète pour l’ensemble de l’application nécessite la création des classes CategoriesCL, EmployeesCL, et SuppliersCL, ainsi que la fourniture d’une méthode dans ces classes de la couche de mise en cache pour chaque méthode d’accès aux données ou de modification dans la BLL. Comme avec BLL et DAL, la couche de mise en cache doit idéalement être implémentée en tant que projet de bibliothèque de classes distinct ; Toutefois, nous allons l’implémenter en tant que classe dans le App_Code dossier.

Pour séparer plus précisément les classes CL des classes DAL et BLL, nous allons créer un sous-dossier dans le App_Code dossier. Cliquez avec le bouton droit sur le App_Code dossier dans l’Explorateur de solutions, choisissez Nouveau dossier et nommez le nouveau dossier CL. Après avoir créé ce dossier, ajoutez-lui une nouvelle classe nommée ProductsCL.cs.

Figure 2 : Ajouter un nouveau dossier nommé CL et une classe nommée ProductsCL.cs

La ProductsCL classe doit inclure le même jeu de méthodes d’accès aux données et de modification que celle trouvée dans sa classe de couche logique métier correspondante (ProductsBLL). Plutôt que de créer toutes ces méthodes, nous allons simplement créer un couple ici pour obtenir une idée des modèles utilisés par le CL. En particulier, nous allons ajouter les méthodes GetProducts() et GetProductsByCategoryID(categoryID) à l'Étape 3 et une surcharge UpdateProduct à l'Étape 4. Vous pouvez ajouter les méthodes restantes ProductsCL et CategoriesCL, ainsi que les classes EmployeesCL et SuppliersCL à votre guise.

Étape 2 : Lecture et écriture dans le cache de données

La fonctionnalité de mise en cache ObjectDataSource explorée dans le didacticiel précédent utilise en interne le cache de données ASP.NET pour stocker les données récupérées à partir de la BLL. Le cache de données peut également être accédé de manière programmatique à partir des classes code-behind des pages ASP.NET ou à partir des classes de l'architecture de l'application web. Pour lire et écrire dans le cache de données depuis une classe en arrière-plan de code d'une page ASP.NET, utilisez le schéma suivant :

// Read from the cache
object value = Cache["key"];
// Add a new item to the cache
Cache["key"] = value;
Cache.Insert(key, value);
Cache.Insert(key, value, CacheDependency);
Cache.Insert(key, value, CacheDependency, DateTime, TimeSpan);

La méthode de classe s a plusieurs surcharges. Cache["key"] = value et sont synonymes et Cache.Insert(key, value) ajoutent un élément au cache à l’aide de la clé spécifiée sans expiration définie. En règle générale, nous voulons spécifier une expiration lors de l’ajout d’un élément au cache, en tant que dépendance, expiration basée sur le temps ou les deux. Utilisez l’une des autres surcharges de la méthode Insert pour fournir des informations d’expiration basées sur la dépendance ou le temps.

Les méthodes de la couche de mise en cache doivent d’abord vérifier si les données demandées se trouvent dans le cache et, le cas échéant, les renvoyer à partir de là. Si les données demandées ne sont pas dans le cache, la méthode BLL appropriée doit être appelée. Sa valeur de retour doit être mise en cache, puis retournée, comme le montre le diagramme de séquence suivant.

Figure 3 : Les méthodes de couche de mise en cache retournent des données à partir du cache s’il est disponible

La séquence illustrée dans la figure 3 est effectuée dans les classes CL à l’aide du modèle suivant :

Type instance = Cache["key"] as Type;
if (instance == null)
{
    instance = BllMethodToGetInstance();
    Cache.Insert(key, instance, ...);
}
return instance;

Ici, type est le type de données stockées dans le cache Northwind.ProductsDataTable, par exemple, tandis que la clé est la clé qui identifie de manière unique l’élément de cache. Si l’élément avec la clé spécifiée n’est pas dans le cache, l’instancenull sera et les données seront récupérées à partir de la méthode BLL appropriée et ajoutées au cache. Une fois que return instance est atteinte, l’instance contient une référence aux données, soit à partir du cache, soit récupérée de la BLL.

Veillez à utiliser le modèle ci-dessus lors de l’accès aux données à partir du cache. Le modèle suivant, qui, à première vue, semble équivalent, contient une différence subtile qui introduit une condition de race. Les conditions de course sont difficiles à déboguer parce qu’elles se révèlent sporadiquement et sont difficiles à reproduire.

if (Cache["key"] == null)
{
    Cache.Insert(key, BllMethodToGetInstance(), ...);
}
return Cache["key"];

La différence dans ce deuxième extrait de code incorrect est que plutôt que de stocker une référence à l’élément mis en cache dans une variable locale, le cache de données est accessible directement dans l’instruction conditionnelle et dans le return. Imaginez que lorsque ce code est atteint, Cache["key"] est non-null, mais avant que l'instruction return soit atteinte, le système évince la clé du cache. Dans ce cas rare, le code retourne une null valeur plutôt qu’un objet du type attendu.

Remarque

Le cache de données est thread-safe. Vous n’avez donc pas besoin de synchroniser l’accès aux threads pour des lectures ou des écritures simples. Toutefois, si vous devez effectuer plusieurs opérations sur des données dans le cache qui doivent être atomiques, vous êtes responsable de l’implémentation d’un verrou ou d’un autre mécanisme pour garantir la sécurité des threads. Pour plus d’informations, consultez Synchronisation de l’accès au cache ASP.NET .

Un élément peut être supprimé par programmation du cache de données à l’aide de la Remove méthode comme suit :

Cache.Remove(key);

Étape 3 : renvoi d’informations sur le produit à partir de laProductsCLclasse

Pour ce tutoriel, nous allons implémenter deux méthodes pour retourner des informations sur le produit à partir de la ProductsCL classe : GetProducts() et GetProductsByCategoryID(categoryID). Comme avec la classe dans la ProductsBL couche logique métier, la GetProducts() méthode dans le CL retourne des informations sur tous les produits en tant qu’objet Northwind.ProductsDataTable , tandis que GetProductsByCategoryID(categoryID) retourne tous les produits d’une catégorie spécifiée.

Le code suivant montre une partie des méthodes de la ProductsCL classe :

[System.ComponentModel.DataObject]
public class ProductsCL
{
    private ProductsBLL _productsAPI = null;
    protected ProductsBLL API
    {
        get
        {
            if (_productsAPI == null)
                _productsAPI = new ProductsBLL();
            return _productsAPI;
        }
    }
    
   [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, true)]
    public Northwind.ProductsDataTable GetProducts()
    {
        const string rawKey = "Products";
        // See if the item is in the cache
        Northwind.ProductsDataTable products = _
            GetCacheItem(rawKey) as Northwind.ProductsDataTable;
        if (products == null)
        {
            // Item not found in cache - retrieve it and insert it into the cache
            products = API.GetProducts();
            AddCacheItem(rawKey, products);
        }
        return products;
    }
    
    [System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Select, false)]
    public Northwind.ProductsDataTable GetProductsByCategoryID(int categoryID)
    {
        if (categoryID < 0)
            return GetProducts();
        else
        {
            string rawKey = string.Concat("ProductsByCategory-", categoryID);
            // See if the item is in the cache
            Northwind.ProductsDataTable products = _
                GetCacheItem(rawKey) as Northwind.ProductsDataTable;
            if (products == null)
            {
                // Item not found in cache - retrieve it and insert it into the cache
                products = API.GetProductsByCategoryID(categoryID);
                AddCacheItem(rawKey, products);
            }
            return products;
        }
    }
}

Tout d'abord, notez les attributs DataObject et DataObjectMethodAttribute appliqués à la classe et aux méthodes. Ces attributs fournissent des informations à l’Assistant ObjectDataSource, indiquant quelles classes et méthodes doivent apparaître dans les étapes de l’assistant. Étant donné que les classes et méthodes CL sont accessibles à partir d’un ObjectDataSource dans la couche Présentation, j’ai ajouté ces attributs pour améliorer l’expérience au moment du design. Reportez-vous au didacticiel Création d’une couche logique métier pour obtenir une description plus approfondie sur ces attributs et leurs effets.

Dans les méthodes GetProducts() et GetProductsByCategoryID(categoryID), les données retournées par la méthode GetCacheItem(key) sont affectées à une variable locale. La GetCacheItem(key) méthode, que nous examinerons prochainement, retourne un élément particulier du cache en fonction de la clé spécifiée. Si aucune donnée de ce type n’est trouvée dans le cache, elle est récupérée à partir de la méthode de classe correspondante ProductsBLL , puis ajoutée au cache à l’aide de la AddCacheItem(key, value) méthode.

Les méthodes GetCacheItem(key) et AddCacheItem(key, value) interagissent avec le cache de données, effectuant respectivement la lecture et l'écriture des valeurs. La GetCacheItem(key) méthode est la plus simple des deux. Elle se contente de retourner la valeur de la classe Cache en utilisant la clé fournie :

private object GetCacheItem(string rawKey)
{
    return HttpRuntime.Cache[GetCacheKey(rawKey)];
}
private readonly string[] MasterCacheKeyArray = {"ProductsCache"};
private string GetCacheKey(string cacheKey)
{
    return string.Concat(MasterCacheKeyArray[0], "-", cacheKey);
}

GetCacheItem(key) n’utilise pas la valeur de clé telle qu’elle est fournie, mais appelle plutôt la GetCacheKey(key) méthode, qui retourne la clé précédée de ProductsCache-. Le MasterCacheKeyArray, qui contient la chaîne ProductsCache, est également utilisé par la AddCacheItem(key, value) méthode, comme nous le verrons momentanément.

À partir d'une classe code-behind d'une page ASP.NET, le cache de données est accessible via la propriété Page de la classe Cache et permet une syntaxe comme Cache["key"] = value, comme indiqué à l'étape 2. À partir d’une classe dans l’architecture, le cache de données peut être accédé en utilisant soit HttpRuntime.Cache soit HttpContext.Current.Cache. L’entrée de blog de Peter JohnsonHttpRuntime.Cache vs. HttpContext.Current.Cache note le léger avantage de performance en utilisant HttpRuntime au lieu de HttpContext.Current; par conséquent, ProductsCL utilise HttpRuntime.

Remarque

Si votre architecture est implémentée à l’aide de projets de bibliothèque de classes, vous devez ajouter une référence à l’assembly System.Web afin d’utiliser les classes HttpRuntime et HttpContext .

Si l’élément est introuvable dans le cache, les ProductsCL méthodes de la classe obtiennent les données de la BLL et l’ajoutent au cache à l’aide de la AddCacheItem(key, value) méthode. Pour ajouter une valeur au cache, nous pourrions utiliser le code suivant qui utilise une expiration de 60 secondes :

const double CacheDuration = 60.0;
private void AddCacheItem(string rawKey, object value)
{
    HttpRuntime.Cache.Insert(GetCacheKey(rawKey), value, null, 
        DateTime.Now.AddSeconds(CacheDuration), Caching.Cache.NoSlidingExpiration);
}

DateTime.Now.AddSeconds(CacheDuration) spécifie une expiration basée sur le temps dans 60 secondes, tandis que System.Web.Caching.Cache.NoSlidingExpiration indique qu’il n’y a pas d’expiration glissante. Bien que cette Insert surcharge de méthode propose des paramètres pour une expiration soit absolue soit glissante, vous ne pouvez en fournir qu’un seul. Si vous tentez de spécifier à la fois une durée absolue et un intervalle de temps, la Insert méthode lève une ArgumentException exception.

Remarque

Cette mise en œuvre de la AddCacheItem(key, value) méthode présente actuellement des lacunes. Nous allons résoudre et surmonter ces problèmes à l’étape 4.

Étape 4 : Invalidation du cache lorsque les données sont modifiées via l’architecture

En plus des méthodes de récupération de données, la couche de mise en cache doit fournir les mêmes méthodes que la BLL pour l’insertion, la mise à jour et la suppression de données. Les méthodes de modification des données cl ne modifient pas les données mises en cache, mais appellent plutôt la méthode de modification de données correspondante de BLL, puis invalident le cache. Comme nous l’avons vu dans le tutoriel précédent, il s’agit du même comportement que celui appliqué par ObjectDataSource lorsque ses fonctionnalités de mise en cache sont activées et que ses méthodes Insert, Update, ou Delete sont appelées.

La surcharge suivante UpdateProduct montre comment implémenter les méthodes de modification des données dans le CL :

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // TODO: Invalidate the cache
    return result;
}

La méthode appropriée de modification de données de la couche de logique métier est appelée, mais avant que sa réponse ne soit retournée, nous devons invalider le cache. Malheureusement, l’invalidation du cache n’est pas simple, car les ProductsCL classes et GetProducts()GetProductsByCategoryID(categoryID) méthodes ajoutent chacun des éléments au cache avec des clés différentes, et la GetProductsByCategoryID(categoryID) méthode ajoute un élément de cache différent pour chaque ID de catégorie unique.

Lors de l’invalidation du cache, nous devons supprimer tous les éléments qui ont peut-être été ajoutés par la ProductsCL classe. Pour ce faire, associez une dépendance de cache à chaque élément ajouté au cache dans la AddCacheItem(key, value) méthode. En général, une dépendance de cache peut être un autre élément dans le cache, un fichier sur le système de fichiers ou des données d’une base de données Microsoft SQL Server. Lorsque la dépendance change ou est supprimée du cache, les éléments de cache auxquels il est associé sont automatiquement supprimés du cache. Pour ce tutoriel, nous voulons créer un élément supplémentaire dans le cache qui sert de dépendance de cache pour tous les éléments ajoutés via la ProductsCL classe. Ainsi, tous ces éléments peuvent être supprimés du cache en supprimant simplement la dépendance du cache.

Nous allons mettre à jour la AddCacheItem(key, value) méthode afin que chaque élément ajouté au cache par le biais de cette méthode soit associé à une dépendance de cache unique :

private void AddCacheItem(string rawKey, object value)
{
    System.Web.Caching.Cache DataCache = HttpRuntime.Cache;
    // Make sure MasterCacheKeyArray[0] is in the cache - if not, add it
    if (DataCache[MasterCacheKeyArray[0]] == null)
        DataCache[MasterCacheKeyArray[0]] = DateTime.Now;
    // Add a CacheDependency
    System.Web.Caching.CacheDependency dependency = 
        new CacheDependency(null, MasterCacheKeyArray);
    DataCache.Insert(GetCacheKey(rawKey), value, dependency, 
        DateTime.Now.AddSeconds(CacheDuration), 
        System.Web.Caching.Cache.NoSlidingExpiration);
}

MasterCacheKeyArray est un tableau de chaînes qui contient une valeur unique, ProductsCache. Tout d’abord, un élément de cache est ajouté au cache et affecté la date et l’heure actuelles. Si l’élément de cache existe déjà, il est mis à jour. Ensuite, une dépendance de cache est créée. Le constructeur de la classe CacheDependency a un certain nombre de surcharges, mais celui utilisé ici attend deux tableaux string en entrée. Le premier spécifie le jeu de fichiers à utiliser comme dépendances. Étant donné que nous ne voulons pas utiliser de dépendances basées sur des fichiers, une valeur est null utilisée pour le premier paramètre d’entrée. Le deuxième paramètre d’entrée spécifie l’ensemble de clés de cache à utiliser comme dépendances. Ici, nous spécifions notre dépendance unique. MasterCacheKeyArray Il CacheDependency est ensuite passé dans la méthode Insert.

Avec cette modification de AddCacheItem(key, value), l'invalidation du cache est aussi simple que la suppression de la dépendance.

[System.ComponentModel.DataObjectMethodAttribute(DataObjectMethodType.Update, false)]
public bool UpdateProduct(string productName, decimal? unitPrice, int productID)
{
    bool result = API.UpdateProduct(productName, unitPrice, productID);
    // Invalidate the cache
    InvalidateCache();
    return result;
}
public void InvalidateCache()
{
    // Remove the cache dependency
    HttpRuntime.Cache.Remove(MasterCacheKeyArray[0]);
}

Étape 5 : Appel de la couche de mise en cache à partir de la couche Présentation

Les classes et méthodes de la couche de mise en cache peuvent être utilisées pour travailler avec des données à l’aide des techniques que nous avons examinées dans ces didacticiels. Pour illustrer l’utilisation des données mises en cache, enregistrez vos modifications dans la ProductsCL classe, puis ouvrez la FromTheArchitecture.aspx page dans le Caching dossier et ajoutez un GridView. À partir de la balise intelligente GridView, créez un ObjectDataSource. Dans la première étape de l'Assistant, vous devez voir la classe ProductsCL comme l'une des options de la liste déroulante.

Figure 4 : La ProductsCL classe est incluse dans la liste des Drop-Down objet métier (cliquez pour afficher l’image de taille complète)

Après avoir ProductsCLsélectionné, cliquez sur Suivant. La liste déroulante de l’onglet SELECT comporte deux éléments : GetProducts() et GetProductsByCategoryID(categoryID), et l’onglet UPDATE a la seule surcharge UpdateProduct. Choisissez la GetProducts() méthode sous l’onglet SELECT et la UpdateProducts méthode de l’onglet UPDATE, puis cliquez sur Terminer.

Figure 5 : Les ProductsCL méthodes de classe sont répertoriées dans les listes de Drop-Down (cliquez pour afficher l’image de taille complète)

Une fois l’Assistant terminé, Visual Studio définit la propriété ObjectDataSource OldValuesParameterFormatString sur original_{0} et ajoute les champs appropriés à GridView. Remettez la propriété OldValuesParameterFormatString à sa valeur par défaut, {0}, puis configurez le GridView pour prendre en charge la pagination, le tri et la modification. Étant donné que la UploadProducts surcharge utilisée par le CL accepte uniquement le nom et le prix du produit modifié, limitez gridView afin que seuls ces champs soient modifiables.

Dans le tutoriel précédent, nous avons défini un GridView pour inclure des champs pour les ProductName, CategoryName et UnitPrice. N’hésitez pas à répliquer cette mise en forme et cette structure, auquel cas votre balisage déclaratif 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:RequiredFieldValidator ID="RequiredFieldValidator1"
                    ControlToValidate="ProductName" Display="Dynamic" 
                    ErrorMessage="You must provide a name for the product." 
                    SetFocusOnError="True"
                    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" runat="server" 
                    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" 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="ProductsCL" UpdateMethod="UpdateProduct">
    <UpdateParameters>
        <asp:Parameter Name="productName" Type="String" />
        <asp:Parameter Name="unitPrice" Type="Decimal" />
        <asp:Parameter Name="productID" Type="Int32" />
    </UpdateParameters>
</asp:ObjectDataSource>

À ce stade, nous avons une page qui utilise la couche de mise en cache. Pour voir le cache en action, définissez des points d’arrêt dans les classes ProductsCL et les méthodes GetProducts(). Visitez la page dans un navigateur et parcourez le code lors du tri et de la pagination pour voir les données extraites du cache. Ensuite, mettez à jour un enregistrement et notez que le cache est invalidé et, par conséquent, il est récupéré à partir de la BLL lorsque les données sont récupérées vers GridView.

Remarque

La couche de mise en cache fournie dans le téléchargement qui accompagne cet article n’est pas terminée. Il ne contient qu’une seule classe, ProductsCL, qui possède seulement une poignée de méthodes. En outre, seule une seule page ASP.NET utilise le CL (~/Caching/FromTheArchitecture.aspx) tous les autres encore référencent directement la BLL. Si vous envisagez d’utiliser un CL dans votre application, tous les appels de la couche Présentation doivent accéder au CL, ce qui exigerait que les classes et méthodes CL couvrent ces classes et méthodes dans la BLL actuellement utilisée par la couche Présentation.

Résumé

Bien que la mise en cache puisse être appliquée dans la couche de Présentation avec les contrôles SqlDataSource et ObjectDataSource d'ASP.NET 2.0, idéalement, les responsabilités de mise en cache devraient être déléguées à une couche distincte dans l'architecture. Dans ce tutoriel, nous avons créé une couche de mise en cache qui réside entre la couche Présentation et la couche logique métier. La couche de mise en cache doit fournir le même ensemble de classes et de méthodes qui existent dans la BLL et qui sont appelées à partir de la couche Présentation.

Les exemples de couche de mise en cache que nous avons explorés dans ce didacticiel et les didacticiels précédents ont présenté un chargement réactif. Avec le chargement réactif, les données sont chargées dans le cache uniquement lorsqu’une demande de données est effectuée et que ces données sont manquantes dans le cache. Les données peuvent également être chargées de manière proactive dans le cache, une technique qui charge les données dans le cache avant qu’elles ne soient réellement nécessaires. Dans le tutoriel suivant, nous allons voir un exemple de chargement proactif lorsque nous examinons comment stocker des valeurs statiques dans le cache au démarrage de l’application.

Bonne programmation !

À propos de l’auteur

Scott Mitchell, auteur de sept livres ASP/ASP.NET et fondateur de 4GuysFromRolla.com, travaille avec les technologies Web Microsoft depuis 1998. Scott travaille en tant que consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 en 24 heures. On peut le contacter à 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 Murph. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com.

Précédent Suivant