Um Anwendungen reaktionsschnell und effektiv zu konstruieren, sind für .NET-Anwendungen häufig Optimierungsmethoden erforderlich. Caching ist ein leistungsstarker Ansatz, bei dem häufig angeforderte Inhalte vorübergehend in einem verteilten Cache gespeichert werden, um eine schnellere Abrufung zu erleichtern. Die Reduzierung der Verarbeitungszeit und Serverlast mit dieser Strategie kann zu einer erheblichen Steigerung der Anwendungsleistung führen. Zusätzlich können Leistungsindikatoren implementiert werden, um das Caching-System zu überwachen und zu verbessern.
[Caching](https://en.wikipedia.org/wiki/Cache_(computing) ist in diesem Kontext eine potente Optimierungsstrategie. Microsoft.Extensions.Caching.Memory bietet eine effiziente In-Memory-Objekt-Caching-Lösung for .NET-Anwendungen. Ihre PDF-zentrierten Apps werden deutlich schneller arbeiten und reagieren, wenn Sie den MemoryCache-Cache strategisch zusammen mit IronPDF nutzen.
Wir untersuchen, wie man Microsoft.Extensions.Caching.Memory C# Beispiele effizient mit IronPDF integriert. In diesem Artikel werden wir die Vorteile von Caching im Hinblick auf den IronPDF HTML zu PDF Konvertierungsprozess besprechen, einige nützliche Implementierungstipps durchgehen und eine detaillierte Anleitung zur Konfiguration des Cachings in Ihrem IronPDF-Programm anbieten. Abschließend werden Sie die Fähigkeiten und Ressourcen haben, um effektive und intuitive PDF-Anwendungen zu entwickeln.
Microsoft.Extensions.Caching.Memory: Die Grundlage für Caching in .NETCaching ist eine Methode, die in vielen leistungsstarken .NET-Anwendungen verwendet wird, um häufig aufgerufene Daten im Speicher zu speichern und schnell abrufen zu können. Microsoft.Extensions ist 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 einfachen, aber effektiven Ansatz für In-Memory-Caching.
Microsoft.Extensions.Caching.Memory"IMemoryCacheMemoryCacheIMemoryCache befindet sich in dieser Klasse. Sie bietet Verwaltung und tatsächlichen Speichercache-Speicher für zwischengespeicherte Elemente.MemoryCache abzurufen.MemoryCacheEntryOptionsMit dieser Klasse können Sie Konfigurationseinstellungen für spezifische Cache-Elemente festlegen. Diese Einstellungen regulieren Dinge wie:
CacheEntryICacheEntryCacheEntry implementiert, die eine praktische Implementierung dieser Funktionen bietet.Microsoft.Extensions.Caching.MemoryWährend des Anwendungsstarts wird der Cache-Service innerhalb der Dienstesammlung der ASP.NET Core-Anwendung konfiguriert. Nachfolgend ist eine ASP.NET Core-Anwendung mit konfiguriertem Microsoft.Extensions.Caching.Memory dargestellt:
Stellen Sie zunächst sicher, dass Microsoft.Extensions.Caching.Memory für Ihr Projekt installiert ist. Sie können es mit dem Befehl über die NuGet-Paket-Manager-Konsole installieren:
Oder wir können den NuGet-Paket-Manager verwenden, um das Paket zu installieren:
Navigieren Sie zur ConfigureServices-Methode in Ihrer ASP.NET Core-App, indem Sie die Startup.cs-Datei öffnen. Um den Memory-Cache-Service 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...
}Imports Microsoft.Extensions.Caching.Memory
Public Sub ConfigureServices(ByVal services As IServiceCollection)
' Add memory cache service
services.AddMemoryCache()
' Other service configurations...
End SubDas Speicher-Cache-Dienstobjekt wird zur Dienstesammlung der Anwendung hinzugefügt und mit diesem Code konfiguriert. Der Memory-Cache-System-Service wird über die AddMemoryCache-Funktion mit den Standardkonfigurationen registriert.
IMemoryCacheSobald der Cache-Store eingerichtet ist, kann jede Klasse oder Komponente, die Caching benötigt, das IMemoryCache-Interface injiziert bekommen. In einer Controller- oder Serviceklasse, zum Beispiel:
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 ClassMethoden zum Cachen und Abrufen von Daten aus dem Speicher werden durch das IMemoryCache-Interface bereitgestellt.
Durch das Festlegen von Cache-Parametern können Sie das Verhalten des Speichercaches ändern, einschließlich Größenbeschränkungen, Taktiken zur Cache-Eintragsentfernung und Regeln zum Ablauf von Cache-Werten. Hier ist ein Beispiel, wie Cache-Optionen gesetzt werden:
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 SubPassen Sie die Einstellungen entsprechend den Anforderungen Ihrer Anwendung an.
Diese Anweisungen helfen Ihnen, Microsoft.Extensions.Caching.Memory in Ihrer ASP.NET Core-Anwendung zu konfigurieren, damit sie durch Speichern und Abrufen häufig zugreifbarer Daten schneller und effizienter arbeitet.
Mit der bekannten .NET-Bibliothek IronPDF können Programmierer PDF-Dokumente innerhalb von .NET-Anwendungen erstellen, bearbeiten und anzeigen. PDFs aus HTML-Inhalten, Bildern oder Rohdaten zu erstellen, ist nur eine der vielen Funktionen, die es für die Arbeit mit PDFs bietet. Weitere Funktionen umfassen das Hinzufügen von Text, Bildern und Formen zu bereits vorhandenen PDF-Dokumenten, das Konvertieren von HTML-Seiten zu PDFs sowie das Extrahieren von Text und Bildern aus PDFs.
Nachfolgend einige Funktionen von IronPDF:
Stellen Sie sicher, dass das IronPDF-Paket in Ihrem Projekt installiert ist. Die NuGet-Paket-Manager-Konsole kann zur Installation verwendet werden:
Um auf die ConfigureServices-Funktion zuzugreifen, öffnen Sie die Startup.cs-Datei in Ihrer ASP.NET Core-Anwendung. Um IronPDF zu konfigurieren, fügen Sie den folgenden Code hinzu.
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 SubDurch die Konfiguration von IronPDFs HtmlToPdf-Dienst als Singleton stellt dieser Code sicher, dass die Anwendung nur eine Instanz von HtmlToPdf erstellt und verwendet.
Microsoft.Extensions.Caching.Memory mit IronPDFIn .NET-Anwendungen bietet Microsoft.Extensions.Caching.Memory eine praktische Möglichkeit, häufig angeforderte Daten für eine schnellere Abrufung zu speichern.
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Net;
using System.Net.Http.Headers;
using IronPdf;
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
Imports IronPdf
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 NamespaceWir importieren die für die Arbeit mit Microsoft und ASP.NET erforderlichen Namespaces Microsoft.Extensions.Caching.Memory. Wir erstellen den DemoController-Controller, der von ControllerBase abgeleitet ist. Dieser Controller wird auf Anfragen antworten, die über HTTP gesendet werden. Eine Instanz von IMemoryCache wird in den Konstruktor des Controllers injiziert.
Um die Lebensdauer von Diensten zu steuern, einschließlich des Speichercaches, bietet ASP.NET Core Abhängigkeitsinjektion. Mit dem aufgebrachten [HttpGet]-Attribut ist die Generate-Methode dafür markiert, HTTP-GET-Anfragen an den Store von der vorgesehenen Route (/Demo) zu behandeln. Wir versuchen, die PDF-Daten aus dem Cache mit dem angegebenen Cache-Schlüssel abzurufen. Wenn die Daten im Cache nicht gefunden werden, verwenden wir die GeneratePdf-Funktion, um ein neues PDF zu erstellen.
In einem Szenario mit mehreren App-Servern stellen Sie sicher, dass Sie ein verteiltes Caching für eine konsistente Cache-Verwaltung über alle Server hinweg konfigurieren.
Um Microsoft.Extensions.Caching.Memory zu verwenden, konsultieren Sie die bereitgestellte Dokumentation und den Beispielcode, um Daten zu cachen 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. Das Zwischenspeichern von Daten, die teuer zu generieren sind oder häufig von mehreren Threads aufgerufen werden, kann die gesamte Benutzererfahrung verbessern und Reaktionszeiten dramatisch verkürzen.
Alles in allem kann Microsoft.Extensions.Caching.Memory genutzt werden, um die Skalierbarkeit und Leistung von .NET-Anwendungen zu erhöhen, insbesondere von Anwendungen, die auf dem ASP.NET Core-Framework basieren. Entwickler können die Benutzererfahrung verbessern, die Latenzzeit minimieren und den Datenzugriff optimieren, indem sie Speichervorgänge im Speicher nutzen. Die Bibliothek bietet eine flexible und benutzerfreundliche API zur Entwicklung von Caching-Strategien, die gezielt auf spezielle Anwendungsanforderungen ausgerichtet sind, sei es für das Caching von Referenzdaten, Abfrageergebnissen oder berechneten Werten. Sie können durch die Annahme von Caching-Best-Practices und die Einbindung von Microsoft.Extensions.Caching.Memory in Ihre .NET-Apps spürbare Geschwindigkeitssteigerungen und verbesserte Anwendungsreaktionsfähigkeit erzielen.
Durch die Nutzung der Microsoft.Extensions-Funktionen, 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 Apps erheblich steigern. Diese potente Kombination ermöglicht es Entwicklern, einfach leistungsstarke, skalierbare und reaktionsfähige Anwendungen zu entwerfen, indem sie die Serverlast reduzieren, die Benutzererfahrung verbessern und den Verarbeitungsaufwand eliminieren.
IronPDF kann zu einem angemessenen Preis erworben werden, und der Erwerb des Pakets beinhaltet eine lebenslange Lizenz. Das Paket bietet herausragenden Wert, da es bei $999 beginnt, einer einmaligen Gebühr für mehrere Systeme. Für Benutzer mit Lizenzen bietet es rund um die Uhr Online-Ingenieurshilfe. Für weitere Details über die Kosten besuchen Sie bitte die IronPDF Licensing Page. Besuchen Sie diese Seite über Iron Software, um mehr über Produkte von Iron Software zu erfahren.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
