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

El almacenamiento en caché es una potente estrategia de optimización en este contexto. Microsoft.Extensions.Caching.Memory ofrece una solución eficiente de almacenamiento en 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, discutiremos las ventajas del almacenamiento en caché con respecto al proceso de conversión de HTML a PDF de IronPDF, revisaremos algunos consejos útiles de implementación y ofreceremos una guía detallada 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 de la 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 son una de las muchas opciones de almacenamiento en caché que están disponibles. Caching.Memory es una opción particularmente fuerte y adaptable. Esta biblioteca es un componente del mayor espacio de nombres Microsoft.Extensions.Caching que ofrece un enfoque de almacenamiento en caché en memoria simple pero efectivo.

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

IMemoryCache

• 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é.

MemoryCache

• La implementación real de IMemoryCache está en esta clase. Ofrece administración y almacenamiento real en memoria para los elementos almacenados en caché.
• La inyección de dependencias suele utilizarse en aplicaciones de ASP.NET Core para obtener una instancia de MemoryCache.

OpcionesDeEntradaDeCacheDeMemoria

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

• Expiración: Puedes configurar ventanas de expiración deslizante (donde la entrada caduca si no se accede a ella dentro de un cierto intervalo) o tiempos de expiración absoluta (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.

EntradaDeCaché

• 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é.

ICacheEntry

• 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 es implementada por la clase CacheEntry, que ofrece una implementación práctica de estas funciones.

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. Una aplicación de ASP.NET Core que tiene configurado Microsoft.Extensions.Caching.Memory se muestra a continuación:

Instale el paquete NuGet necesario

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

Install-Package Microsoft.Extensions.Caching.Memory

Install-Package Microsoft.Extensions.Caching.Memory

O podemos utilizar NuGet Package Manager para instalar el paquete:

Configurar servicios en Startup.cs

Navega al método ConfigureServices en tu aplicación ASP.NET Core abriendo el archivo Startup.cs. Para configurar el servicio de caché de memoria, añade 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 predeterminadas a través de la función AddMemoryCache.

Inyectar IMemoryCache

Una vez configurado el almacén de caché, cualquier clase o componente que necesite almacenamiento en 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

Los métodos para almacenar en caché y recuperar datos de la memoria son proporcionados por la interfaz IMemoryCache.

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 te ayudarán a configurar Microsoft.Extensions. En su aplicación ASP.NET Core, use 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, abre el archivo Startup.cs en tu 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 asegura que la aplicación cree y utilice solo 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 frecuentemente solicitados 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 espacios de nombres necesarios para trabajar con Microsoft y ASP.NET Microsoft.Extensions.Caching.Memory. Crearemos el controlador DemoController, que se deriva de ControllerBase. Este controlador responderá a las consultas enviadas a través de HTTP. Una instancia de IMemoryCache se inyecta 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 la propiedad [HttpGet] aplicada, el método Generate está marcado para manejar solicitudes HTTP GET a la tienda 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 proporcionado para almacenar en caché datos 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

Considerando todo, Microsoft.Extensions.Caching.Memory se puede usar para aumentar la escalabilidad y el rendimiento de las aplicaciones .NET, especialmente aquellas que están basadas en el marco de trabajo 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. Puedes lograr aumentos notorios de velocidad y una mayor capacidad de respuesta de las aplicaciones al adoptar mejores prácticas de almacenamiento en caché y agregar Microsoft.Extensions.Caching.Memory a tus aplicaciones .NET.

Al hacer uso de las características de Microsoft.Extensions, con la ayuda de IronPDF para la creación dinámica de PDF y Caching.Memory para un almacenamiento en caché de datos efectivo, los desarrolladores de .NET pueden incrementar significativamente la velocidad de sus aplicaciones. Esta potente combinación permite a los desarrolladores diseñar fácilmente aplicaciones de alto rendimiento, escalables y receptivas al reducir la carga del servidor, mejorar la experiencia del usuario y eliminar el exceso 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 sola tarifa para múltiples sistemas. Para los usuarios con licencia, 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 aprender más sobre los productos hechos por Iron Software.