Gyorsítótár a memóriában az ASP.NET Core-ban

Rick Anderson, John Luo és Steve Smith

A gyorsítótárazás jelentősen javíthatja az alkalmazások teljesítményét és méretezhetőségét a tartalom létrehozásához szükséges munka csökkentésével. A gyorsítótárazás akkor működik a legjobban, ha az adatok ritkán változnak és költséges a létrehozásuk. Az adatok másolatát készíti el a gyorsítótárazás, ami sokkal gyorsabban visszaadható, mint az eredeti forrásból. Az alkalmazásokat úgy kell írni és tesztelni, hogy soha ne függjenek a gyorsítótárazott adatoktól.

ASP.NET Core számos különböző gyorsítótárat támogat. A legegyszerűbb gyorsítótár a IMemoryCache interfészen alapul. IMemoryCache a webkiszolgáló memóriájában tárolt gyorsítótárat jelöli. A szerverfarmon (több kiszolgálón) futó alkalmazásoknak biztosítaniuk kell, hogy a munkamenetek ragadósak legyenek a memóriában történő gyorsítótárazás során. A ragadós munkamenetek biztosítják, hogy az ügyféltől érkező kérések mind ugyanarra a kiszolgálóra menjenek. Egy Azure-webalkalmazás például az Microsoft application request Routing (ARR) használatával irányítja az összes kérést ugyanarra a kiszolgálóra.

A webfarmok nem ragadós munkamenetei az elosztott gyorsítótárat igénylik a gyorsítótár konzisztenciájával kapcsolatos problémák elkerülése érdekében. Egyes alkalmazások esetében az elosztott gyorsítótárak nagyobb mértékű felskálázást támogatnak, mint a memóriabeli gyorsítótárak. Elosztott gyorsítótár használata kiosztja a gyorsítótár memóriáját egy külső folyamatba.

A memóriabeli gyorsítótár bármilyen objektumot tárolhat. Az elosztott gyorsítótár-illesztő korlátozva a byte[]-re. A memóriabeli és az elosztott gyorsítótár kulcs-érték párként tárolja a gyorsítótár elemeit.

Használja a System.Runtime.Caching/MemoryCache-t

System.Runtime.Caching / MemoryCache (NuGet-csomag) a következőkkel használható:

• .NET Standard 2.0 vagy újabb verzió
• Minden .NET implementáció, amely .NET Standard 2.0-s vagy újabb verziót célozza (például ASP.NET Core 3.1 vagy újabb)
• .NET-keretrendszer 4.5-ös vagy újabb verziója

Microsoft.Extensions.Caching.Memory/IMemoryCache (ebben a cikkben ismertetett) ajánlott a System.Runtime.Caching/MemoryCache helyett, mert jobb integrációt biztosít az ASP.NET Core-ral. Például IMemoryCache natív módon működik ASP.NET Core függőséginjektálással.

Kompatibilitási hídként használható System.Runtime.Caching/MemoryCache a kód ASP.NET 4.x-ből ASP.NET Core-ba történő portolásához.

A memóriabeli gyorsítótárazással kapcsolatos irányelvek áttekintése

A memóriabeli gyorsítótárazásra az alábbi irányelvek vonatkoznak:

• A kódnak mindig rendelkeznie kell tartalék beállítással az adatok lekéréséhez, és nem függ a gyorsítótárazott érték rendelkezésre állásától.

• A gyorsítótár memóriát használ, ami szűkös erőforrás. A gyorsítótár növekedésének korlátozása:

  • Ne szúrjon be külső bemenetet a gyorsítótárba. Például nem ajánlott tetszőleges, felhasználó által megadott bemenetet gyorsítótárkulcsként használni, mert a bemenet kiszámíthatatlan mennyiségű memóriát használhat fel.

  • A gyorsítótár növekedésének korlátozásához használjon lejáratokat.

  • A Gyorsítótár méretének korlátozásához használja a SetSize, a Size és a SizeLimit parancsot. Az ASP.NET Core futtatókörnyezet nem korlátozza a gyorsítótár méretét memóriaterhelés alapján. A fejlesztő felelős a gyorsítótár méretének korlátozásáért.

IMemoryCache-példány létrehozása

A memóriabeli gyorsítótárazás egy szolgáltatás, amelyet az alkalmazás függőségi injektálás segítségével hivatkozik meg.

Warning

Ha ugyanazt a gyorsítótárat több keretrendszer vagy tár használja, az egy megosztott gyorsítótár. Ha megosztott memóriagyorsítótárat használ a dependency injection segítségével, és SetSize, Size, valamint SizeLimit-t is alkalmaz a gyorsítótár méretének korlátozására, az alkalmazás meghibásodhat.

Ha a gyorsítótárban méretkorlát van beállítva, az összes bejegyzésnek meg kell adnia a méretet a hozzáadásukkor. Ez a megközelítés problémákhoz vezethet, mert előfordulhat, hogy a fejlesztők nem tudják teljes mértékben szabályozni, hogy mi használja a megosztott gyorsítótárat.

A gyorsítótár méretének SetSize metódussal, a Size tulajdonsággal vagy a SizeLimit tulajdonsággal történő korlátozásához hozzon létre egy singleton-t a gyorsítótárazáshoz. További információ és példa: A SetSize, a Size és a SizeLimit használata a gyorsítótár méretének korlátozásához.

Kérje le a példányt IMemoryCache a konstruktorban:

public class IndexModel : PageModel
{
    private readonly IMemoryCache _memoryCache;

    public IndexModel(IMemoryCache memoryCache) =>
        _memoryCache = memoryCache;

    // ...

Az alábbi kód a TryGetValue metódus használatával ellenőrzi, hogy van-e idő a gyorsítótárban. Ha egy időpont nincs gyorsítótárazva, a rendszer létrehoz egy új bejegyzést, és hozzáadja a gyorsítótárhoz a Set következő módszerrel:

public void OnGet()
{
    CurrentDateTime = DateTime.Now;

    if (!_memoryCache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
    {
        cacheValue = CurrentDateTime;

        var cacheEntryOptions = new MemoryCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(3));

        _memoryCache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
    }

    CacheCurrentDateTime = cacheValue;
}

Az előző kódban a gyorsítótár-bejegyzés három másodperces csúszó lejárati idővel lett konfigurálva. Ha a gyorsítótár-bejegyzés 3 másodpercnél hosszabb ideig nem érhető el, a bejegyzés ki lesz távolítva a gyorsítótárból. A gyorsítótár-bejegyzés minden elérésekor további 3 másodpercig a gyorsítótárban marad. Az CacheKeys osztály a letöltési minta része.

Az aktuális és a gyorsítótárazott idő jelenik meg:

<ul>
    <li>Current Time: @Model.CurrentDateTime</li>
    <li>Cached Time: @Model.CacheCurrentDateTime</li>
</ul>

A következő kód a Set bővítménymetódus használatával gyorsítótárazza az adatokat egy relatív időtartamra e nélkül MemoryCacheEntryOptions.

_memoryCache.Set(CacheKeys.Entry, DateTime.Now, TimeSpan.FromDays(1));

Az előző kódban a gyorsítótár-bejegyzés egy nap relatív lejáratával van konfigurálva. A gyorsítótár-bejegyzést a rendszer egy nap elteltével kiüríti a gyorsítótárból, még akkor is, ha a bejegyzés az időtúllépési időszak alatt érhető el.

Az alábbi kód a GetOrCreate és GetOrCreateAsync metódusok használatával gyorsítótárazza az adatokat.

public void OnGetCacheGetOrCreate()
{
    var cachedValue = _memoryCache.GetOrCreate(
        CacheKeys.Entry,
        cacheEntry =>
        {
            cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
            return DateTime.Now;
        });

    // ...
}

public async Task OnGetCacheGetOrCreateAsync()
{
    var cachedValue = await _memoryCache.GetOrCreateAsync(
        CacheKeys.Entry,
        cacheEntry =>
        {
            cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
            return Task.FromResult(DateTime.Now);
        });

    // ...
}

A következő kód meghívja a(z) Get metódust a gyorsítótárazott idő beolvasásához.

var cacheEntry = _memoryCache.Get<DateTime?>(CacheKeys.Entry);

A következő kód egy gyorsítótárazott elemet kap vagy hoz létre abszolút lejárati idővel.

var cachedValue = _memoryCache.GetOrCreate(
    CacheKeys.Entry,
    cacheEntry =>
    {
        cacheEntry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20);
        return DateTime.Now;
    });

A csak csúszó lejárattal rendelkező gyorsítótárazott elemek esetében fennáll a veszélye annak, hogy soha nem jár le. Ha a gyorsítótárazott elemet a csúszó lejárati időszakon belül ismételten elérik, az elem soha nem jár le. A csúszó lejárat és az abszolút lejárat kombinációja garantálja az elem lejáratát. Az abszolút lejárat határozza meg az elem tárolási idejének felső határát. Továbbra is lehetővé teszi, hogy az elem korábban lejárjon, ha az elem nem kérhető le a csúszásos lejárati időközön belül. Ha a csúszó lejárati időköz vagy az abszolút lejárati idő lejár, a rendszer kizárja az elemet a gyorsítótárból.

Az alábbi kód lekér egy gyorsítótárba helyezett elemet, vagy létrehoz egyet csúszó és abszolút lejárattal.

var cachedValue = _memoryCache.GetOrCreate(
    CacheKeys.CallbackEntry,
    cacheEntry =>
    {
        cacheEntry.SlidingExpiration = TimeSpan.FromSeconds(3);
        cacheEntry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(20);
        return DateTime.Now;
    });

Az előző kód garantálja, hogy az adatok gyorsítótárazása nem történik meg a megadott időtartamnál hosszabb ideig.

GetOrCreate, GetOrCreateAsyncés Get az osztályban a CacheExtensions bővítménymetelyek. Ezek a metódusok kibővítik a IMemoryCache képességeit.

MemoryCacheEntryOptions létrehozása bejegyzéshez

Az alábbi példa megmutatja, hogyan hozható létre MemoryCacheEntryOptions egy bejegyzés. A kód a következő feladatokat hajtja végre:

• A gyorsítótár prioritását a következőre CacheItemPriority.NeverRemoveállítja: .

• Beállít egy PostEvictionDelegate hívást, miután a bejegyzést kiürítette a gyorsítótárból. A visszahívás egy másik szálon fut, mint a kód, amely eltávolítja az elemet a gyorsítótárból.

public void OnGetCacheRegisterPostEvictionCallback()
{
    var memoryCacheEntryOptions = new MemoryCacheEntryOptions()
        .SetPriority(CacheItemPriority.NeverRemove)
        .RegisterPostEvictionCallback(PostEvictionCallback, _memoryCache);

    _memoryCache.Set(CacheKeys.CallbackEntry, DateTime.Now, memoryCacheEntryOptions);
}

private static void PostEvictionCallback(
    object cacheKey, object cacheValue, EvictionReason evictionReason, object state)
{
    var memoryCache = (IMemoryCache)state;

    memoryCache.Set(
        CacheKeys.CallbackMessage,
        $"Entry {cacheKey} was evicted: {evictionReason}.");
}

Gyorsítótár méretének korlátozása a SetSize, a Size és a SizeLimit használatával

A MemoryCache példány opcionálisan megadhatja és kikényszerítheti a méretkorlátot. A gyorsítótár méretkorlátja nem rendelkezik meghatározott mértékegységekkel, mert a gyorsítótár nem rendelkezik a bejegyzések méretének mérésére szolgáló mechanizmussal. Ha a gyorsítótár méretkorlátja be van állítva, minden bejegyzésnek meg kell adnia a méretet. A ASP.NET Core-futtatókörnyezet nem korlátozza a gyorsítótár méretét a memóriaterhelés alapján. A gyorsítótár méretének korlátozása a fejlesztőn múlik. A megadott méret a fejlesztő által választott egységekben van megadva.

Például:

• Ha a webalkalmazás elsősorban karakterláncokat gyorsítótáraz, akkor a gyorsítótár minden egyes bejegyzésének mérete lehet a karakterlánc hossza.
• Az alkalmazás az összes bejegyzés méretét 1-ként adhatja meg, a méretkorlát pedig a bejegyzések száma.

Ha a SizeLimit tulajdonság nincs beállítva, a gyorsítótár kötöttség nélkül nő. A ASP.NET Core-futtatókörnyezet nem csökkenti a gyorsítótárat, ha a rendszermemória alacsony. Az alkalmazásokat a következőre kell létrehozni:

• Korlátozza a gyorsítótár növekedését.
• Hívja meg a metódust Compact , Remove ha a rendelkezésre álló memória korlátozott.

Az alábbi kód létrehoz egy egység nélküli rögzített méretű MemoryCache példányt, amely függőséginjektálással érhető el:

public class MyMemoryCache
{
    public MemoryCache Cache { get; } = new MemoryCache(
        new MemoryCacheOptions
        {
            SizeLimit = 1024
        });
}

A SizeLimit tulajdonság nem rendelkezik egységekkel. A gyorsítótárazott bejegyzéseknek meg kell adniuk a méretet minden olyan egységben, amelyet a gyorsítótár méretkorlátjának beállításakor a legmegfelelőbbnek tartanak. A gyorsítótárpéldány minden felhasználójának ugyanazt az egységrendszert kell használnia. A bejegyzés nem lesz gyorsítótárazva, ha a gyorsítótárazott bejegyzésméretek összege meghaladja a megadott SizeLimitértéket. Ha nincs gyorsítótárméretkorlát beállítva, a rendszer figyelmen kívül hagyja a bejegyzés gyorsítótárméret-beállítását.

A következő kód regisztrálja a MyMemoryCache példányt a függőséginjektálási tárolóban.

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddSingleton<MyMemoryCache>();

MyMemoryCache független memória-gyorsítótárként kerül megszervezésre olyan összetevők számára, amelyek tisztában vannak ezzel a méretkorlátos gyorsítótárral, és tudják, hogyan lehet megfelelően beállítani a gyorsítótár-bejegyzés méretét.

A gyorsítótár-bejegyzés mérete a bővítménymetódus vagy a SetSizeSize tulajdonság használatával állítható be:

if (!_myMemoryCache.Cache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
{
    var cacheEntryOptions = new MemoryCacheEntryOptions()
        .SetSize(1);

    // cacheEntryOptions.Size = 1;

    _myMemoryCache.Cache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
}

Az előző kódban a két kiemelt sor ugyanazt az eredményt éri el, mint a gyorsítótár-bejegyzés méretének beállítása. A SetSize metódus a hívások new MemoryCacheOptions()láncolásakor nyújt kényelmes megoldást.

Memóriatár elemek eltávolítása a MemoryCache.Compact segítségével

A MemoryCache.Compact metódus a gyorsítótár megadott százalékos arányát a következő sorrendben próbálja eltávolítani:

• Minden lejárt elem
• Elemek prioritás szerint, ahol először a legalacsonyabb prioritású elemek kerülnek eltávolításra
• Legutóbb használt objektumok
• A legkorábbi abszolút lejáratú elemek
• A legkorábbi csúszó lejáratú elemek

A prioritással NeverRemove ellátott rögzített elemek soha nem lesznek eltávolítva. Az alábbi kód eltávolít egy gyorsítótár-elemet, és meghívja a metódust a Compact gyorsítótárazott bejegyzések 25% eltávolítására:

_myMemoryCache.Cache.Remove(CacheKeys.Entry);
_myMemoryCache.Cache.Compact(.25);

További információt a GitHub Kompakt forrásában talál.

Gyorsítótár-bejegyzés eltávolítása lejárt függőségekkel

Az alábbi minta bemutatja, hogyan lehet lejáratni egy gyorsítótár-bejegyzést, ha egy függő bejegyzés lejár. A CancellationChangeToken hozzáadásra kerül a gyorsítótárazott elemhez. Amikor a Cancel metódust meghívja az CancellationTokenSource objektumon, a rendszer mindkét gyorsítótár-bejegyzést kiüríti:

public void OnGetCacheCreateDependent()
{
    var cancellationTokenSource = new CancellationTokenSource();

    _memoryCache.Set(
        CacheKeys.DependentCancellationTokenSource,
        cancellationTokenSource);

    using var parentCacheEntry = _memoryCache.CreateEntry(CacheKeys.Parent);

    parentCacheEntry.Value = DateTime.Now;

    _memoryCache.Set(
        CacheKeys.Child,
        DateTime.Now,
        new CancellationChangeToken(cancellationTokenSource.Token));
}

public void OnGetCacheRemoveDependent()
{
    var cancellationTokenSource = _memoryCache.Get<CancellationTokenSource>(
        CacheKeys.DependentCancellationTokenSource);

    cancellationTokenSource.Cancel();
}

Amikor egy CancellationTokenSource objektumot használ, csoportként több gyorsítótár-bejegyzést is kiüríthet. Az előző kódban található using mintával a using hatókörben létrehozott gyorsítótár-bejegyzések öröklik az eseményindítókat és a lejárati beállításokat.

A memóriabeli gyorsítótárazással kapcsolatos megjegyzések áttekintése

A memóriabeli gyorsítótárazásra az alábbi megjegyzések vonatkoznak:

• A lejárat nem zajlik a háttérben.

  Nincs olyan időzítő, amely aktívan átvizsgálja a gyorsítótárat a lejárt elemek után. A gyorsítótárban (Get, TryGetValue, Set vagy Remove útján) végzett bármely tevékenység elindíthatja a lejárt elemek háttérvizsgálatát. Az CancellationTokenSource objektum időzítőjének beállítása (a CancelAfter módszer használatával) szintén eltávolítja a bejegyzést, és elindítja a lejárt elemek vizsgálatát.

  Az alábbi példa a regisztrált token CancellationTokenSource(TimeSpan) túlterhelt konstruktorát használja. Amikor ez a token aktiválódik, azonnal eltávolítja a bejegyzést, és végrehajtja az eltávolítási visszahívásokat.

  if (!_memoryCache.TryGetValue(CacheKeys.Entry, out DateTime cacheValue))
  {
      cacheValue = DateTime.Now;
  
      var cancellationTokenSource = new CancellationTokenSource(
          TimeSpan.FromSeconds(10));
  
      var cacheEntryOptions = new MemoryCacheEntryOptions()
          .AddExpirationToken(
              new CancellationChangeToken(cancellationTokenSource.Token))
          .RegisterPostEvictionCallback((key, value, reason, state) =>
          {
              ((CancellationTokenSource)state).Dispose();
          }, cancellationTokenSource);
  
      _memoryCache.Set(CacheKeys.Entry, cacheValue, cacheEntryOptions);
  }
  

• Ha visszahívást használ a gyorsítótárelem újratöltéséhez:

  • Előfordulhat, hogy több kérés észlelheti, hogy a gyorsítótárazott kulcs értéke üres, mivel a visszahívás még nem fejeződött be.
  • Ez a megközelítés több szál által a gyorsítótárazott elem újra feltöltését eredményezheti.

• Amikor egy gyorsítótárbejegyzés (a szülő) létrehoz egy másik bejegyzést (a gyermek), a gyermek átmásolja a szülőbejegyzés lejárati jogkivonatait és az időalapú lejárati beállításokat. A gyermek nem jár le a szülőbejegyzés manuális eltávolításával vagy frissítésével.

• PostEvictionCallbacks A tulajdonság használatával megadhatja, hogy mely visszahívások aktiválhatók a gyorsítótár-bejegyzés gyorsítótárból való kizárása után.

• A legtöbb alkalmazás IMemoryCache esetében engedélyezve van. A AddMvc fájlban például a AddControllersWithViews, AddRazorPages, AddMvcCore().AddRazorViewEngine, Add{Service}, és sok más metódus meghívása lehetővé teszi IMemoryCache.

  Az olyan alkalmazások esetében, amelyek nem hívják meg az említett Add{Service} módszerek egyikét, előfordulhat, hogy meg kell hívnia a metódust AddMemoryCache a Program.cs fájlban.

Háttérgyorsítótár-frissítés használata

A gyorsítótár frissítéséhez használjon háttérszolgáltatást , például az IHostedService interfészt. A háttérszolgáltatás csak akkor tudja újrakomponensíteni a bejegyzéseket, és hozzárendelni őket a gyorsítótárhoz, ha elkészültek.

Kapcsolódó tartalom

• Mintakód megtekintése vagy letöltése (hogyan töltsd le)
• Változások észlelése változási tokenekkel az ASP.NET Core
• Válasz gyorsítótárazása az ASP.NET Core-ban