La caché es una técnica fundamental en el desarrollo de software para mejorar el rendimiento almacenando datos a los que se accede con frecuencia en la memoria o en un medio de almacenamiento más rápido. En C#, LazyCache es una biblioteca popular que simplifica la implementación de cachés seguras para subprocesos, facilitando a los desarrolladores el uso efectivo de cachés en sus aplicaciones para escenarios de carga pesada.

¿Qué es LazyCache?

LazyCache es una biblioteca de proveedores de caché subyacente para aplicaciones .NET/ASP.NET Core que proporciona una API simple e intuitiva para el almacenamiento en caché de datos. Está disponible como un paquete NuGet y puede integrarse fácilmente en proyectos C#. El objetivo principal de LazyCache es simplificar la implementación de cachés y reducir el código repetitivo necesario para gestionar la información en caché utilizando un patrón de caché de doble bloqueo.

Características clave de LazyCache:

1. API simple: LazyCache proporciona una API sencilla para agregar, recuperar y eliminar elementos en caché. Los desarrolladores pueden integrar rápidamente la caché en sus aplicaciones o llamadas al servicio web sin tener que lidiar con mecanismos de cacheo complejos.

2. Expiración automática: LazyCache admite la expiración automática de elementos en caché basándose en políticas de expiración configurables. Los desarrolladores pueden especificar la duración de expiración para los elementos en caché, y LazyCache elimina los elementos caducados de los datos de la caché.

3. Caché en memoria: LazyCache almacena por defecto los elementos en caché en memoria, lo que lo hace adecuado para escenarios donde se requiere un acceso rápido a los datos en caché. El almacenamiento en caché en memoria garantiza baja latencia y alto rendimiento en el acceso a los datos en caché.

4. Operaciones seguras para subprocesos: LazyCache proporciona operaciones seguras para subprocesos para agregar, recuperar y eliminar elementos en caché. Esto asegura que múltiples subprocesos puedan acceder a la caché concurrentemente sin riesgo de corrupción o inconsistencia de datos.

5. Extensibilidad: LazyCache está diseñado para ser extensible, permitiendo a los desarrolladores personalizar el comportamiento de la caché de acuerdo con sus requerimientos específicos. Proporciona ganchos para implementar estrategias de almacenamiento en caché personalizadas, como el almacenamiento en caché distribuido o con persistencia.

Cómo usar LazyCache en C#:

El uso de LazyCache en C# es sencillo, gracias a su API intuitiva. A continuación, se presenta un ejemplo básico que demuestra cómo usar LazyCache para almacenar en caché el resultado de una llamada a un método:

using LazyCache;

public class DataService
{
    // Define a private readonly field for the cache
    private readonly IAppCache _cache;

    // Constructor to initialize the cache
    public DataService(IAppCache cache)
    {
        _cache = cache;
    }

    // Method to retrieve data (cached or fetched)
    public string GetData()
    {
        return _cache.GetOrAdd("dataKey", () =>
        {
            // Simulate expensive operation such as database calls
            return FetchDataFromDatabase();
        });
    }

    // Simulate fetching data from a database
    private string FetchDataFromDatabase()
    {
        return "Cached Data";
    }
}

using LazyCache;

public class DataService
{
    // Define a private readonly field for the cache
    private readonly IAppCache _cache;

    // Constructor to initialize the cache
    public DataService(IAppCache cache)
    {
        _cache = cache;
    }

    // Method to retrieve data (cached or fetched)
    public string GetData()
    {
        return _cache.GetOrAdd("dataKey", () =>
        {
            // Simulate expensive operation such as database calls
            return FetchDataFromDatabase();
        });
    }

    // Simulate fetching data from a database
    private string FetchDataFromDatabase()
    {
        return "Cached Data";
    }
}

Imports LazyCache

Public Class DataService
	' Define a private readonly field for the cache
	Private ReadOnly _cache As IAppCache

	' Constructor to initialize the cache
	Public Sub New(ByVal cache As IAppCache)
		_cache = cache
	End Sub

	' Method to retrieve data (cached or fetched)
	Public Function GetData() As String
		Return _cache.GetOrAdd("dataKey", Function()
			' Simulate expensive operation such as database calls
			Return FetchDataFromDatabase()
		End Function)
	End Function

	' Simulate fetching data from a database
	Private Function FetchDataFromDatabase() As String
		Return "Cached Data"
	End Function
End Class

Imports LazyCache

Public Class DataService
	' Define a private readonly field for the cache
	Private ReadOnly _cache As IAppCache

	' Constructor to initialize the cache
	Public Sub New(ByVal cache As IAppCache)
		_cache = cache
	End Sub

	' Method to retrieve data (cached or fetched)
	Public Function GetData() As String
		Return _cache.GetOrAdd("dataKey", Function()
			' Simulate expensive operation such as database calls
			Return FetchDataFromDatabase()
		End Function)
	End Function

	' Simulate fetching data from a database
	Private Function FetchDataFromDatabase() As String
		Return "Cached Data"
	End Function
End Class

En este ejemplo, la clase DataService usa LazyCache para almacenar en caché el resultado del método GetData(). El método GetOrAdd() recupera los datos en caché asociados con la clave especificada ('dataKey') si existe. Si los datos no están en caché, se ejecuta el delegado proporcionado FetchDataFromDatabase() para obtener los datos, los cuales luego se almacenan en caché para su uso futuro.

Introducción a IronPDF

IronPDF es una potente biblioteca PDF de C# que permite generar, editar y extraer contenido de documentos PDF en proyectos .NET. Aquí algunas características clave:

1. Conversión de HTML a PDF:

   • Convierte contenido HTML, CSS y JavaScript a formato PDF.
   • Usa el Motor de Renderizado de Chrome para PDFs de alta precisión.
   • Genera PDFs desde URLs, archivos HTML o cadenas HTML.

2. Conversión de imágenes y contenidos:

   • Convierte imágenes hacia y desde PDF.
   • Extrae texto e imágenes de PDFs existentes.
   • Soporte para varios formatos de imagen.

3. Edición y manipulación:

   • Establece propiedades, seguridad y permisos para PDFs.
   • Añade firmas digitales.
   • Edita metadatos e historial de revisiones.

4. Compatibilidad multiplataforma:

   • Funciona con .NET Core (8, 7, 6, 5 y 3.1+), .NET Standard (2.0+) y .NET Framework (4.6.2+).
   • Compatible con Windows, Linux y macOS.
   • Disponible en NuGet para una fácil instalación.

Generar un documento PDF utilizando IronPDF y LazyCache

Para comenzar, crea una aplicación de consola usando Visual Studio como se muestra a continuación.

Proveer Nombre del Proyecto.

Proporcione la versión de .NET.

Instala el paquete IronPDF.

Instale el paquete LazyCache para agregar llamadas a métodos en caché.

using LazyCache;
using IronPdf; // Add the IronPdf namespace
using System;

namespace CodeSample
{
    internal class LazyCacheDemo
    {
        public static void Execute()
        {
            // Instantiate the Chrome PDF Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo LazyCache and IronPDF</h1>";
            content += "<h2>Create CachingService</h2>";

            // Create the cache service using LazyCache
            IAppCache cache = new CachingService();

            var cacheKey = "uniqueKey"; // Unique key for caching the content

            // Define a factory method to generate the cacheable data
            Func<string> expensiveLongRunMethod = () =>
            {
                // Render the HTML content to a PDF
                var pdf = renderer.RenderHtmlAsPdf(content);
                
                // Export the rendered PDF to a file
                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf");
                
                // Return the content as a string
                return content;
            };

            // Get the cached value or execute expensiveLongRunMethod to cache it
            string cachedValue = cache.GetOrAdd(cacheKey, expensiveLongRunMethod);

            // Output the cached value to the console
            Console.WriteLine(cachedValue);
        }
    }
}

using LazyCache;
using IronPdf; // Add the IronPdf namespace
using System;

namespace CodeSample
{
    internal class LazyCacheDemo
    {
        public static void Execute()
        {
            // Instantiate the Chrome PDF Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo LazyCache and IronPDF</h1>";
            content += "<h2>Create CachingService</h2>";

            // Create the cache service using LazyCache
            IAppCache cache = new CachingService();

            var cacheKey = "uniqueKey"; // Unique key for caching the content

            // Define a factory method to generate the cacheable data
            Func<string> expensiveLongRunMethod = () =>
            {
                // Render the HTML content to a PDF
                var pdf = renderer.RenderHtmlAsPdf(content);
                
                // Export the rendered PDF to a file
                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf");
                
                // Return the content as a string
                return content;
            };

            // Get the cached value or execute expensiveLongRunMethod to cache it
            string cachedValue = cache.GetOrAdd(cacheKey, expensiveLongRunMethod);

            // Output the cached value to the console
            Console.WriteLine(cachedValue);
        }
    }
}

Imports LazyCache
Imports IronPdf ' Add the IronPdf namespace
Imports System

Namespace CodeSample
    Friend Class LazyCacheDemo
        Public Shared Sub Execute()
            ' Instantiate the Chrome PDF Renderer
            Dim renderer = New ChromePdfRenderer()
            Dim content = "<h1>Demo LazyCache and IronPDF</h1>"
            content &= "<h2>Create CachingService</h2>"

            ' Create the cache service using LazyCache
            Dim cache As IAppCache = New CachingService()

            Dim cacheKey = "uniqueKey" ' Unique key for caching the content

            ' Define a factory method to generate the cacheable data
            Dim expensiveLongRunMethod As Func(Of String) = Function()
                                                                ' Render the HTML content to a PDF
                                                                Dim pdf = renderer.RenderHtmlAsPdf(content)

                                                                ' Export the rendered PDF to a file
                                                                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf")

                                                                ' Return the content as a string
                                                                Return content
                                                            End Function

            ' Get the cached value or execute expensiveLongRunMethod to cache it
            Dim cachedValue As String = cache.GetOrAdd(cacheKey, expensiveLongRunMethod)

            ' Output the cached value to the console
            Console.WriteLine(cachedValue)
        End Sub
    End Class
End Namespace

Imports LazyCache
Imports IronPdf ' Add the IronPdf namespace
Imports System

Namespace CodeSample
    Friend Class LazyCacheDemo
        Public Shared Sub Execute()
            ' Instantiate the Chrome PDF Renderer
            Dim renderer = New ChromePdfRenderer()
            Dim content = "<h1>Demo LazyCache and IronPDF</h1>"
            content &= "<h2>Create CachingService</h2>"

            ' Create the cache service using LazyCache
            Dim cache As IAppCache = New CachingService()

            Dim cacheKey = "uniqueKey" ' Unique key for caching the content

            ' Define a factory method to generate the cacheable data
            Dim expensiveLongRunMethod As Func(Of String) = Function()
                                                                ' Render the HTML content to a PDF
                                                                Dim pdf = renderer.RenderHtmlAsPdf(content)

                                                                ' Export the rendered PDF to a file
                                                                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf")

                                                                ' Return the content as a string
                                                                Return content
                                                            End Function

            ' Get the cached value or execute expensiveLongRunMethod to cache it
            Dim cachedValue As String = cache.GetOrAdd(cacheKey, expensiveLongRunMethod)

            ' Output the cached value to the console
            Console.WriteLine(cachedValue)
        End Sub
    End Class
End Namespace

Explicación del código

• Instanciar Renderizador: Se crea una instancia de ChromePdfRenderer para manejar la conversión de contenido HTML a formato PDF.

• Define Content: HTML content ("

  Demo LazyCache and IronPDF

  ", "

  Create CachingService

  ", etc.) is prepared. Este contenido será renderizado en un PDF y almacenado en caché para reutilización.

• Crear Servicio de Caché: Un servicio de caché (IAppCache) se instancia utilizando CachingService de LazyCache. Este servicio de caché administrará el almacenamiento y recuperación de los datos en caché.

• Clave de caché: se asigna un identificador único ("uniqueKey") para representar el contenido PDF almacenado en caché.

• Definir Método Costoso: Se define un método de fábrica (expensiveLongRunMethod) para generar los datos almacenables en caché. Este método invoca el ChromePdfRenderer para renderizar contenido HTML como un PDF. El PDF resultante se guarda y se retorna como una cadena.

• Obtener o Añadir al Caché: Se llama al método GetOrAdd del servicio para recuperar el valor en caché asociado con el cacheKey. Si el valor no existe en la caché, se invoca expensiveLongRunMethod para calcularlo, almacenarlo en la caché y retornarlo. Si el valor ya está en caché, se retorna directamente.

• Salida: El contenido del PDF en caché (como una cadena) se imprime en la consola (Console.WriteLine(cachedValue)), demostrando la recuperación de datos en caché.

Resultado

PDF

Licencias de IronPDF (prueba disponible)

El paquete IronPDF requiere una licencia para ejecutar y generar el PDF. Agregue el siguiente código al inicio de la aplicación antes de acceder al paquete.

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

Imports IronPdf

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY"

Imports IronPdf

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY"

Una licencia de prueba está disponible en la página de licencia de prueba de IronPDF.

Conclusión

LazyCache simplifica la implementación de cachés en aplicaciones C# proporcionando una API sencilla y la expiración automática de elementos en caché. Al integrar LazyCache en sus proyectos, puede mejorar el rendimiento al almacenar eficientemente en caché datos a los que se accede con frecuencia, reduciendo la latencia y optimizando el uso de recursos de manera atómica y ordenada. Ya sea que esté desarrollando aplicaciones web, APIs o servicios, LazyCache puede ser una herramienta valiosa para mejorar el rendimiento y la escalabilidad de sus aplicaciones C#.

Por otro lado, IronPDF se destaca como una potente y versátil biblioteca C# para manejar documentos PDF dentro de aplicaciones .NET. Sus robustas capacidades abarcan la creación, edición, renderizado de HTML a PDF y manipulación de PDFs de forma programática. Con funciones para el manejo seguro de documentos a través de cifrado y firmas digitales, IronPDF permite a los desarrolladores gestionar y personalizar eficientemente los flujos de trabajo PDF, convirtiéndolo en una herramienta valiosa para una amplia variedad de tareas de gestión y generación de documentos en el desarrollo en C#.