Verwendung von IMemoryCache in .NET

20 Aug 2022 - Matthias Voigt

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. In diesem Artikel erkläre ich, wie man IMemoryCache in .NET verwendet, um Caching zu implementieren, und verweise auf die ältere MemoryCache-Klasse für diejenigen, die mit ihr vertraut sind.

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 bietet eine leistungsstarke und flexible Möglichkeit, Daten im Speicher zwischenzuspeichern. Mit seinen zahlreichen Konfigurationsoptionen und der nahtlosen Integration in ASP.NET Core ist es eine ausgezeichnete Wahl für moderne .NET-Anwendungen. Es lohnt sich, die Möglichkeiten von IMemoryCache in zukünftigen Projekten zu erkunden und zu nutzen.

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