Verwendung von IMemoryCache in .NET

• .NET

Samstag, 20. August 2022 - Matt

Caching ist eine wichtige Technik, um die Leistung und Skalierbarkeit von Anwendungen zu verbessern. In .NET bietet die IMemoryCache-Schnittstelle eine moderne und flexible Möglichkeit, Daten im Speicher zwischenzuspeichern. Hier geht es um IMemoryCache, dazu ein Blick auf die ältere MemoryCache-Klasse für alle, die sie noch im Einsatz haben.

Was ist IMemoryCache?

IMemoryCache ist eine Schnittstelle im Namespace Microsoft.Extensions.Caching.Memory, die eine im Speicher basierte Implementierung eines Caches bietet. Sie ermöglicht das Speichern von Daten im Speicher, um schnelle Zugriffe auf häufig benötigte Daten zu ermöglichen und somit die Leistung der Anwendung zu verbessern.

Vorteile von IMemoryCache

1. Leistung: Schneller Zugriff auf zwischengespeicherte Daten, da sie im Speicher gehalten werden.
2. Einfachheit: Einfach zu verwenden und in bestehende Anwendungen zu integrieren.
3. Flexibilität: Unterstützt verschiedene Konfigurationsoptionen wie Ablaufzeiten und Cache-Prioritäten.
4. Integrierte DI-Unterstützung: Kann leicht in ASP.NET Core-Anwendungen über Dependency Injection integriert werden.

Ein einfaches Beispiel

Hier ist ein einfaches Beispiel, wie man IMemoryCache in einer .NET-Anwendung verwenden kann:

Schritt 1: Paket hinzufügen

Stelle sicher, dass dein Projekt eine Referenz auf Microsoft.Extensions.Caching.Memory hat. Füge das NuGet-Paket hinzu, falls es noch nicht vorhanden ist:

__sh dotnet add package Microsoft.Extensions.Caching.Memory __

Schritt 2: IMemoryCache konfigurieren

In einer ASP.NET Core-Anwendung kannst du IMemoryCache in Startup.cs konfigurieren:

__csharp public void ConfigureServices(IServiceCollection services) { services.AddMemoryCache(); services.AddControllers(); } __

Schritt 3: IMemoryCache verwenden

Erstelle einen Controller, der IMemoryCache verwendet:

___csharp using Microsoft.AspNetCore.Mvc; using Microsoft.Extensions.Caching.Memory;

[ApiController] [Route(“[controller]”)] public class CacheController : ControllerBase { private readonly IMemoryCache _memoryCache;

public CacheController(IMemoryCache memoryCache)
{
    _memoryCache = memoryCache;
}

[HttpGet("{key}")]
public IActionResult Get(string key)
{
    if (_memoryCache.TryGetValue(key, out string value))
    {
        return Ok(new { key, value });
    }
    return NotFound();
}

[HttpPost("{key}")]
public IActionResult Post(string key, [FromBody] string value)
{
    var cacheEntryOptions = new MemoryCacheEntryOptions()
        .SetSlidingExpiration(TimeSpan.FromMinutes(5))
        .SetAbsoluteExpiration(TimeSpan.FromHours(1));

    _memoryCache.Set(key, value, cacheEntryOptions);
    return Ok(new { key, value });
} } ___

In diesem Beispiel wird IMemoryCache verwendet, um Daten im Speicher zu speichern und abzurufen. Die Cache-Einträge haben eine gleitende Ablaufzeit von 5 Minuten und eine absolute Ablaufzeit von 1 Stunde.

Erweiterte Optionen

Ablaufzeiten und Prioritäten

Beim Hinzufügen von Daten zum Cache können Ablaufzeiten und Prioritäten festgelegt werden:

___csharp var cacheEntryOptions = new MemoryCacheEntryOptions() .SetSlidingExpiration(TimeSpan.FromMinutes(5)) .SetAbsoluteExpiration(TimeSpan.FromHours(1)) .SetPriority(CacheItemPriority.High);

memoryCache.Set(key, value, cacheEntryOptions); __

Cache-Abhängigkeiten

Du kannst auch Cache-Abhängigkeiten konfigurieren, um Einträge basierend auf Änderungen an anderen Einträgen zu entfernen:

___csharp var cacheEntryOptions = new MemoryCacheEntryOptions() .AddExpirationToken(new CancellationChangeToken(tokenSource.Token));

memoryCache.Set(key, value, cacheEntryOptions); __

Verweis auf MemoryCache

Für diejenigen, die mit der älteren MemoryCache-Klasse aus System.Runtime.Caching vertraut sind, bietet IMemoryCache eine modernere und flexiblere API. MemoryCache wird weiterhin unterstützt und ist für bestimmte Szenarien nützlich, insbesondere wenn du bereits bestehende Anwendungen hast, die diese Klasse verwenden.

Fazit

IMemoryCache reicht für alles, was im Speicher eines einzelnen Prozesses liegen darf. Sobald mehrere Instanzen laufen, braucht es einen verteilten Cache. Bis dahin ist es die einfachste Lösung, die ohnehin schon im Framework steckt.

Für weitere Details und eine ausführliche Anleitung besuche die offizielle Microsoft-Dokumentation.

Weiterführend zu Caching-Strategien: Zwischenspeichern in .NET.