C # Implementasi dalam C # .NET

Cache lokal, cache lokal persisten, dan cache terdistribusi

• In-Memory Cache digunakan untuk kasus-kasus ketika Anda hanya perlu mengimplementasikan cache dalam satu proses. Ketika sebuah proses mati, cache mati bersamanya. Jika Anda menjalankan proses yang sama di beberapa server, Anda akan memiliki cache terpisah untuk setiap server.
• Cache dalam-proses persisten - ini adalah saat Anda membuat cadangan cache di luar memori proses. Ini dapat ditemukan di file atau di database. Itu lebih kompleks daripada cache di memori, tetapi jika proses Anda restart, cache tidak memerah. Paling cocok untuk kasus-kasus di mana mendapatkan barang yang di-cache mahal dan proses Anda cenderung sering dimulai kembali.
• Cache Terdistribusi adalah ketika Anda membutuhkan cache bersama untuk beberapa mesin. Biasanya ini adalah beberapa server. Cache yang didistribusikan disimpan dalam layanan eksternal. Ini berarti bahwa jika satu server memiliki elemen cache, server lain juga dapat menggunakannya. Layanan seperti Redis sangat bagus untuk ini.

Implementasi primitif

public class NaiveCache<TItem>
{
    Dictionary<object, TItem> _cache = new Dictionary<object, TItem>();
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        if (!_cache.ContainsKey(key))
        {
            _cache[key] = createItem();
        }
        return _cache[key];
    }
}

var _avatarCache = new NaiveCache<byte[]>();
// ...
var myAvatar = _avatarCache.GetOrCreate(userId, () => _database.GetAvatar(userId));

1. Cache dapat mulai mengambil banyak memori, yang akhirnya mengarah ke pengecualian karena kekurangan dan crash.
2. Konsumsi memori yang tinggi dapat menyebabkan tekanan memori (juga dikenal sebagai Tekanan GC ). Dalam keadaan ini, pengumpul sampah bekerja lebih dari yang seharusnya, yang mengurangi kinerja.
3. Cache mungkin perlu diperbarui ketika data berubah. Infrastruktur caching kami harus mendukung fitur ini.

• Kebijakan Kedaluwarsa Absolut yang menghapus item dari cache setelah waktu yang tetap, apa pun yang terjadi.
• Kebijakan Kedaluwarsa Sliding yang menghapus item dari cache jika belum diakses selama periode waktu tertentu. Artinya, jika saya mengatur waktu kedaluwarsa menjadi 1 menit, item itu akan tetap ada di cache sementara saya menggunakannya setiap 30 detik. Jika saya tidak menggunakannya lebih dari satu menit, item tersebut akan dihapus.
• Kebijakan Batas Ukuran , yang akan membatasi ukuran cache.

Solusi yang lebih baik

System.Runtime.Caching / MemoryCache vs Microsoft.Extensions.Caching.Memory

public class SimpleMemoryCache<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        TItem cacheEntry;
        if (!_cache.TryGetValue(key, out cacheEntry)) //    .
        {
            //    ,   .
            cacheEntry = createItem();
            
            //    . 
            _cache.Set(key, cacheEntry);
        }
        return cacheEntry;
    }
}

var _avatarCache = new SimpleMemoryCache<byte[]>();
// ...
var myAvatar = _avatarCache.GetOrCreate(userId, () => _database.GetAvatar(userId));

public class MemoryCacheWithPolicy<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions()
    {
        SizeLimit = 1024
    });
 
    public TItem GetOrCreate(object key, Func<TItem> createItem)
    {
        TItem cacheEntry;
        if (!_cache.TryGetValue(key, out cacheEntry))//    .
        {
            //    ,   . 
            cacheEntry = createItem();
 
            var cacheEntryOptions = new MemoryCacheEntryOptions()
         	.SetSize(1)// 
         	//        (  )
                .SetPriority(CacheItemPriority.High)
                //       ,    .
                 .SetSlidingExpiration(TimeSpan.FromSeconds(2))
                //       ,    .
                .SetAbsoluteExpiration(TimeSpan.FromSeconds(10));
 
            //    .
            _cache.Set(key, cacheEntry, cacheEntryOptions);
        }
        return cacheEntry;
    }
}

1. MemoryCacheOptions telah ditambahkan SizeLimit. Ini menambahkan kebijakan batas ukuran ke wadah cache kami. Cache tidak memiliki mekanisme untuk mengukur ukuran catatan. Karena itu, kita perlu mengatur ukuran setiap entri cache. Dalam hal ini, setiap kali kita mengatur ukuran ke 1 dengan SetSize(1). Ini berarti bahwa cache kami akan memiliki batas 1024 elemen.
2. , ? .SetPriority (CacheItemPriority.High). : Low (), Normal (), High () NeverRemove ( ).
3. SetSlidingExpiration(TimeSpan.FromSeconds(2)) 2 . , 2 , .
4. SetAbsoluteExpiration(TimeSpan.FromSeconds(10)) 10 . , 10 , .

Masalah dan fitur yang hilang

1. Meskipun Anda dapat menetapkan batas ukuran, caching sebenarnya tidak mengontrol tekanan memori. Jika kita memonitor, kita bisa memperketat kebijakan dengan tekanan tinggi dan melemahkan kebijakan dengan rendah.
2. , . . , , , 10 . 2 , , ( ), .

public class WaitToFinishMemoryCache<TItem>
{
    private MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
    private ConcurrentDictionary<object, SemaphoreSlim> _locks = new ConcurrentDictionary<object, SemaphoreSlim>();
 
    public async Task<TItem> GetOrCreate(object key, Func<Task<TItem>> createItem)
    {
        TItem cacheEntry;
 
        if (!_cache.TryGetValue(key, out cacheEntry))//    .
        {
            SemaphoreSlim mylock = _locks.GetOrAdd(key, k => new SemaphoreSlim(1, 1));
 
            await mylock.WaitAsync();
            try
            {
                if (!_cache.TryGetValue(key, out cacheEntry))
                {
                    //    ,   .
                    cacheEntry = await createItem();
                    _cache.Set(key, cacheEntry);
                }
            }
            finally
            {
                mylock.Release();
            }
        }
        return cacheEntry;
    }
}

var _avatarCache = new WaitToFinishMemoryCache<byte[]>();
// ...
var myAvatar =
await _avatarCache.GetOrCreate(userId, async () => await _database.GetAvatar(userId));

Penguraian kode

Kapan harus digunakan WaitToFinishMemoryCache

• Ketika waktu pembuatan item memiliki nilai, dan Anda ingin meminimalkan jumlah kreasi sebanyak mungkin.
• Ketika waktu untuk membuat item sangat panjang.
• Ketika suatu item harus dibuat sekali untuk setiap tombol.

• Tidak ada bahaya bahwa banyak utas akan mendapatkan akses ke elemen cache yang sama.
• Anda tidak kategoris menentang membuat elemen lebih dari sekali. Misalnya, jika satu kueri tambahan ke database tidak terlalu memengaruhi apa pun.

Ringkasan