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

Microsoft.Extensions.Caching.Memory: Die Grundlage des Cachings 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 der vielen verfügbaren Caching-Optionen. Caching.Memory ist eine besonders starke und anpassungsfähige Option. Diese Bibliothek ist ein Bestandteil des größeren Microsoft.Extensions.Caching Namespace und bietet einen einfachen, aber effektiven Ansatz für In-Memory-Caching.

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

Installation und Konfiguration von Microsoft.Extensions.Caching.Memory

Während des Anwendungsstarts wird der Cache-Service innerhalb der Dienstesammlung der ASP.NET Core-Anwendung konfiguriert. Im Folgenden eine ASP.NET Core-Anwendung mit konfiguriertem 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...
}

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

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

Verwendung von Microsoft.Extensions.Caching.Memory mit IronPDF

In .NET-Anwendungen bietet Microsoft.Extensions.Caching.Memory eine praktische Möglichkeit zum Speichern häufig angeforderter Daten für schnellere Abrufe.

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

Wir importieren die erforderlichen Namespaces, 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 über HTTP gesendete Anfragen antworten. 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 [HttpGet] Attribut versehen, wird die Generate Methode markiert, um HTTP GET-Anfragen vom festgelegten Pfad (/Demo) zu bearbeiten. Wir versuchen, die PDF-Daten aus dem Cache mit dem angegebenen Cache-Schlüssel abzurufen. Wenn die Daten nicht im Cache 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 nutzen, ziehen Sie die Dokumentation und die bereitgestellten Beispielcodes zu Rate, 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.

Abschluss

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 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. Durch die Übernahme von Caching-Best Practices und das Hinzufügen von Microsoft.Extensions.Caching.Memory in Ihre .NET-Apps können Sie deutliche Geschwindigkeitssteigerungen und eine verbesserte Reaktionsfähigkeit der Anwendung erzielen.

Durch die Nutzung der Microsoft.Extensions Funktionen, mit Hilfe von IronPDF zur dynamischen 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 reaktionsschnelle Anwendungen einfach zu gestalten, indem sie die Serverbelastung verringern, die Benutzererfahrung verbessern und die Verarbeitungskosten beseitigen.

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 bei einem einzigen Gebühr von $799 für mehrere Systeme beginnt. 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.