Microsoft.Extensions.Caching.Memory Beispiel (mit PDF) in C#

Um Anwendungen reaktionsschnell und effektiv zu erstellen, werden häufig Optimierungsmethoden für .NET-Anwendungen benötigt. Caching ist ein wirksamer Ansatz, bei dem häufig angefordertes Material vorübergehend in einem verteilten Cache gespeichert wird, um einen schnelleren Abruf zu ermöglichen. Die Verringerung der Verarbeitungszeit und der Serverbelastung durch diese Strategie kann zu einer erheblichen Steigerung der Anwendungsleistung führen. Zusätzlich können Leistungszähler implementiert werden, um das Caching-System zu überwachen und zu verbessern.

Caching ist eine leistungsstarke Optimierungsstrategie in diesem Kontext. Microsoft.Extensions.Caching.Memory bietet eine effiziente In-Memory-Objekt-Caching-Lösung für .NET-Anwendungen. Ihre PDF-zentrierten Apps werden viel schneller arbeiten und reagieren, wenn Sie den MemoryCache-Cache strategisch zusammen mit IronPDF verwenden.

Wir untersuchen, wie man Microsoft.Extensions.Caching.Memory C#-Beispiele effizient mit IronPDF integriert. In diesem Artikel werden wir die Vorteile des Cachings im Zusammenhang mit dem IronPDF HTML-zu-PDF-Konvertierungsprozess besprechen, nützliche Implementierungstipps durchgehen und eine detaillierte Anleitung zur Konfiguration des Cachings in Ihrem IronPDF-Programm anbieten. Am Ende des Kurses verfügen Sie über die notwendigen Fähigkeiten und Ressourcen, um effektive und intuitive PDF-Anwendungen zu entwickeln.

Microsoft.Extensions.Caching.Memory: Die Grundlage des Cachings in .NET

Caching ist eine Methode, die in vielen hochleistungsfähigen .NET-Anwendungen verwendet wird, um Daten, auf die häufig zugegriffen wird, zum schnellen Abruf im Speicher zu speichern. Microsoft.Extensions sind eine der vielen Caching-Optionen, die zugänglich sind. Caching.Memory ist eine besonders starke und anpassungsfähige Option. Diese Bibliothek ist ein Bestandteil des größeren Microsoft.Extensions.Caching-Namespaces und bietet einen unkomplizierten, aber effektiven Ansatz für das In-Memory-Caching.

Haupttypen innerhalb von "Microsoft.Extensions.Caching.Memory"

IMemoryCache

• Die grundlegende Fähigkeit zur Nutzung des In-Memory-Cache wird durch diese Schnittstelle dargestellt. Es bietet die Möglichkeit, Einträge im Cache zu verwalten und sie hinzuzufügen, abzurufen und zu entfernen.
• Betrachten Sie es als Ihren primären Einstiegspunkt für Ihre Caching-Prozesse.

MemoryCache

• Die eigentliche Implementierung von IMemoryCache befindet sich in dieser Klasse. Es bietet Verwaltung und echten In-Memory-Speicher für zwischengespeicherte Elemente.
• Abhängigkeitsinjektion wird normalerweise in ASP.NET Core-Anwendungen verwendet, um eine Instanz von MemoryCache abzurufen.

MemoryCacheEntryOptions

Mit dieser Klasse können Sie Konfigurationseinstellungen für bestimmte Cache-Elemente festlegen. Diese Einstellungen regeln Dinge wie:

• Ablauf: Sie können gleitende Ablaufzeiträume konfigurieren (bei denen der Eintrag abläuft, wenn er innerhalb eines bestimmten Intervalls nicht aufgerufen wird) oder absolute Ablaufzeiten (bei denen der Eintrag automatisch abläuft).
• Priorität: Wenn der Cache voll ist, beeinflusst dies, ob Elemente entfernt werden. Einträge mit höherer Priorität haben eine geringere Chance, entfernt zu werden.
• Rückruf nach Ablauf der Gültigkeit: Damit können Sie die Logik für den Umgang mit abgelaufenen Daten feinabstimmen. Es ist besonders nützlich in Szenarien, in denen kritische Daten aktualisiert werden müssen, bei der Ressourcenverwaltung und bei der Protokollierung.

CacheEntry

• Innerhalb des Caches kennzeichnet dieser Typ einen einzelnen Eintrag. Sie bietet Methoden und Attribute zum Abrufen von Größenangaben, Ablaufeinstellungen und zwischengespeicherten Werten.
• Er enthält im Wesentlichen alle Informationen zu einem bestimmten Datenbestand, der im Cache gespeichert ist.

ICacheEntry

• Diese Schnittstelle umreißt die grundlegenden Aktivitäten, die an einem Cache-Element durchgeführt werden können, obwohl sie für grundlegende Caching-Vorgänge nicht erforderlich ist. Sie enthält Anweisungen, wie der Wert und die Ablaufdaten abgerufen werden können. Dies ist häufiger in Szenarien der Fall, in denen Sie den String-Schlüssel abrufen müssen.
• Dieses Interface wird von der CacheEntry-Klasse implementiert, die eine praktische Umsetzung dieser Funktionen bietet.

Installieren und Konfigurieren von Microsoft.Extensions.Caching.Memory

Microsoft.Extensions.Caching-Konfiguration. Während des Anwendungsstarts wird Speicher für die Konfiguration des Cache-Dienstes innerhalb der Dienstesammlung der ASP.NET Core-Anwendung verwendet. Eine ASP.NET Core-Anwendung, die Microsoft.Extensions.Caching.Memory konfiguriert hat, wird unten gezeigt:

Installieren Sie das erforderliche NuGet-Paket

Stellen Sie zuerst sicher, dass Microsoft.Extensions.Caching.Memory für Ihr Projekt installiert ist. Über die NuGet Package Manager Console können Sie es mit dem folgenden Befehl installieren:

Install-Package Microsoft.Extensions.Caching.Memory

Oder wir können NuGet Package Manager verwenden, um das Paket zu installieren:

Dienste in Startup.cs konfigurieren

Wechseln Sie zur Methode ConfigureServices in Ihrer ASP.NET Core-Anwendung, indem Sie die Datei Startup.cs öffnen. Um den Memory-Cache-Dienst einzurichten, fügen Sie den folgenden Code hinzu:

using Microsoft.Extensions.Caching.Memory;
public void ConfigureServices(IServiceCollection services)
{
    // Add memory cache service
    services.AddMemoryCache();
    // Other service configurations...
}

using Microsoft.Extensions.Caching.Memory;
public void ConfigureServices(IServiceCollection services)
{
    // Add memory cache service
    services.AddMemoryCache();
    // Other service configurations...
}

Imports Microsoft.Extensions.Caching.Memory
Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Add memory cache service
	services.AddMemoryCache()
	' Other service configurations...
End Sub

Das Memory-Cache-Dienstobjekt wird der Dienstesammlung der Anwendung hinzugefügt und durch diesen Code konfiguriert. Der Speichercache-Dienst wird mit seinen Standardkonfigurationen über die AddMemoryCache-Funktion registriert.

IMemoryCache injizieren

Sobald der Cache-Speicher eingerichtet ist, kann jede Klasse oder Komponente, die Caching benötigt, das IMemoryCache-Interface in sie injiziert bekommen. Zum Beispiel in einer Controller- oder Serviceklasse:

public class MyService
{
    private readonly IMemoryCache _cache;
    public MyService(IMemoryCache cache)
    {
        _cache = cache;
    }
    // Use _cache to perform caching operations...
}

public class MyService
{
    private readonly IMemoryCache _cache;
    public MyService(IMemoryCache cache)
    {
        _cache = cache;
    }
    // Use _cache to perform caching operations...
}

Public Class MyService
	Private ReadOnly _cache As IMemoryCache
	Public Sub New(ByVal cache As IMemoryCache)
		_cache = cache
	End Sub
	' Use _cache to perform caching operations...
End Class

Methoden zum Zwischenspeichern und Abrufen von Daten aus dem Speicher werden von der IMemoryCache-Schnittstelle bereitgestellt.

Cache-Optionen konfigurieren

Durch die Einstellung von Cache-Parametern können Sie das Verhalten des Speicher-Caches beeinflussen. Dazu gehört die Konfiguration einer Reihe von Parametern, darunter Größenbeschränkungen, Taktiken für die Räumung von Cache-Einträgen und Vorschriften für den Ablauf von Cache-Werten. Dies ist ein Beispiel für die Einstellung der Cache-Optionen:

public void ConfigureServices(IServiceCollection services)
{
    // Configure cache options
    services.AddMemoryCache(options =>
    {
        options.SizeLimit = 1024; // Set the maximum size limit for the cache
        options.CompactionPercentage = 0.75; // Set the percentage of memory to free up when the cache size exceeds the limit
        options.ExpirationScanFrequency = TimeSpan.FromMinutes(5); // Set how often the cache should scan for expired items
    });
    // Other service configurations...
}

public void ConfigureServices(IServiceCollection services)
{
    // Configure cache options
    services.AddMemoryCache(options =>
    {
        options.SizeLimit = 1024; // Set the maximum size limit for the cache
        options.CompactionPercentage = 0.75; // Set the percentage of memory to free up when the cache size exceeds the limit
        options.ExpirationScanFrequency = TimeSpan.FromMinutes(5); // Set how often the cache should scan for expired items
    });
    // Other service configurations...
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure cache options
	services.AddMemoryCache(Sub(options)
		options.SizeLimit = 1024 ' Set the maximum size limit for the cache
		options.CompactionPercentage = 0.75 ' Set the percentage of memory to free up when the cache size exceeds the limit
		options.ExpirationScanFrequency = TimeSpan.FromMinutes(5) ' Set how often the cache should scan for expired items
	End Sub)
	' Other service configurations...
End Sub

Ändern Sie die Einstellungen entsprechend den Spezifikationen Ihrer Anwendung.

Diese Anweisungen helfen Ihnen bei der Konfiguration von Microsoft.Extensions. In Ihrer ASP.NET Core-Anwendung verwenden Sie Caching.Memory. Anwendungen können so schneller und effizienter arbeiten, indem sie häufig benötigte Daten im Cache speichern und abrufen.

Erste Schritte

Was ist IronPDF?

Mit Hilfe der bekannten .NET-Bibliothek IronPDF können Programmierer PDF-Dokumente in .NET-Anwendungen erzeugen, bearbeiten und anzeigen. Die Erstellung von PDFs aus HTML-Inhalten, Fotos oder Rohdaten ist nur eine der vielen Funktionen, die es für die Arbeit mit PDFs bietet. Weitere Funktionen sind das Hinzufügen von Text, Bildern und Formen zu bereits vorhandenen PDF-Dokumenten, die Konvertierung von HTML-Seiten in PDFs und die Extraktion von Text und Bildern aus PDFs.

Im Folgenden sind einige Funktionen von IronPDF aufgeführt:

• Erstellung von PDFs aus HTML, PNGs und unbearbeiteten Daten.
• Extrahieren von Bildern und Text aus PDFs.
• Hinzufügen von PDF-Kopf- und Fußzeilen sowie Wasserzeichen.
• PDF-Dokumente mit Passwortschutz und Verschlüsselung.
• Ausfüllen von Formularen und Möglichkeiten zur digitalen Unterschrift.

Installieren Sie das NuGet-Paket

Vergewissern Sie sich, dass in Ihrem Projekt das IronPDF-Paket installiert ist. Zur Installation kann die NuGet Package Manager Console verwendet werden:

Install-Package IronPdf

Um auf die ConfigureServices-Funktion zuzugreifen, öffnen Sie die Datei Startup.cs in Ihrer ASP.NET Core-Anwendung. Um IronPDF zu konfigurieren, fügen Sie den folgenden Code ein.

using IronPdf;
public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

using IronPdf;
public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

Imports IronPdf
Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure IronPDF
	services.AddSingleton(Of HtmlToPdf)()
	' Other service configurations...
End Sub

Durch die Konfiguration des HtmlToPdf-Dienstes von IronPDF als Singleton stellt dieser Code sicher, dass die Anwendung nur eine Instanz von HtmlToPdf erstellt und verwendet.

Verwenden von Microsoft.Extensions.Caching.Memory mit IronPDF

In .NET-Anwendungen bietet Microsoft.Extensions.Caching.Memory eine praktische Möglichkeit, häufig angeforderte Daten für eine schnellere Abfrage zu speichern.

Dieser Quellcode und das Snippet veranschaulichen, wie man es grundsätzlich verwendet:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Net;
using System.Net.Http.Headers;
namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly IMemoryCache _cache;
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<DemoController > _logger;
        public DemoController(ILogger<DemoController > logger, IMemoryCache cache, HtmlToPdf htmlToPdf)
        {
            _logger = logger;
            _cache = cache;
            _htmlToPdf = htmlToPdf;
        }
        [HttpGet]
        public FileContentResult Generate()
        {
            string fileName = "Sample.pdf";
            var stream = GeneratePdf("Hello IronPDF");
            return new FileContentResult(stream, "application/octet-stream")
            {
                FileDownloadName = fileName
            };
        }
        private byte[] GeneratePdf(string htmlContent)
        {
        // object key
            string cacheKey = "GeneratedPdf";
            if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
            {
                // PDF not found in cache, generate it
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);
                pdfBytes = pdfDocument.BinaryData;
                // Cache the generated PDF with a sliding expiration of 1 hour
                _cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
            }
            return pdfBytes;
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Net;
using System.Net.Http.Headers;
namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly IMemoryCache _cache;
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<DemoController > _logger;
        public DemoController(ILogger<DemoController > logger, IMemoryCache cache, HtmlToPdf htmlToPdf)
        {
            _logger = logger;
            _cache = cache;
            _htmlToPdf = htmlToPdf;
        }
        [HttpGet]
        public FileContentResult Generate()
        {
            string fileName = "Sample.pdf";
            var stream = GeneratePdf("Hello IronPDF");
            return new FileContentResult(stream, "application/octet-stream")
            {
                FileDownloadName = fileName
            };
        }
        private byte[] GeneratePdf(string htmlContent)
        {
        // object key
            string cacheKey = "GeneratedPdf";
            if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
            {
                // PDF not found in cache, generate it
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);
                pdfBytes = pdfDocument.BinaryData;
                // Cache the generated PDF with a sliding expiration of 1 hour
                _cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
            }
            return pdfBytes;
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Caching.Memory
Imports System.Net
Imports System.Net.Http.Headers
Namespace DemoWebApplication.Controllers
	<ApiController>
	<Route("[controller]")>
	Public Class DemoController
		Inherits ControllerBase

		Private ReadOnly _cache As IMemoryCache
		Private ReadOnly _htmlToPdf As HtmlToPdf
		Private ReadOnly _logger As ILogger(Of DemoController )
		Public Sub New(ByVal logger As ILogger(Of DemoController ), ByVal cache As IMemoryCache, ByVal htmlToPdf As HtmlToPdf)
			_logger = logger
			_cache = cache
			_htmlToPdf = htmlToPdf
		End Sub
		<HttpGet>
		Public Function Generate() As FileContentResult
			Dim fileName As String = "Sample.pdf"
			Dim stream = GeneratePdf("Hello IronPDF")
			Return New FileContentResult(stream, "application/octet-stream") With {.FileDownloadName = fileName}
		End Function
		Private Function GeneratePdf(ByVal htmlContent As String) As Byte()
		' object key
			Dim cacheKey As String = "GeneratedPdf"
			Dim pdfBytes() As Byte
			If Not _cache.TryGetValue(cacheKey, pdfBytes) Then
				' PDF not found in cache, generate it
				Dim pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent)
				pdfBytes = pdfDocument.BinaryData
				' Cache the generated PDF with a sliding expiration of 1 hour
				_cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1))
			End If
			Return pdfBytes
		End Function
	End Class
End Namespace

Wir importieren die Namespaces, die erforderlich sind, um mit Microsoft und ASP.NET Microsoft.Extensions.Caching.Memory zu arbeiten. Wir erstellen den DemoController-Controller, der von ControllerBase abgeleitet ist. Dieser Controller wird auf Anfragen reagieren, die über HTTP gesendet werden. Eine Instanz von IMemoryCache wird in den Konstruktor des Controllers injiziert.

Um die Lebensdauer von Diensten, einschließlich des Speicher-Caches, zu kontrollieren, bietet ASP.NET Core eine Abhängigkeitsinjektion. Mit der [HttpGet]-Eigenschaft angewendet, wird die Generate-Methode markiert, um HTTP-GET-Anfragen an den Store von der angegebenen Route (/Demo) zu bearbeiten. Wir versuchen, die Wettervorhersagedaten aus dem Cache innerhalb der Funktion Generate mit Hilfe des angegebenen Cache-Schlüssels abzurufen. Wenn die Daten nicht verwendet werden können, weil sich ASP im Cache befindet, verwenden wir die Funktion Erzeugen, um neue Wetterdaten zu erstellen.

In einem Szenario mit mehreren Anwendungsservern sollten Sie verteiltes Caching konfigurieren, um eine konsistente Cache-Verarbeitung auf allen Servern zu gewährleisten.

Um Microsoft.Extensions.Caching.Memory zu nutzen, konsultieren Sie die Dokumentation und die bereitgestellten Beispielcodes, um Daten zwischenzuspeichern und die Leistung in ASP.NET Core-Anwendungen zu verbessern. In der Praxis können Sie die Ablaufrichtlinien, Cache-Schlüssel und das Caching-Verhalten an die Bedürfnisse Ihrer Anwendung anpassen. Die Zwischenspeicherung von Daten, deren Generierung teuer ist oder auf die häufig von mehreren Threads zugegriffen wird, kann die Benutzerfreundlichkeit insgesamt verbessern und die Antwortzeiten erheblich verkürzen.

Schlussfolgerung

Alles in allem kann Microsoft.Extensions.Caching.Memory verwendet werden, um die Skalierbarkeit und Leistung von .NET-Anwendungen zu erhöhen, insbesondere von solchen, die auf dem ASP.NET Core-Framework basieren. Entwickler können die Benutzerfreundlichkeit verbessern, die Latenzzeit minimieren und den Datenzugriff optimieren, indem sie das In-Memory-Caching nutzen. Die Bibliothek bietet eine flexible und benutzerfreundliche API für die Entwicklung von Caching-Strategien, die auf bestimmte Anwendungsanforderungen ausgerichtet sind, sei es für das Caching von Referenzdaten, Abfrageergebnissen oder berechneten Werten. Durch die Anwendung bewährter Methoden zur Zwischenspeicherung und das Hinzufügen von Microsoft.Extensions.Caching.Memory in Ihre .NET-Apps, können Sie spürbare Geschwindigkeitssteigerungen und eine verbesserte Anwendungsreaktionsfähigkeit erzielen.

Durch die Nutzung von Microsoft.Extensions-Funktionen, mithilfe von IronPDF für dynamische PDF-Erstellung und Caching.Memory für effektives Daten-Caching, können .NET-Entwickler die Geschwindigkeit ihrer Apps erheblich steigern. Diese leistungsstarke Kombination ermöglicht es Entwicklern, leistungsstarke, skalierbare und reaktionsfähige Anwendungen zu gestalten, indem sie die Serverlast reduzieren, die Benutzererfahrung verbessern und Verarbeitungsaufwand eliminieren.

IronPDF kann zu einem günstigen Preis erworben werden, und der Erwerb des Pakets beinhaltet eine lebenslange Lizenz. Das Paket bietet einen herausragenden Wert, da es bei $749 beginnt, einer einmaligen Gebühr für mehrere Systeme. Für Benutzer mit Lizenzen bietet es rund um die Uhr technische Online-Hilfe. Für weitere Informationen zu den Gebühren besuchen Sie bitte die IronPDF-Lizenzseite. Besuchen Sie diese Seite über Iron Software, um mehr über die Produkte von Iron Software zu erfahren.