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

Um Anwendungen reaktionsschnell und effektiv zu gestalten, 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 in diesem Zusammenhang eine wirksame Optimierungsstrategie. microsoft.Extensions.Caching.Memory" bietet eine effiziente In-Memory-Objekt-Caching-Lösung für .NET-Anwendungen. Ihre PDF-zentrierten Anwendungen werden viel schneller arbeiten und reagieren, wenn Sie den MemoryCache-Cache strategisch zusammen mit IronPDF verwenden.

Wir untersuchen, wie man das C#-Beispiel "Microsoft.Extensions.Caching.Memory" effizient in IronPDF integriert. In diesem Artikel werden wir die Vorteile des Caching in Bezug auf die PDF-Erzeugung prozess, einige nützliche Tipps zur Implementierung und eine detaillierte Anleitung zur Konfiguration des Caching in Ihrem IronPDF-Programm. 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 Caching 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" ist eine der vielen Caching-Optionen, die verfügbar sind. caching.Memory" ist eine besonders leistungsfähige und anpassungsfähige Option. Diese Bibliothek ist eine Komponente des größeren Namespace "Microsoft.Extensions.Caching" und bietet einen einfachen, aber effektiven Ansatz für das Caching im Speicher.

Schlüsseltypen innerhalb von "Microsofts.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.

speicherCache

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

speicherCacheEintragOptionen

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

• Verfall: Sie können gleitende Verfallsfenster konfigurieren (wobei der Eintrag verfällt, wenn er nicht innerhalb eines bestimmten Zeitraums aufgerufen wird) oder absolute Verfallszeiten (wo 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.

cacheEintrag

• 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.
• Diese Schnittstelle wird von der Klasse "CacheEntry" implementiert, die eine praktische Umsetzung dieser Funktionen bietet.

Installieren und Konfigurieren von "Microsoft.Extensions.Caching.Memory"

icrosoft.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. Die folgende Abbildung zeigt eine ASP.NET Core-Anwendung, für die "Microsoft.Extensions.Caching.Memory" konfiguriert ist:

Installieren Sie das erforderliche NuGet-Paket

Stellen Sie zunächst 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

Navigieren Sie zur Methode "ConfigureServices" in Ihrer ASP.NET Core-Anwendung, indem Sie die Datei "Startup.cs" öffnen. Fügen Sie den folgenden Code hinzu, um den Speicher-Cache-Dienst einzurichten:

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 Speicher-Cache-Systemdienst wird mit seinen Standardkonfigurationen über die Funktion "AddMemoryCache" registriert.

Inject IMemoryCache

Sobald der Cache-Speicher eingerichtet ist, kann jeder Klasse oder Komponente, die eine Zwischenspeicherung benötigt, die Schnittstelle "IMemoryCache" zugewiesen werden. 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 Schnittstelle "IMemoryCache" 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". Verwenden Sie in Ihrer ASP.NET Core-Anwendung "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 Funktion "ConfigureServices" 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 IronPDF-Dienstes HtmlToPdf als Singleton stellt dieser Code sicher, dass die Anwendung nur eine Instanz von HtmlToPdf erstellt und verwendet.

Verwendung 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 einen schnelleren Abruf zu speichern.

Dieser Quellcode und dieses Snippet veranschaulichen die grundsätzliche Verwendung:

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 für die Arbeit mit Microsoft und ASP.NET Microsoft.Extensions.Caching.Memory erforderlich sind. Wir erstellen den Controller DemoController, der von ControllerBase abgeleitet ist. Dieser Controller antwortet auf Abfragen, 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 dem [HttpGet] wird die Generate-Methode so markiert, dass sie HTTP-GET-Anfragen an den Shop von der angegebenen Route aus bearbeitet (/Demo). 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" zu verwenden, lesen Sie bitte die Dokumentation und den mitgelieferten Beispielcode. caching.Memory" wird verwendet, 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. Sie können spürbare Geschwindigkeitssteigerungen und eine verbesserte Reaktionsfähigkeit Ihrer Anwendungen erzielen, indem Sie bewährte Caching-Verfahren anwenden und "Microsoft.Extensions.Caching.Memory" in Ihre .NET-Anwendungen integrieren.

Durch die Nutzung der Funktionen von "Microsoft.Extensions". Mit Hilfe von IronPDF für die dynamische PDF-Erstellung und Caching.Memory für effektives Daten-Caching können .NET-Entwickler die Geschwindigkeit ihrer Anwendungen erheblich steigern. Diese leistungsstarke Kombination ermöglicht es Entwicklern, hochleistungsfähige, skalierbare und reaktionsschnelle Anwendungen zu entwerfen, indem sie die Serverlast verringern, die Benutzerfreundlichkeit verbessern und den Verarbeitungs-Overhead eliminieren.

IronPDF kann zu einem günstigen Preis erworben werden, und der Erwerb des Pakets beinhaltet eine lebenslange Lizenz. Das Paket bietet ein hervorragendes Preis-Leistungs-Verhältnis, da es bei $749 beginnt, einer einzigen Gebühr für mehrere Systeme. Für Benutzer mit Lizenzen bietet es rund um die Uhr technische Online-Hilfe. Weitere Informationen über die Gebühr finden Sie auf der Website website. Besuchen Sie diese website um mehr über Produkte von Iron Software zu erfahren.