C # -Implementierungen in C # .NET

Lokaler Cache, persistenter lokaler Cache und verteilter Cache

• Der In-Memory-Cache wird in Fällen verwendet, in denen Sie den Cache nur in einem Prozess implementieren müssen. Wenn ein Prozess stirbt, stirbt der Cache damit. Wenn Sie denselben Prozess auf mehreren Servern ausführen, verfügen Sie für jeden Server über einen separaten Cache.
• Permanenter In-Process-Cache - In diesem Fall sichern Sie den Cache außerhalb des Prozessspeichers. Es kann sich in einer Datei oder in einer Datenbank befinden. Es ist komplexer als der Cache im Speicher, aber wenn Ihr Prozess neu gestartet wird, wird der Cache nicht geleert. Am besten geeignet für Fälle, in denen das Abrufen eines zwischengespeicherten Elements teuer ist und Ihr Prozess häufig neu gestartet wird.
• Verteilter Cache ist, wenn Sie einen gemeinsam genutzten Cache für mehrere Computer benötigen. Normalerweise sind dies mehrere Server. Der verteilte Cache wird in einem externen Dienst gespeichert. Dies bedeutet, dass wenn ein Server ein Cache-Element beibehalten hat, andere Server es auch verwenden können. Services wie Redis sind dafür großartig.

Primitive Implementierung

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. Ein Cache kann viel Speicherplatz beanspruchen, was letztendlich aufgrund seines Mangels und seiner Abstürze zu Ausnahmen führt.
2. Ein hoher Speicherverbrauch kann zu Speicherdruck führen (auch als GC-Druck bezeichnet ). In diesem Zustand arbeitet der Garbage Collector viel mehr als er sollte, was die Leistung verringert.
3. Der Cache muss möglicherweise aktualisiert werden, wenn sich Daten ändern. Unsere Caching-Infrastruktur muss diese Funktion unterstützen.

• Eine Absolute Expiration-Richtlinie , die ein Element nach einer festgelegten Zeit aus dem Cache entfernt, egal was passiert.
• Eine Sliding Expiration-Richtlinie , die ein Element aus dem Cache entfernt, wenn für einen bestimmten Zeitraum nicht auf es zugegriffen wurde. Das heißt, wenn ich die Ablaufzeit auf 1 Minute einstelle, bleibt das Element im Cache, während ich es alle 30 Sekunden verwende. Wenn ich es länger als eine Minute nicht benutze, wird der Artikel gelöscht.
• Größenbeschränkungsrichtlinie , die die Größe des Caches begrenzt.

Bessere Lösungen

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. Die MemoryCacheOptions wurden hinzugefügt SizeLimit. Dadurch wird unserem Cache-Container eine Richtlinie zur Größenbeschränkung hinzugefügt. Der Cache verfügt nicht über einen Mechanismus zum Messen der Größe von Datensätzen. Daher müssen wir die Größe jedes Cache-Eintrags festlegen. In diesem Fall setzen wir jedes Mal die Größe auf 1 mit SetSize(1). Dies bedeutet, dass unser Cache ein Limit von 1024 Elementen hat.
2. , ? .SetPriority (CacheItemPriority.High). : Low (), Normal (), High () NeverRemove ( ).
3. SetSlidingExpiration(TimeSpan.FromSeconds(2)) 2 . , 2 , .
4. SetAbsoluteExpiration(TimeSpan.FromSeconds(10)) 10 . , 10 , .

Probleme und fehlende Funktionen

1. Während Sie eine Größenbeschränkung festlegen können, steuert das Caching den Speicherdruck nicht. Wenn wir überwachen würden, könnten wir die Politik mit hohem Druck straffen und die Politik mit niedrigem Druck schwächen.
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));

Code-Analyse

Wann zu verwenden WaitToFinishMemoryCache

• Wenn die Erstellungszeit eines Elements einen Wert hat und Sie die Anzahl der Erstellungen so gering wie möglich halten möchten.
• Wenn die Zeit zum Erstellen eines Elements sehr lang ist.
• Wenn ein Element für jeden Schlüssel einmal erstellt werden muss.

• Es besteht keine Gefahr, dass mehrere Threads Zugriff auf dasselbe Cache-Element erhalten.
• Sie sind nicht kategorisch dagegen, Elemente mehr als einmal zu erstellen. Zum Beispiel, wenn eine zusätzliche Abfrage an die Datenbank keine großen Auswirkungen hat.

Zusammenfassung