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 d'un cache sûr pour les threads, ce qui permet aux développeurs d'exploiter plus facilement le cache dans leurs applications pour les scénarios à 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 fournit une API simple pour l'ajout, la récupération et la suppression d'é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. **LazyCache stocke par défaut les éléments mis en cache dans la mémoire, ce qui le rend adapté aux scénarios dans lesquels 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. **LazyCache fournit des opérations thread-safe 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. **LazyCache est conçu pour être extensible, ce qui permet aux développeurs de personnaliser le comportement de la mise en cache en fonction de leurs besoins 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.

   How to Use LazyCache in 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 fonction GetData() méthode. La fonction GetOrAdd() récupère les données mises en cache associées à la clé spécifiée("dataKey") s'il existe. Si les données ne sont pas mises en cache, le délégué fourni(Extraire les données de la base de données()) est exécutée pour récupérer les données, qui sont ensuite mises en cache en vue d'une utilisation ultérieure.

Introduction à IronPDF

IronPDF est une puissante bibliothèque PDF C# 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 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'images et de contenus :

   • 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+), Standard .NET(2.0+)et le Framework .NET(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

• Instaurer le moteur de rendu : Une instance de ChromePdfRenderer est créée pour gérer la conversion du contenu HTML au format PDF.
• Définir le contenu : Contenu HTML("

  Démo LazyCache et IronPDF

  ", "

  Créer CachingService

  ", etc.) est préparée. Ce contenu sera converti en PDF et mis en cache pour être réutilisé.
• Créer un service de mise en cache : Un service de mise en cache(IAppCache) est instancié à l'aide du service de mise en cache de LazyCache. Ce service de cache paresseux gère le stockage et la récupération des données mises en cache.
• Cache Key : Un identifiant unique("uniqueKey") est attribué pour représenter le contenu du PDF mis en cache.
• Définir une méthode coûteuse : Une méthode d'usine(méthode de la longue course coûteuse) est défini pour générer les données cachables. 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.
• Get or Add to Cache : La méthode GetOrAdd du service est appelée pour récupérer la valeur mise en cache associée à la clé de cache. 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 du PDF mis en cache(sous forme de chaîne de caractères) est imprimé sur la console(Console.WriteLine(valeur cachée))qui démontre 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 disponiblesur la page de la 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#.