Cache dalam memori di ASP.NET Core

Oleh Rick Anderson, John Luo, dan Steve Smith

Penembolokan dapat secara signifikan meningkatkan performa dan skalabilitas aplikasi dengan mengurangi pekerjaan yang diperlukan untuk menghasilkan konten. Penembolokan berfungsi paling baik dengan data yang jarang berubah dan mahal untuk dihasilkan. Penembolokan membuat salinan data yang dapat dikembalikan jauh lebih cepat daripada dari sumbernya. Aplikasi harus ditulis dan diuji agar tidak pernah bergantung pada data yang di-cache.

ASP.NET Core mendukung beberapa cache yang berbeda. Cache paling sederhana didasarkan pada IMemoryCache. IMemoryCache mewakili cache yang disimpan dalam memori server web. Aplikasi yang berjalan di farm server (beberapa server) harus memastikan sesi lengket saat menggunakan cache dalam memori. Sesi tempel memastikan bahwa permintaan dari klien semuanya masuk ke server yang sama. Misalnya, aplikasi Azure Web menggunakan Perutean Permintaan Aplikasi (ARR) untuk merutekan semua permintaan ke server yang sama.

Sesi yang tidak lengket di farm web memerlukan cache terdistribusi untuk menghindari masalah konsistensi cache. Untuk beberapa aplikasi, cache terdistribusi dapat mendukung peluasan skala yang lebih tinggi daripada cache dalam memori. Menggunakan cache terdistribusi membongkar memori cache ke proses eksternal.

Cache dalam memori dapat menyimpan objek apa pun. Antarmuka cache terdistribusi terbatas pada byte[]. Item cache penyimpanan cache dalam memori dan cache terdistribusi sebagai pasangan kunci-nilai.

System.Runtime.Caching/MemoryCache

System.Runtime.Caching/MemoryCache (Paket NuGet) dapat digunakan dengan:

• .NET Standard 2.0 atau yang lebih baru.
• Implementasi .NET apa pun yang menargetkan .NET Standard 2.0 atau yang lebih baru. Misalnya, ASP.NET Core 3.1 atau yang lebih baru.
• .NET Framework 4.5 atau yang lebih baru.

Microsoft.Extensions.Caching.MemoryIMemoryCache/ (dijelaskan dalam artikel ini) direkomendasikan karena System.Runtime.Caching/MemoryCache lebih baik diintegrasikan ke dalam ASP.NET Core. Misalnya, IMemoryCache bekerja secara asli dengan injeksi dependensi inti ASP.NET.

Gunakan System.Runtime.Caching/MemoryCache sebagai jembatan kompatibilitas saat mentransfer kode dari ASP.NET 4.x ke ASP.NET Core.

Panduan cache

• Kode harus selalu memiliki opsi fallback untuk mengambil data dan tidak bergantung pada nilai cache yang tersedia.
• Cache menggunakan sumber daya yang langka, memori. Batasi pertumbuhan cache:
  • Jangan masukkan input eksternal ke dalam cache. Sebagai contoh, menggunakan input yang disediakan pengguna arbitrer sebagai kunci cache tidak disarankan karena input mungkin menggunakan jumlah memori yang tidak dapat diprediksi.
  • Gunakan kedaluwarsa untuk membatasi pertumbuhan cache.
  • Gunakan SetSize, Size, dan SizeLimit untuk membatasi ukuran cache. Runtime ASP.NET Core tidak membatasi ukuran cache berdasarkan tekanan memori. Terserah pengembang untuk membatasi ukuran cache.

Menggunakan IMemoryCache

Peringatan

Menggunakan cache memori bersama dari Injeksi Dependensi dan panggilan SetSize, , Sizeatau SizeLimit untuk membatasi ukuran cache dapat menyebabkan aplikasi gagal. Ketika batas ukuran diatur pada cache, semua entri harus menentukan ukuran saat ditambahkan. Ini dapat menyebabkan masalah karena pengembang mungkin tidak memiliki kontrol penuh tentang apa yang menggunakan cache bersama. Saat menggunakan SetSize, Size, atau SizeLimit untuk membatasi cache, buat cache singleton untuk penembolokan. Untuk informasi selengkapnya dan contohnya, lihat Menggunakan SetSize, Size, dan SizeLimit untuk membatasi ukuran cache. Cache bersama dibagikan oleh kerangka kerja atau pustaka lain.

Penembolokan dalam memori adalah layanan yang dirujuk dari aplikasi menggunakan Injeksi Dependensi. IMemoryCache Minta instans di konstruktor:

public class IndexModel : PageModel
{
    private readonly IMemoryCache _memoryCache;

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

    // ...

Kode berikut menggunakan TryGetValue untuk memeriksa apakah waktu ada di cache. Jika waktu tidak di-cache, entri baru dibuat dan ditambahkan ke cache dengan Set:

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;
}

Dalam kode sebelumnya, entri cache dikonfigurasi dengan kedaluwarsa geser tiga detik. Jika entri cache tidak diakses selama lebih dari tiga detik, entri tersebut akan dikeluarkan dari cache. Setiap kali entri cache diakses, entri tersebut tetap berada di cache selama 3 detik lebih lanjut. Kelas CacheKeys adalah bagian dari sampel unduhan.

Waktu saat ini dan waktu yang di-cache ditampilkan:

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

Kode berikut menggunakan Set metode ekstensi untuk menyimpan data untuk waktu relatif tanpa MemoryCacheEntryOptions:

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

Dalam kode sebelumnya, entri cache dikonfigurasi dengan kedaluwarsa relatif satu hari. Entri cache dikeluarkan dari cache setelah satu hari, bahkan jika diakses dalam periode batas waktu ini.

Kode berikut menggunakan GetOrCreate dan GetOrCreateAsync untuk menyimpan data.

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);
        });

    // ...
}

Kode berikut memanggil Get untuk mengambil waktu yang di-cache:

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

Kode berikut mendapatkan atau membuat item yang di-cache dengan kedaluwarsa absolut:

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

Item yang di-cache yang diatur hanya dengan kedaluwarsa geser berisiko tidak pernah kedaluwarsa. Jika item yang di-cache berulang kali diakses dalam interval kedaluwarsa geser, item tidak pernah kedaluwarsa. Gabungkan kedaluwarsa geser dengan kedaluwarsa absolut untuk menjamin item kedaluwarsa. Kedaluwarsa absolut mengatur batas atas pada berapa lama item dapat di-cache sambil tetap mengizinkan item kedaluwarsa lebih awal jika tidak diminta dalam interval kedaluwarsa geser. Jika interval kedaluwarsa geser atau waktu kedaluwarsa absolut berlalu, item dikeluarkan dari cache.

Kode berikut mendapatkan atau membuat item yang di-cache dengan geser dan kedaluwarsa absolut:

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

Kode sebelumnya menjamin data tidak akan di-cache lebih lama dari waktu absolut.

GetOrCreate, GetOrCreateAsync, dan Get adalah metode ekstensi di CacheExtensions kelas . Metode ini memperluas kemampuan IMemoryCache.

MemoryCacheEntryOptions

Lihat contoh berikut:

• Mengatur prioritas cache ke CacheItemPriority.NeverRemove.
• PostEvictionDelegate Mengatur yang dipanggil setelah entri dikeluarkan dari cache. Panggilan balik dijalankan pada utas yang berbeda dari kode yang menghapus item dari cache.

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}.");
}

Gunakan SetSize, Size, dan SizeLimit untuk membatasi ukuran cache

Instans MemoryCache dapat secara opsional menentukan dan menerapkan batas ukuran. Batas ukuran cache tidak memiliki satuan pengukuran yang ditentukan karena cache tidak memiliki mekanisme untuk mengukur ukuran entri. Jika batas ukuran cache diatur, semua entri harus menentukan ukuran. Runtime ASP.NET Core tidak membatasi ukuran cache berdasarkan tekanan memori. Terserah pengembang untuk membatasi ukuran cache. Ukuran yang ditentukan adalah dalam unit yang dipilih pengembang.

Contohnya:

• Jika aplikasi web terutama menyimpan string, setiap ukuran entri cache bisa menjadi panjang string.
• Aplikasi ini dapat menentukan ukuran semua entri sebagai 1, dan batas ukurannya adalah jumlah entri.

Jika SizeLimit tidak diatur, cache tumbuh tanpa terikat. Runtime ASP.NET Core tidak memangkas cache saat memori sistem rendah. Aplikasi harus dirancang untuk:

• Batasi pertumbuhan cache.
• Panggilan Compact atau Remove ketika memori yang tersedia terbatas.

Kode berikut membuat ukuran MemoryCache tetap tanpa unit yang dapat diakses oleh injeksi dependensi:

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

SizeLimit tidak memiliki unit. Entri cache harus menentukan ukuran dalam unit apa pun yang dianggap paling tepat jika batas ukuran cache telah ditetapkan. Semua pengguna instans cache harus menggunakan sistem unit yang sama. Entri tidak akan di-cache jika jumlah ukuran entri yang di-cache melebihi nilai yang ditentukan oleh SizeLimit. Jika tidak ada batas ukuran cache yang diatur, ukuran cache yang diatur pada entri diabaikan.

Kode berikut mendaftar MyMemoryCache dengan kontainer injeksi dependensi:

var builder = WebApplication.CreateBuilder(args);

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

MyMemoryCache dibuat sebagai cache memori independen untuk komponen yang mengetahui cache terbatas ukuran ini dan tahu cara mengatur ukuran entri cache dengan tepat.

Ukuran entri cache dapat diatur menggunakan SetSize metode ekstensi atau Size properti :

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);
}

Dalam kode sebelumnya, dua baris yang disorot mencapai hasil yang sama untuk mengatur ukuran entri cache. SetSize disediakan untuk kenyamanan saat merantai panggilan ke new MemoryCacheOptions().

MemoryCache.Compact

MemoryCache.Compact mencoba menghapus persentase cache yang ditentukan dalam urutan berikut:

• Semua item kedaluwarsa.
• Item berdasarkan prioritas. Item prioritas terendah dihapus terlebih dahulu.
• Objek yang terakhir digunakan.
• Item dengan kedaluwarsa absolut paling awal.
• Item dengan kedaluwarsa geser paling awal.

Item yang disematkan dengan prioritas NeverRemove tidak pernah dihapus. Kode berikut menghapus item cache dan panggilan Compact untuk menghapus 25% entri cache:

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

Untuk informasi selengkapnya, lihat Sumber ringkas di GitHub.

Dependensi cache

Contoh berikut menunjukkan cara kedaluwarsa entri cache jika entri dependen kedaluwarsa. CancellationChangeToken ditambahkan ke item yang di-cache. Ketika Cancel dipanggil pada CancellationTokenSource, kedua entri cache dikeluarkan:

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();
}

Menggunakan memungkinkan CancellationTokenSource beberapa entri cache dikeluarkan sebagai grup. using Dengan pola dalam kode di atas, entri cache yang dibuat di dalam using cakupan mewarisi pemicu dan pengaturan kedaluwarsa.

Catatan tambahan

• Kedaluwarsa tidak terjadi di latar belakang. Tidak ada timer yang secara aktif memindai cache untuk item yang kedaluwarsa. Setiap aktivitas pada cache (Get, Set, Remove) dapat memicu pemindaian latar belakang untuk item yang kedaluwarsa. Timer pada CancellationTokenSource (CancelAfter) juga menghapus entri dan memicu pemindaian untuk item yang kedaluwarsa. Contoh berikut menggunakan CancellationTokenSource(TimeSpan) untuk token terdaftar. Ketika token ini diaktifkan, token ini segera menghapus entri dan menembakkan panggilan balik pengeluaran:

  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);
  }
  

• Saat menggunakan panggilan balik untuk mengisi ulang item cache:

  • Beberapa permintaan dapat menemukan nilai kunci yang di-cache kosong karena panggilan balik belum selesai.
  • Ini dapat mengakibatkan beberapa utas mengisi ulang item yang di-cache.

• Ketika satu entri cache digunakan untuk membuat yang lain, anak menyalin token kedaluwarsa entri induk dan pengaturan kedaluwarsa berbasis waktu. Anak tidak kedaluwarsa oleh penghapusan manual atau pembaruan entri induk.

• Gunakan PostEvictionCallbacks untuk mengatur panggilan balik yang akan diaktifkan setelah entri cache dikeluarkan dari cache.

• Untuk sebagian besar aplikasi, IMemoryCache diaktifkan. Misalnya, memanggil AddMvc, , AddControllersWithViewsAddRazorPages, AddMvcCore().AddRazorViewEngine, dan banyak metode lain Add{Service} di Program.cs, memungkinkan IMemoryCache. Untuk aplikasi yang tidak memanggil salah satu metode sebelumnyaAdd{Service}, mungkin perlu untuk memanggil AddMemoryCache .Program.cs

Pembaruan cache latar belakang

Gunakan layanan latar belakang seperti IHostedService untuk memperbarui cache. Layanan latar belakang dapat mengolah ulang entri lalu menetapkannya ke cache hanya ketika sudah siap.

Sumber Daya Tambahan:

• Melihat atau mengunduh kode sampel (cara mengunduh)
• Penembolokan terdistribusi di ASP.NET Core
• Mendeteksi perubahan dengan token perubahan di ASP.NET Core
• Penembolokan respons di ASP.NET Core
• Middleware Penembolokan Respons di ASP.NET Core
• Pembantu Tag Cache di ASP.NET Core MVC
• Pembantu Tag Singgahan Terdistribusi di ASP.NET Core