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

Para construir aplicaciones con capacidad de respuesta y eficacia, a menudo se necesitan métodos de optimización para aplicaciones .NET. El caché es un potente enfoque que incluye el almacenamiento temporal de material solicitado con frecuencia en una caché distribuida para facilitar una recuperación más rápida. La reducción del tiempo de procesamiento y de la carga del servidor con esta estrategia puede suponer un aumento significativo del rendimiento de las aplicaciones. Además, se pueden implementar contadores de rendimiento para supervisar y mejorar el sistema de caché.

Almacenamiento en caché es una potente estrategia de optimización en este contexto. Microsoft.Extensions.Caching.Memory proporciona una eficiente solución de caché de objetos en memoria para aplicaciones .NET. Sus aplicaciones centradas en PDF funcionarán y responderán mucho más rápido si utiliza estratégicamente la caché MemoryCache junto con IronPDF.

Exploramos cómo integrar ejemplos de C# de Microsoft.Extensions.Caching.Memory con IronPDF de manera eficiente. En este artículo, hablaremos de las ventajas del almacenamiento en caché en relación con laConversión de HTML a PDF de IronPDF repasar algunos consejos útiles de implementación y ofrecer un recorrido detallado para configurar el almacenamiento en caché en su programa IronPDF. Cuando todo esté dicho y hecho, dispondrá de los conocimientos y recursos necesarios para desarrollar aplicaciones PDF eficaces e intuitivas.

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 en memoria los datos a los que se accede con frecuencia para recuperarlos rápidamente. Microsoft.Extensions es una de las muchas opciones de almacenamiento en caché accesibles. Caching.Memory es una opción especialmente potente y adaptable. Esta biblioteca es un componente del espacio de nombres más amplio Microsoft.Extensions.Caching que ofrece un enfoque de almacenamiento en caché en memoria sencillo pero eficaz.

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

Caché de memoria

• La capacidad fundamental para utilizar la caché en memoria está representada por esta interfaz. Ofrece formas de gestionar las entradas de la caché y de añadirlas, recuperarlas y eliminarlas.
• Considérelo su principal punto de entrada para sus procesos de almacenamiento en caché.

Caché de memoria

• La implementación real de IMemoryCache se encuentra en esta clase. Ofrece administración y almacenamiento real en memoria para los elementos almacenados en caché.
• La inyección de dependencia se utiliza normalmente en aplicaciones ASP.NET Core para recuperar una instancia de MemoryCache.

MemoryCacheEntryOptions (opciones de entrada de caché de memoria)

Con esta clase se pueden especificar ajustes de configuración para elementos específicos de la caché. Estos ajustes regulan cosas como:

• Caducidad: Puede configurar ventanas de caducidad deslizantes(donde la entrada caduca si no se accede a ella en un intervalo determinado) o los plazos de expiración absolutos(donde la entrada caduca automáticamente).
• Prioridad: Cuando la caché se llena, esto influye en la decisión de desalojar elementos. Las entradas de mayor prioridad tienen menos posibilidades de ser eliminadas.
• Devolución de llamada post-expiración: Permite ajustar la lógica de gestión de los datos cuando han expirado. Resulta especialmente útil en situaciones en las que es necesario actualizar datos críticos, gestionar recursos y registrar datos.

Entrada de caché

• Dentro de la caché, este tipo denota una única entrada. Ofrece métodos y atributos para recuperar los detalles del tamaño, la configuración de caducidad y los valores almacenados en caché.
• En esencia, contiene toda la información sobre un dato concreto que se guarda en la caché.

Entrada de caché

• Esta interfaz describe las actividades básicas que se pueden realizar en un elemento de caché, aunque no es necesaria para las operaciones básicas de caché. Contiene instrucciones sobre cómo recuperar el valor y los detalles de caducidad. Esto es más frecuente en situaciones en las que hay que recuperar la clave de cadena.
• Esta interfaz está implementada por la clase CacheEntry, que ofrece una implementación práctica de estas características.

Instalar y configurar Microsoft.Extensions.Caching.Memory.

Configuración de Microsoft.Extensions.Caching. Durante el inicio de la aplicación, la memoria se utiliza 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 que tiene configurado Microsoft.Extensions.Caching.Memory:

Instale el paquete NuGet necesario

Primero, asegúrate de que Microsoft.Extensions.Caching.Memory está instalado en tu proyecto. Utilizando la consola del gestor de paquetes NuGet, puede instalarlo con el siguiente comando:

Install-Package Microsoft.Extensions.Caching.Memory

O podemos utilizar NuGet Package Manager para instalar el paquete:

Configurar servicios en Startup.cs

Vaya al método ConfigureServices de su aplicación ASP.NET Core abriendo el archivo Startup.cs. Para configurar el servicio de caché de memoria, añada el siguiente código:

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

El objeto de servicio de caché de memoria se añade a la colección de servicios de la aplicación y se configura mediante este código. El servicio del sistema de caché de memoria se registra utilizando sus configuraciones por defecto a través de la función AddMemoryCache.

Inyectar IMemoryCache

Una vez que el almacén de caché está configurado, cualquier clase o componente que necesite caché puede tener la interfaz IMemoryCache inyectada en él. En una clase de controlador o de servicio, por ejemplo:

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

La interfaz IMemoryCache proporciona métodos para almacenar y recuperar datos de la memoria.

Configurar opciones de caché

La configuración de los parámetros de la caché permite modificar el comportamiento de la memoria caché. Esto implica configurar un método conjunto de parámetros que incluyen restricciones de tamaño, tácticas de desalojo de entradas de caché y regulaciones de expiración de valores de caché. Esta es una ilustración de cómo configurar las opciones de caché:

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

Modifique los ajustes siguiendo las especificaciones de su aplicación.

Estas instrucciones le ayudarán a configurar Microsoft.Extensions. En su aplicación ASP.NET Core, utilice Caching.Memory. De este modo, las aplicaciones pueden funcionar con mayor rapidez y eficacia almacenando y recuperando en la memoria caché los datos a los que se accede con más frecuencia.

Primeros pasos

¿Qué es IronPDF?

Con la ayuda de la conocida biblioteca .NET IronPDF, los programadores pueden generar, editar y mostrar documentos PDF dentro de aplicaciones .NET. Crear PDF a partir de contenido HTML, fotos o datos sin procesar es sólo una de las muchas funciones que ofrece para trabajar con PDF. Otras funciones son la adición de texto, imágenes y formas a documentos PDF preexistentes, la conversión de páginas HTML a PDF y la extracción de texto e imágenes de PDF.

A continuación se indican algunas características de IronPDF:

• Creación de PDF a partir de HTML, PNG y datos sin procesar.
• Extracción de imágenes y texto de PDF.
• Añadir encabezados, pies de página y marcas de agua en PDF.
• Documentos PDF con protección por contraseña y cifrado.
• Cumplimentación de formularios y posibilidad de firma digital.

Instalar el paquete NuGet

En su proyecto, asegúrese de que el paquete IronPDF está instalado. Se puede utilizar la consola del gestor de paquetes NuGet para instalarlo:

Install-Package IronPdf

Para acceder a la función ConfigureServices, abra el archivo Startup.cs en su aplicación ASP.NET Core. Para configurar IronPDF, añada el siguiente código.

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

Al configurar el servicio HtmlToPdf de IronPDF como un singleton, este código se asegura de que la aplicación cree y utilice sólo una instancia de HtmlToPdf.

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.

Este código fuente y este fragmento ilustran su uso fundamental:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Net;
using System.Net.Http.Headers;
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;
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
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

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

Para controlar la vida útil de los servicios, incluida la caché de memoria, ASP.NET Core ofrece inyección de dependencias. Con el[HttpGet] aplicada, el método Generate se marca para gestionar las solicitudes HTTP GET al almacén desde la ruta designada(/Demo). Intentamos obtener los datos de previsión meteorológica de la caché dentro de la función Generar utilizando la clave de caché dada. Si los datos no se pueden utilizar ASP se encuentra en la caché, utilizamos la función Generar para crear nuevos datos meteorológicos.

En un escenario con varios servidores de aplicaciones, asegúrese de configurar el almacenamiento en caché distribuido para que la gestión de la caché sea coherente en todos los servidores.

Para utilizar Microsoft.Extensions.Caching.Memory, consulte la documentación y el código de ejemplo proporcionados para almacenar datos en caché y mejorar el rendimiento en aplicaciones ASP.NET Core. En la práctica, puede ajustar las políticas de caducidad, las claves de caché y el comportamiento de la caché para adaptarlos a las necesidades de su aplicación. El almacenamiento en caché de datos cuya generación es costosa o a los que acceden a menudo varios subprocesos puede mejorar la experiencia general del usuario y reducir drásticamente los tiempos de respuesta.

Conclusión

En definitiva, Microsoft.Extensions.Caching.Memory puede utilizarse para aumentar la escalabilidad y el rendimiento de las aplicaciones .NET, especialmente las basadas en el marco ASP.NET Core. Los desarrolladores pueden mejorar la experiencia del usuario, minimizar la latencia y optimizar el acceso a los datos utilizando el almacenamiento en caché en memoria. La biblioteca proporciona una API flexible y fácil de usar para desarrollar estrategias de almacenamiento en caché orientadas a requisitos concretos de la aplicación, ya sea para almacenar en caché datos de referencia, resultados de consultas o valores calculados. Si adoptas las mejores prácticas de almacenamiento en caché y añades Microsoft.Extensions.Caching.Memory a tus aplicaciones .NET, podrás aumentar notablemente la velocidad y mejorar la capacidad de respuesta de las aplicaciones.

Mediante el uso de las funciones de Microsoft.Extensions, con la ayuda de IronPDF para la creación dinámica de PDF y Caching.Memory para el almacenamiento eficaz de datos en caché, los desarrolladores .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 con capacidad de respuesta, reduciendo la carga del servidor, mejorando la experiencia del usuario y eliminando la sobrecarga de procesamiento.

IronPDF puede adquirirse a un precio razonable, y la adquisición del paquete incluye una licencia de por vida. El paquete ofrece un valor excepcional, ya que comienza en $749, una tarifa única para múltiples sistemas. Para los usuarios con licencia, ofrece ayuda de ingeniería en línea las 24 horas del día. Para más información sobre la tasa, visite la páginaPágina de licencias de IronPDF. Visita esta páginapágina sobre Iron Software para obtener más información sobre los productos de Iron Software.