Microsoft.Extensions.Caching.Memory Ejemplo (Con PDF) en C#

Microsoft.Extensions.Caching.Memory: La base del almacenamiento en caché en .NET

El almacenamiento en caché es un método utilizado en muchas aplicaciones .NET de alto rendimiento que almacena datos accedidos con frecuencia en memoria para una recuperación rápida. Microsoft.Extensions es una de las muchas opciones de almacenamiento en caché que están accesibles. Caching.Memory es una opción particularmente fuerte y adaptable. Esta biblioteca es un componente del espacio de nombres más grande Microsoft.Extensions.Caching que ofrece un enfoque de almacenamiento en caché en memoria sencillo pero efectivo.

Tipos clave dentro de "Microsoft.Extensions.Caching.Memory"

Instalar y configurar Microsoft.Extensions.Caching.Memory

Durante el inicio de la aplicación, se utiliza memoria para configurar el servicio de caché dentro de la colección de servicios de la aplicación ASP.NET Core. A continuación, se muestra una aplicación ASP.NET Core con Microsoft.Extensions.Caching.Memory configurado:

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

Empezando

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

Uso de Microsoft.Extensions.Caching.Memory con IronPDF

En las aplicaciones .NET, Microsoft.Extensions.Caching.Memory ofrece un medio práctico de almacenar datos solicitados con frecuencia para una recuperación más rápida.

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

Importamos los espacios de nombres necesarios para trabajar con Microsoft y ASP.NET Microsoft.Extensions.Caching.Memory. Creamos el controlador DemoController, que se deriva de ControllerBase. Este controlador responderá a consultas enviadas por HTTP. Se inyecta una instancia de IMemoryCache en el constructor del controlador.

Para controlar el ciclo de vida de los servicios, incluida la caché en memoria, ASP.NET Core ofrece inyección de dependencias. Con el atributo [HttpGet] aplicado, el método Generate está marcado para manejar solicitudes HTTP GET a la tienda desde la ruta designada (/Demo). Intentamos obtener los datos del PDF de la caché utilizando la clave de caché dada. Si no se encuentran los datos en la caché, usamos la función GeneratePdf para crear un nuevo PDF.

En un escenario con múltiples servidores de aplicaciones, asegúrese de configurar almacenamiento en caché distribuido para una gestión coherente de la caché en todos los servidores.

Para utilizar Microsoft.Extensions.Caching.Memory, consulte la documentación y el código de muestra proporcionado para almacenar datos en caché y mejorar el rendimiento en aplicaciones ASP.NET Core. En la práctica, puede ajustar las políticas de expiración, las claves de caché y el comportamiento de almacenamiento en caché para adaptarse a las necesidades de su aplicación. El almacenamiento en caché de datos que es costoso de generar o al que acceden con frecuencia varios hilos puede mejorar la experiencia general del usuario y reducir drásticamente los tiempos de respuesta.

Conclusión

Considerando todo, Microsoft.Extensions.Caching.Memory se puede utilizar para aumentar la escalabilidad y el rendimiento de las aplicaciones .NET, especialmente aquellas que se basan en el marco ASP.NET Core. Los desarrolladores pueden mejorar la experiencia del usuario, minimizar la latencia y optimizar el acceso a los datos al utilizar almacenamiento en caché en memoria. La biblioteca proporciona una API flexible y fácil de usar para desarrollar estrategias de almacenamiento en caché dirigidas a requisitos específicos de la aplicación, ya sea para almacenar en caché datos de referencia, resultados de consultas o valores calculados. Puede lograr aumentos de velocidad notables y una mayor capacidad de respuesta de la aplicación al adoptar las mejores prácticas de almacenamiento en caché y agregar Microsoft.Extensions.Caching.Memory en sus aplicaciones .NET.

Al aprovechar las características de Microsoft.Extensions, con la ayuda de IronPDF para la creación dinámica de PDF y Caching.Memory para el almacenamiento en caché de datos efectivo, los desarrolladores de .NET pueden mejorar enormemente la velocidad de sus aplicaciones. Esta potente combinación permite a los desarrolladores diseñar fácilmente aplicaciones de alto rendimiento, escalables y receptivas, reduciendo la carga del servidor, mejorando la experiencia del usuario y eliminando la sobrecarga de procesamiento.

IronPDF se puede comprar a un precio razonable, y adquirir el paquete incluye una licencia de por vida. El paquete ofrece un valor excelente, ya que comienza en $799, una tarifa única para múltiples sistemas. Para usuarios con licencias, ofrece ayuda de ingeniería en línea las 24 horas del día. Para obtener más detalles sobre el cargo, visite la Página de Licencias de IronPDF. Visite esta página sobre Iron Software para obtener más información sobre los productos elaborados por Iron Software.