C# Academy · Lektion

Abstraktionen IDistributedCache

Cacha data på flera servrar.

Lektion 1 av 413 steg

Abstraktionen IDistributedCache är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

Varför distribuerad cachelagring?

En cache i minnet finns i en enda process, så den försvinner vid omstart och delas inte mellan servrar. En distribuerad cache finns i ett externt datalager, till exempel Redis, som alla instanser av appen kan läsa från och skriva till. Det gör cachelagringen konsekvent i en skalad distribution.

Gränssnittet IDistributedCache

ASP.NET Core abstraherar distribuerad cachelagring bakom IDistributedCache i Microsoft.Extensions.Caching.Distributed. Din kod är beroende av det här gränssnittet, inte direkt av Redis, så du kan byta implementation.

public interface IDistributedCache
{
    byte[] Get(string key);
    Task<byte[]> GetAsync(string key, CancellationToken token = default);
    void Set(string key, byte[] value, DistributedCacheEntryOptions options);
    void Remove(string key);
    void Refresh(string key);
}

Det lagrar byte

Observera att cachen lagrar byte[]. Om du vill cacha strängar eller objekt måste du serialisera dem först. För det vanliga fallet finns praktiska extension-metoder för strängar.

using Microsoft.Extensions.Caching.Distributed;

await cache.SetStringAsync("greeting", "Hello, world");
string value = await cache.GetStringAsync("greeting");

Injicera cachen

Begär IDistributedCache via konstruktorinjektion, precis som vilken annan tjänst som helst.

public class WeatherService
{
    private readonly IDistributedCache _cache;
    public WeatherService(IDistributedCache cache)
    {
        _cache = cache;
    }
}

Läsa från cachen

GetStringAsync returnerar null när nyckeln saknas eller har gått ut. Hantera alltid fallet med cachemiss.

string cached = await _cache.GetStringAsync("forecast:istanbul");
if (cached is null)
{
    // cache miss: load from source
}

Skriva till cachen

SetStringAsync lagrar ett värde med valfria alternativ för förfallotid, som vi går igenom i en senare lektion.

await _cache.SetStringAsync(
    "forecast:istanbul",
    "22C sunny",
    new DistributedCacheEntryOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
    });

Ta bort och uppdatera

RemoveAsync tar bort en nyckel ur cachen, till exempel när underliggande data ändras. RefreshAsync återställer en glidande förfallotid utan att ändra värdet.

await _cache.RemoveAsync("forecast:istanbul");
await _cache.RefreshAsync("session:abc123");

Implementation i minnet

För utveckling eller tester kan du registrera den distribuerade cachen i minnet. Den implementerar samma gränssnitt, så din kod förblir identisk, men data delas inte faktiskt mellan processer.

builder.Services.AddDistributedMemoryCache();

Leverantörsoberoende kod

Eftersom du bara är beroende av IDistributedCache kan du byta från leverantören i minnet till Redis eller SQL Server genom att ändra en rad i registreringen, utan att ändra någon kod i dina tjänster.

Konventioner för nyckelnamn

Använd strukturerade nycklar med namnområden, till exempel entity:id:field (exempelvis user:42:profile). Tydliga konventioner förhindrar kollisioner och gör cacheogiltigförklaring förutsägbar.

string key = $"user:{userId}:profile";

När bör man inte cacha

Cacha data som läses ofta och ändras sällan. Data som ändras mycket eller som innehåller känsliga användarspecifika uppgifter kanske inte passar, och risken med inaktuella data måste alltid vägas mot prestandavinsten.

Snabbtest

Testa abstraktionen IDistributedCache.

Besvara frågan i den interaktiva lektionen

Sammanfattning

IDistributedCache abstraherar en extern, delad cache så att varje appinstans ser samma data. Den lagrar byte[] och har GetStringAsync/SetStringAsync för strängar, samt RemoveAsync och RefreshAsync. Om du är beroende av gränssnittet förblir koden leverantörsoberoende, och du kan byta mellan AddDistributedMemoryCache och Redis genom att ändra en rad. Använd tydliga nycklar med namnområden.

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 93
Lektioner: 346

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Abstraktionen IDistributedCache” gratis?

Ja – hela texten till ”Abstraktionen IDistributedCache” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Abstraktionen IDistributedCache”?

Cacha data på flera servrar. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Abstraktionen IDistributedCache”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C# Academy