0Pricing
C# Academy · Leçon

Politiques de cache et invalidation

Contrôlez la durée de vie et les balises du cache.

Politiques de cache et invalidation est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Stratégies nommées

Plutôt que de répéter les paramètres du cache sur chaque point de terminaison, définissez une fois des stratégies nommées réutilisables et référencez-les par leur nom.

builder.Services.AddOutputCache(options =>
{
    options.AddPolicy("Short", policy =>
        policy.Expire(TimeSpan.FromSeconds(10)));
    options.AddPolicy("Long", policy =>
        policy.Expire(TimeSpan.FromMinutes(10)));
});

Appliquer une stratégie nommée

Référencez la stratégie par son nom lors de la mise en cache d’un point de terminaison.

app.MapGet("/catalog", GetCatalog)
   .CacheOutput("Long");

Étiquettes du cache

Les étiquettes regroupent les entrées mises en cache associées afin que vous puissiez les invalider ensemble. Étiquetez un point de terminaison avec Tag dans sa stratégie.

app.MapGet("/products", GetProducts)
   .CacheOutput(policy => policy
        .Expire(TimeSpan.FromMinutes(5))
        .Tag("products"));

IOutputCacheStore

L’invalidation passe par IOutputCacheStore. Injectez-le et appelez EvictByTagAsync pour purger chaque entrée portant une étiquette.

app.MapPost("/products", async (
    Product p, AppDb db, IOutputCacheStore cache, CancellationToken ct) =>
{
    db.Products.Add(p);
    await db.SaveChangesAsync(ct);
    await cache.EvictByTagAsync("products", ct);
    return Results.Created($"/products/{p.Id}", p);
});

Pourquoi invalider lors des écritures

Une liste mise en cache devient obsolète dès que les données sous-jacentes changent. L’éviction de l’étiquette concernée lors de chaque création, modification ou suppression garantit la fraîcheur des lectures sans attendre l’expiration.

// After any mutation:
await cache.EvictByTagAsync("products", ct);

Étiquetage par ressource

Utilisez une granularité plus fine pour évincer uniquement les réponses mises en cache d’un élément, et non toute la collection.

app.MapGet("/products/{id}", GetProduct)
   .CacheOutput(policy => policy.Tag("products"));
// Evict the single item's detail + the list together
await cache.EvictByTagAsync("products", ct);

Règles de variation dans une stratégie

Combinez l’expiration, les étiquettes et les règles de variation dans une stratégie nommée afin de définir un contrat de mise en cache complet.

options.AddPolicy("ProductList", policy => policy
    .Expire(TimeSpan.FromMinutes(5))
    .Tag("products")
    .SetVaryByQuery("page", "size"));

Valeur de variation personnalisée

VaryByValue vous permet de construire la clé du cache à partir de données de requête arbitraires, comme un identifiant de locataire résolu depuis la requête.

policy.VaryByValue(context =>
    new KeyValuePair<string, string>(
        "tenant",
        context.Request.Headers["X-Tenant"].ToString()));

Éviction ou expiration

Les entrées peuvent quitter le cache de deux façons :

  • Expiration : fondée sur le temps, automatiquement via Expire.
  • Éviction : explicite, via EvictByTagAsync lorsque les données changent.

Utilisez les deux : une expiration courte comme filet de sécurité, et l’éviction pour garantir la cohérence.

// belt-and-suspenders: Expire(5min) + EvictByTag on write

Verrouillage et protection contre l’effet d’avalanche

La mise en cache des réponses regroupe par défaut les échecs de cache concurrents : lorsque de nombreuses requêtes atteignent simultanément un point de terminaison non mis en cache, une seule exécute le handler tandis que les autres attendent. Vous pouvez désactiver ce comportement avec SetLocking(false).

policy.SetLocking(false); // allow concurrent regeneration

Mise en cache des réponses distribuée

Par défaut, le stockage est en mémoire et distinct per instance. Pour plusieurs serveurs, utilisez un stockage distribué (par exemple Redis) afin que toutes les instances partagent le même cache et l’invalident de la même manière.

// Register a distributed IOutputCacheStore implementation
// (e.g. a Redis-backed package) so EvictByTag works cluster-wide

Vérification rapide

Testez votre compréhension de l’invalidation.

Récapitulatif

Vous avez découvert les stratégies de cache et l’invalidation :

  • Définissez des stratégies nommées réutilisables et appliquez-les par leur nom.
  • Les étiquettes regroupent les entrées ; IOutputCacheStore.EvictByTagAsync les purge lors des écritures.
  • Combinez l’expiration (automatique) et l’éviction (explicite).
  • Utilisez un stockage distribué pour les déploiements sur plusieurs serveurs.

Le cours sur la limitation du débit et la mise en cache est terminé.

Questions Fréquemment Posées

La leçon « Politiques de cache et invalidation » est-elle gratuite ?

Oui — le texte complet de « Politiques de cache et invalidation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Politiques de cache et invalidation » ?

Contrôlez la durée de vie et les balises du cache. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Politiques de cache et invalidation » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Algorithmes de limitation du débit
  2. Configurer le middleware de limitation du débit
  3. Bases de la mise en cache des sorties
  4. Politiques de cache et invalidation
← Retour à C# Academy