El almacenamiento en caché es una técnica fundamental en el desarrollo de software para mejorar el rendimiento almacenando los datos a los que se accede con más 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é segura para hilos, facilitando a los desarrolladores el uso efectivo del almacenamiento en caché 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 sencilla e intuitiva para almacenar datos en caché. Está disponible como paquete NuGet y puede integrarse fácilmente en proyectos de C#. El objetivo principal de LazyCache es simplificar la implementación de la caché y reducir el código repetitivo necesario para gestionar la información almacenada 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 almacenados en caché. Los desarrolladores pueden integrar rápidamente el almacenamiento en caché en sus aplicaciones o llamadas a servicios web sin tener que lidiar con complejos mecanismos de almacenamiento en caché.

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

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

4. Operaciones seguras para hilos: LazyCache ofrece operaciones seguras para hilos para agregar, recuperar y eliminar elementos almacenados en caché. Esto garantiza que varios subprocesos puedan acceder simultáneamente a la caché sin riesgo de corrupción o incoherencia de los datos.

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

   Cómo usar LazyCache en C#:

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

using LazyCache;
public class DataService
{
// private readonly IAppCache cache
    private readonly IAppCache _cache;
    public DataService(IAppCache cache)
    {
        _cache = cache;
    }
    public string GetData()
    {
        return _cache.GetOrAdd("dataKey", () =>
        {
            // Simulate expensive operation such as database calls
            return FetchDataFromDatabase();
        });
    }
    private string FetchDataFromDatabase()
    {
        // Simulate fetching data from a database
        return "Cached Data";
    }
}

using LazyCache;
public class DataService
{
// private readonly IAppCache cache
    private readonly IAppCache _cache;
    public DataService(IAppCache cache)
    {
        _cache = cache;
    }
    public string GetData()
    {
        return _cache.GetOrAdd("dataKey", () =>
        {
            // Simulate expensive operation such as database calls
            return FetchDataFromDatabase();
        });
    }
    private string FetchDataFromDatabase()
    {
        // Simulate fetching data from a database
        return "Cached Data";
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

En este ejemplo, la clase DataService utiliza 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 almacenados en caché, el delegado proporcionado (FetchDataFromDatabase()) se ejecuta para obtener los datos, que luego se almacenan en caché para uso futuro.

Introducción a IronPDF

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

1. Conversión de HTML a PDF:

   • Convierte contenidos HTML, CSS y JavaScript a formato PDF.

   • Utiliza el motor de renderizado de Chrome para obtener PDF perfectos.

   • Genere PDF a partir de URL, archivos HTML o cadenas HTML.

2. Conversión de Imágenes y Contenido:

   • Convierte imágenes a y desde PDF.

   • Extraiga texto e imágenes de PDF existentes.

   • Compatible con varios formatos de imagen.

3. Edición y Manipulación:

   • Establezca las propiedades, la seguridad y los permisos de los archivos PDF.

   • Añade firmas digitales.

   • Editar metadatos e historial de revisiones.

4. Soporte 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 facilitar la instalación.

Generación de documentos PDF con IronPDF y LazyCache

Para empezar, cree una aplicación de consola utilizando Visual Studio como se indica a continuación.

Proporcione el nombre del proyecto.

Proporcione la versión .NET.

Instale el paquete IronPDF.

Instala el paquete LazyCache para añadir llamadas a métodos en caché.

using LazyCache;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CodeSample
{
    internal class LazyCacheDemo
    {
        public static void Execute()
        {
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo LazyCache and IronPDF</h1>";
            content += "<h2>Create CachingService</h2>";
            // Create the cache service using caching logic
            IAppCache cache = new CachingService();
            content += "<p>IAppCache cache = new CachingService();</p>";
            var cacheKey = "uniqueKey";           
            content += "<p>string cachedValue = cache.GetOrAdd(cacheKey, expensiveMethod);</p>";
            // Define a factory method to generate the cacheable data
            Func<string> expensiveLongRunMethod = () => {
                var pdf = renderer.RenderHtmlAsPdf(content);
                // Export to a file or Stream
                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf");
                return content;
            };
            // Get the cached value or add it if it doesn't exist
            string cachedValue = cache.GetOrAdd(cacheKey, expensiveLongRunMethod);
            Console.WriteLine(cachedValue);
        }
    }
}

using LazyCache;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CodeSample
{
    internal class LazyCacheDemo
    {
        public static void Execute()
        {
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo LazyCache and IronPDF</h1>";
            content += "<h2>Create CachingService</h2>";
            // Create the cache service using caching logic
            IAppCache cache = new CachingService();
            content += "<p>IAppCache cache = new CachingService();</p>";
            var cacheKey = "uniqueKey";           
            content += "<p>string cachedValue = cache.GetOrAdd(cacheKey, expensiveMethod);</p>";
            // Define a factory method to generate the cacheable data
            Func<string> expensiveLongRunMethod = () => {
                var pdf = renderer.RenderHtmlAsPdf(content);
                // Export to a file or Stream
                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf");
                return content;
            };
            // Get the cached value or add it if it doesn't exist
            string cachedValue = cache.GetOrAdd(cacheKey, expensiveLongRunMethod);
            Console.WriteLine(cachedValue);
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Código Explicación

• Instanciar Renderizador: Se crea una instancia de ChromePdfRenderer para gestionar la conversión de contenido HTML a formato PDF.
• Definir Contenido: El contenido HTML ("

  Demo LazyCache y IronPDF

  ", "

  Crear CachingService

  ", etc.) está preparado. Este contenido se convertirá en un PDF y se almacenará en caché para su reutilización.
• Crear Servicio de Caché: Un servicio de caché (IAppCache) se instaura utilizando el CachingService de LazyCache. Este servicio de caché perezoso gestiona el almacenamiento y la recuperación de 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 PDF. El PDF resultante se guarda y se devuelve como una cadena.
• Obtener o Agregar 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 devolverlo. Si el valor ya está en caché, se devuelve directamente.
• Salida: El contenido en caché del PDF (como una cadena) se imprime en la consola (Console.WriteLine(cachedValue)), demostrando la recuperación de datos en caché.

Salida

PDF

Licencias de IronPDF (versión de prueba disponible)

El paquete IronPDF requiere una licencia para ejecutar y generar el PDF. Añada 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";

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

Conclusión

LazyCache simplifica la implementación del almacenamiento en caché en aplicaciones C# al proporcionar una API sencilla y la caducidad automática de los elementos almacenados en caché. Al integrar LazyCache en sus proyectos, puede mejorar el rendimiento almacenando en caché de forma eficiente los datos a los que se accede con frecuencia, reduciendo la latencia y optimizando la utilización de recursos de forma atómica y ordenada. Tanto si está creando aplicaciones web, APIs o servicios, LazyCache puede ser una valiosa herramienta para mejorar el rendimiento y la escalabilidad de sus aplicaciones C#.

Por otro lado, IronPDF destaca como una biblioteca C# potente y versátil para manejar documentos PDF dentro de aplicaciones .NET. Sus potentes funciones abarcan la creación, edición, conversión de HTML a PDF y manipulación de PDF mediante programación. Con funciones para la gestión segura de documentos mediante cifrado y firmas digitales, IronPDF permite a los desarrolladores gestionar y personalizar eficazmente los flujos de trabajo de PDF, lo que lo convierte en una valiosa herramienta para una amplia gama de tareas de gestión y generación de documentos en el desarrollo en C#.