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

Microsoft.Extensions.Caching.Memory: Die Grundlage 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 der vielen Caching-Optionen, die verfügbar sind. Caching.Memory ist eine besonders starke und anpassbare Option. Diese Bibliothek ist ein Bestandteil des größeren Microsoft.Extensions.Caching-Namespaces und bietet einen einfachen, aber effektiven Speichercache-Ansatz.

Schlüsseltypen in "Microsoft.Extensions.Caching.Memory"

Installieren und Konfigurieren von Microsoft.Extensions.Caching.Memory

Während des Anwendungsstarts wird der Cache-Service innerhalb der Dienstesammlung der ASP.NET Core-Anwendung konfiguriert. Unten ist 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, häufig angeforderte Daten für einen schnelleren Zugriff 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;
        }
    }
}

Wir importieren die für die Arbeit mit Microsoft und ASP.NET erforderlichen Namespaces Microsoft.Extensions.Caching.Memory. Wir erstellen den Controller DemoController, der sich von ControllerBase ableitet. Dieser Controller wird auf über HTTP gesendete Abfragen 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 angewandten Attribut [HttpGet] wird die Generate-Methode markiert, um HTTP GET-Anfragen an den Speicher von der angegebenen Route (/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 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 bereitgestellte Dokumentation und 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 verwendet werden, um die Skalierbarkeit und Leistung von .NET-Anwendungen zu steigern, insbesondere 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 Geschwindigkeitserhöhungen und eine verbesserte Anwendungsreaktionsfähigkeit erzielen, indem Sie bewährte Caching-Praktiken umsetzen und Microsoft.Extensions.Caching.Memory in Ihre .NET-Apps einbinden.

Durch die Nutzung der Microsoft.Extensions Funktionen, mit Hilfe von IronPDF zur dynamischen PDF-Erstellung und Caching.Memory zur effektiven Datenspeicherung, können .NET-Entwickler die Geschwindigkeit ihrer Apps erheblich verbessern. Diese potente Kombination ermöglicht es Entwicklern, mit Leichtigkeit leistungsstarke, skalierbare und reaktionsschnelle Anwendungen zu entwerfen, indem sie die Serverlast senken, das Benutzererlebnis verbessern und Verarbeitungsoverhead vermeiden.

IronPDF kann zu einem angemessenen Preis erworben werden, und der Erwerb des Pakets beinhaltet eine lebenslange Lizenz. Das Paket bietet einen hervorragenden Wert, da es bei $799 beginnt, 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.