La mise en cache est une technique fondamentale dans le développement de logiciels pour améliorer les performances en stockant les données fréquemment consultées dans la mémoire ou sur un support de stockage plus rapide. En C#, LazyCache est une bibliothèque populaire qui simplifie la mise en œuvre de la mise en cache sécurisée pour les threads, facilitant ainsi pour les développeurs l'utilisation efficace de la mise en cache dans leurs applications pour des scénarios de forte charge.

Qu'est-ce que LazyCache ?

LazyCache est une bibliothèque de fournisseurs de mise en cache sous-jacente pour les applications .NET/ ASP.NET Core qui fournit une API simple et intuitive pour la mise en cache des données. Il est disponible sous la forme d'un paquet NuGet et peut être facilement intégré dans des projets C#. L'objectif principal de LazyCache est de simplifier la mise en œuvre de la mise en cache et de réduire le code de base nécessaire pour gérer les informations mises en cache à l'aide d'un modèle de cache à double verrouillage.

Caractéristiques principales de LazyCache :

1. API Simple : LazyCache offre une API simple pour ajouter, récupérer et supprimer des éléments mis en cache. Les développeurs peuvent rapidement intégrer la mise en cache dans leurs applications ou leurs appels de services web sans avoir à gérer des mécanismes de mise en cache complexes.

2. Expiration automatique : LazyCache prend en charge l'expiration automatique des éléments mis en cache en fonction de politiques d'expiration configurables. Les développeurs peuvent spécifier la durée d'expiration des éléments mis en cache, et LazyCache supprime les éléments expirés des données du cache.

3. Mise en cache en mémoire : LazyCache stocke les éléments mis en cache en mémoire par défaut, ce qui le rend adapté aux situations où un accès rapide aux données mises en cache est nécessaire. La mise en mémoire cache garantit une faible latence et un débit élevé pour l'accès aux données mises en cache.

4. Opérations sûres pour les threads : LazyCache offre des opérations sûres pour les threads pour l'ajout, la récupération et la suppression d'éléments mis en cache. Cela garantit que plusieurs threads peuvent accéder au cache simultanément sans risque de corruption ou d'incohérence des données.

5. Extensibilité : LazyCache est conçu pour être extensible, permettant aux développeurs de personnaliser le comportement du cache selon leurs exigences spécifiques. Il fournit des crochets pour la mise en œuvre de stratégies de mise en cache personnalisées, telles que la mise en cache distribuée ou la mise en cache avec persistance.

   Comment utiliser LazyCache en C# :

   L'utilisation de LazyCache en C# est simple, grâce à son API intuitive. L'exemple ci-dessous montre comment utiliser LazyCache pour mettre en cache le résultat d'un appel de méthode :

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

Dans cet exemple, la classe DataService utilise LazyCache pour mettre en cache le résultat de la méthode GetData(). La méthode GetOrAdd() récupère les données mises en cache associées à la clé spécifiée ("dataKey") si elles existent. Si les données ne sont pas mises en cache, le délégué fourni (FetchDataFromDatabase()) est exécuté pour récupérer les données, qui sont ensuite mises en cache pour une utilisation future.

Introduction à IronPDF

IronPDF est une bibliothèque PDF C# puissante qui permet de générer, d'éditer et d'extraire du contenu à partir de documents PDF dans des projets .NET. En voici les principales caractéristiques :

1. Conversion de HTML en PDF :

   • Convertissez du contenu HTML, CSS et JavaScript au format PDF.

   • Utilisez le moteur de rendu Chrome pour obtenir des PDF au pixel près.

   • Générer des PDF à partir d'URL, de fichiers HTML ou de chaînes HTML.

2. Conversion d'image et de contenu :

   • Convertissez des images depuis et vers des PDF.

   • Extraction de texte et d'images à partir de PDF existants.

   • Prise en charge de différents formats d'image.

3. Édition et Manipulation :

   • Définir les propriétés, la sécurité et les autorisations pour les PDF.

   • Ajouter des signatures numériques.

   • Modifier les métadonnées et l'historique des révisions.

4. Support multiplateforme :

   • Fonctionne avec .NET Core (8, 7, 6, 5 et 3.1+), .NET Standard (2.0+) et .NET Framework (4.6.2+).

   • Compatible avec Windows, Linux et macOS.

   • Disponible sur NuGet pour une installation facile.

Générer un document PDF en utilisant IronPDF et LazyCache

Pour commencer, créez une application Console à l'aide de Visual Studio, comme indiqué ci-dessous.

Fournir le nom du projet.

Fournir la version .NET.

Installez le paquet IronPDF.

Installer le paquetage LazyCache pour ajouter des appels de méthode en cache.

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

Explication du code

• Instancier le Rendu : Une instance de ChromePdfRenderer est créée pour gérer la conversion du contenu HTML en format PDF.
• Définir le contenu : Le contenu HTML ("

  Démonstration de LazyCache et IronPDF

  ", "

  Créer CachingService

  ", etc.) est préparé. Ce contenu sera converti en PDF et mis en cache pour être réutilisé.
• Créer un service de cache : Un service de cache (IAppCache) est instancié en utilisant le CachingService de LazyCache. Ce service de cache paresseux gère le stockage et la récupération des données mises en cache.
• Clé de cache : Un identifiant unique ("uniqueKey") est attribué pour représenter le contenu PDF mis en cache.
• Définir une Méthode Coûteuse : Une méthode de fabrique (expensiveLongRunMethod) est définie pour générer les données pouvant être mises en cache. Cette méthode invoque le ChromePdfRenderer pour rendre le contenu HTML sous forme de PDF. Le PDF résultant est ensuite enregistré et renvoyé sous la forme d'une chaîne de caractères.
• Obtenir ou Ajouter au cache : La méthode GetOrAdd du service est appelée pour récupérer la valeur en cache associée à cacheKey. Si la valeur n'existe pas dans le cache, la méthode expensiveLongRunMethod est invoquée pour la calculer, la stocker dans le cache et la renvoyer. Si la valeur est déjà mise en cache, elle est renvoyée directement.
• Sortie : Le contenu PDF mis en cache (sous forme de chaîne) est imprimé sur la console (Console.WriteLine(cachedValue)), démontrant la récupération des données mises en cache.

Sortie

PDF (EN ANGLAIS)

Licences IronPDF (version d'essai disponible)

Le package IronPDF nécessite une licence pour l'exécution et la génération du PDF. Ajoutez le code suivant au début de l'application avant d'accéder au paquet.

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Une licence d'essai est disponible sur la page de licence d'essai d'IronPDF.

Conclusion

LazyCache simplifie la mise en œuvre de la mise en cache dans les applications C# en fournissant une API simple et une expiration automatique des éléments mis en cache. En intégrant LazyCache dans vos projets, vous pouvez améliorer les performances en mettant efficacement en cache les données fréquemment consultées, en réduisant la latence et en optimisant l'utilisation des ressources de manière atomique et ordonnée. Que vous construisiez des applications web, des API ou des services, LazyCache peut être un outil précieux pour améliorer les performances et l'évolutivité de vos applications C#.

D'autre part, IronPDF est une bibliothèque C# puissante et polyvalente qui permet de gérer les documents PDF dans les applications .NET. Ses solides capacités englobent la création, l'édition, le rendu HTML au format PDF et la manipulation programmatique des PDF. Doté de fonctions de traitement sécurisé des documents grâce au cryptage et aux signatures numériques, IronPDF permet aux développeurs de gérer et de personnaliser efficacement les flux de travail PDF, ce qui en fait un outil précieux pour un large éventail de tâches de gestion et de génération de documents dans le cadre du développement C#.