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

Microsoft.Extensions.Caching.Memory: Die Grundlagen des Caching in .NET

Caching 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 von vielen verfügbaren Caching-Optionen. Caching.Memory ist eine besonders starke und anpassungsfähige Option. Diese Bibliothek ist eine Komponente des größeren Namespace Microsoft.Extensions.Caching und bietet einen unkomplizierten, aber dennoch effektiven In-Memory-Caching-Ansatz.

Schlüsseltypen innerhalb von "Microsoft.Extensions.Caching.Memory"

Installieren und Konfigurieren Microsoft.Extensions.Caching.Memory

Während des Anwendungsstarts wird der Cache-Service innerhalb der Dienstesammlung der ASP.NET Core-Anwendung konfiguriert. Nachfolgend eine ASP.NET Core Anwendung mit der Konfiguration Microsoft.Extensions.Caching.Memory:

Install-Package Microsoft.Extensions.Caching.Memory

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

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

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

Einstieg

Install-Package IronPdf

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

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.

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;
        }
    }
}

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 Namespace

Wir importieren die Namespaces, die für die Arbeit mit Microsoft und ASP.NET erforderlich sind Microsoft.Extensions.Caching.Memory. Wir erstellen den Controller DemoController, der von ControllerBase abgeleitet ist. Dieser Controller beantwortet Anfragen, 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 Attribut [HttpGet] wird die Methode Generate so konfiguriert, dass sie HTTP-GET-Anfragen an den Store von der angegebenen Route (/Demo) verarbeitet. Wir versuchen, die PDF-Daten aus dem Cache mit dem angegebenen Cache-Schlüssel abzurufen. Falls die Daten nicht im Cache gefunden werden, verwenden wir die Funktion GeneratePdf, 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 nutzen, konsultieren Sie die Dokumentation und den bereitgestellten Beispielcode, 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. 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.

Abschluss

Alles in allem kann Microsoft.Extensions.Caching.Memory dazu verwendet werden, die Skalierbarkeit und Leistung von .NET Anwendungen zu steigern, insbesondere von solchen, 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 spürbare Geschwindigkeitssteigerungen und eine verbesserte Reaktionsfähigkeit Ihrer Anwendung erzielen, indem Sie die Best Practices für Caching anwenden und Microsoft.Extensions.Caching.Memory in Ihre .NET -Apps einfügen.

Durch die Nutzung der Funktionen von Microsoft.Extensions, unterstützt durch IronPDF für die dynamische PDF-Erstellung und Caching.Memory für effektives Daten-Caching, können .NET -Entwickler die Geschwindigkeit ihrer Anwendungen deutlich steigern. Diese leistungsstarke Kombination ermöglicht es Entwicklern, problemlos performante, skalierbare und responsive Anwendungen zu erstellen, indem die Serverlast reduziert, die Benutzerfreundlichkeit verbessert und der Verarbeitungsaufwand minimiert wird.

IronPDF kann zu einem angemessenen Preis erworben werden, und der Erwerb des Pakets beinhaltet eine lebenslange Lizenz. Das Paket bietet ein hervorragendes Preis-Leistungs-Verhältnis, da es bereits ab $999 erhältlich ist – eine einmalige 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.