Optimisez les performances de vos applications .NET grâce à la mise en cache Redis personnalisée à l’aide de GroupDocs.Conversion

Introduction

Vos applications .NET connaissent-elles des lenteurs de conversion de documents ? Améliorez vos performances et votre efficacité en exploitant un cache Redis personnalisé avec GroupDocs.Conversion pour .NET. Ce tutoriel vous guide dans les opérations de mise en cache pour accélérer le rendu des documents.

Ce que vous apprendrez :

Configuration de GroupDocs.Conversion pour .NET
Implémentation d’un cache Redis personnalisé pour la conversion de documents
Optimiser les performances avec des stratégies de mise en cache efficaces

Nous vous guiderons pour améliorer l’efficacité de votre application grâce à ces puissants outils. Avant de commencer, assurez-vous de bien comprendre les prérequis.

Prérequis

Pour suivre ce tutoriel, assurez-vous d’avoir :

Bibliothèques et versions requises :

GroupDocs.Conversion pour .NET (Version 25.3.0)
StackExchange.Redis bibliothèque pour les opérations Redis
Une instance en cours d’exécution d’un serveur Redis (par exemple, 192.168.222.4:6379)

Configuration requise pour l’environnement :

Visual Studio ou un autre IDE compatible prenant en charge C#
.NET Framework ou .NET Core installé

Prérequis en matière de connaissances :

Compréhension de base de la programmation C# et .NET
Familiarité avec Redis comme solution de mise en cache
Expérience des processus de conversion de documents dans les applications logicielles

Configuration de GroupDocs.Conversion pour .NET

Pour commencer à utiliser GroupDocs.Conversion, installez-le via la console du gestionnaire de packages NuGet ou l’interface de ligne de commande .NET.

Console du gestionnaire de packages NuGet :

Install-Package GroupDocs.Conversion -Version 25.3.0

.NET CLI :

dotnet add package GroupDocs.Conversion --version 25.3.0

Étapes d’acquisition de la licence :

Essai gratuit : Testez les fonctionnalités et les fonctionnalités avec une licence temporaire.
Licence temporaire : Obtenez une évaluation prolongée sans limitations.
Achat: Pour une utilisation à long terme, envisagez d’acheter une licence complète.

Après l’installation, initialisez GroupDocs.Conversion dans votre application C# :

using GroupDocs.Conversion;

Guide de mise en œuvre

Implémentation de cache personnalisé à l’aide de Redis

Cette section montre comment créer un cache personnalisé à l’aide de Redis pour les opérations de rendu de documents afin d’améliorer la vitesse et l’efficacité de la conversion.

Aperçu

Nous allons implémenter un mécanisme de mise en cache basé sur Redis qui stocke les documents rendus, évitant ainsi le traitement redondant et accélérant considérablement les temps de conversion.

Étape 1 : définir la classe RedisCache

using System;
using System.Collections.Generic;
using System.IO;
using StackExchange.Redis;

public class RedisCache : IDisposable
{
    private readonly string _cacheKeyPrefix;
    private readonly ConnectionMultiplexer _redis;
    private readonly IDatabase _db;
    private readonly string _host = "192.168.222.4:6379";

    public RedisCache(string cacheKeyPrefix)
    {
        _cacheKeyPrefix = cacheKeyPrefix;
        _redis = ConnectionMultiplexer.Connect(_host);
        _db = _redis.GetDatabase();
    }

    // Définir les données dans le cache avec une clé spécifique
    public void Set(string key, object data)
    {
        if (data == null) return;

        string prefixedKey = GetPrefixedKey(key);
        using (MemoryStream stream = new MemoryStream())
        {
            ((Stream)data).CopyTo(stream);
            _db.StringSet(prefixedKey, RedisValue.CreateFrom(stream));
        }
    }

    // Essayez de récupérer les données du cache à l'aide d'une clé
    public bool TryGetValue(string key, out object value)
    {
        var prefixedKey = GetPrefixedKey(key);
        var redisValue = _db.StringGet(prefixedKey);

        if (redisValue.HasValue)
        {
            value = new MemoryStream(redisValue);
            return true;
        }

        value = default;
        return false;
    }

    // Récupérer toutes les clés correspondant à un modèle de filtre à partir du cache
    public IEnumerable<string> GetKeys(string filter)
    {
        return _redis.GetServer(_host).Keys(pattern: $"*{filter}*")
            .Select(x => x.ToString().Replace(_cacheKeyPrefix, string.Empty))
            .Where(x => x.StartsWith(filter, StringComparison.InvariantCultureIgnoreCase))
            .ToList();
    }

    private string GetPrefixedKey(string key) => $"{_cacheKeyPrefix}{key}";

    public void Dispose()
    {
        _redis.Dispose();
    }
}

Explication:

Méthode de définition : Enregistre les données dans Redis à l’aide d’une clé de cache spécifique.
Méthode TryGetValue : Récupère les données mises en cache, si disponibles.
Méthode GetKeys : Récupère les clés correspondant à un modèle spécifié.

Étape 2 : Implémenter la conversion de documents avec un cache personnalisé

using System;
using System.Diagnostics;
using GroupDocs.Conversion.Options.Convert;
using GroupDocs.Conversion.Caching;

public class HowToUseCustomCacheImplementation
{
    public static void Run()
    {
        string outputDirectory = "YOUR_OUTPUT_DIRECTORY";
        
        RedisCache cache = new RedisCache("sample_");
        Func<ConverterSettings> settingsFactory = () => new ConverterSettings
        {
            Cache = cache
        };

        using (Converter converter = new Converter("YOUR_DOCUMENT_DIRECTORY/SAMPLE_PDF", settingsFactory))
        {
            PdfConvertOptions options = new PdfConvertOptions();
            
            Stopwatch stopWatch = Stopwatch.StartNew();
            converter.Convert($"{outputDirectory}/converted.pdf", options);
            stopWatch.Stop();

            stopWatch.Restart();
            converter.Convert($"{outputDirectory}/converted-1.pdf", options);
            stopWatch.Stop();
        }
    }
}

Explication:

Initialisation de RedisCache : Configure un cache avec un préfixe de clé.
Paramètres du convertisseur : Intègre le cache personnalisé dans les paramètres GroupDocs.Conversion.
Processus de conversion : Mesure et démontre les améliorations de performances en mettant en cache les résultats de conversion.

Applications pratiques

Cas d’utilisation :

Systèmes de gestion de documents d’entreprise : Améliorez la vitesse de rendu des documents pour les applications à grande échelle.
Services Web : Améliorez les temps de réponse des API gérant des conversions PDF fréquentes.
Réseaux de diffusion de contenu (CDN) : Mettez en cache et livrez rapidement des documents pré-convertis.
Plateformes d’analyse de données : Accélérez la génération de rapports impliquant la conversion de données en formats visuels.
Sites de commerce électronique : Optimisez le traitement du catalogue de produits en mettant en cache les images converties ou les aperçus de documents.

Possibilités d’intégration :

Combinez-le avec d’autres frameworks .NET comme ASP.NET Core pour les applications Web.
Intégrez-vous à l’architecture de microservices à l’aide de Docker et Kubernetes.

Considérations relatives aux performances

Pour optimiser les performances, tenez compte des éléments suivants :

Gestion de la taille du cache : Effacez régulièrement les anciennes entrées pour éviter un débordement de mémoire.
Regroupement de connexions : Utilisez le pool de connexions dans Redis pour gérer efficacement les ressources.
Sérialisation des données : Optez pour des formats de sérialisation efficaces (par exemple, Protocol Buffers) pour stocker les données dans Redis.

Conclusion

L’implémentation d’un cache Redis personnalisé avec GroupDocs.Conversion pour .NET peut considérablement améliorer les performances de conversion de documents de votre application. Ce tutoriel vous guide pas à pas pour configurer et utiliser ces puissants outils afin d’optimiser vos opérations.

Prochaines étapes :

Expérimentez avec différentes configurations de cache.
Explorez les fonctionnalités avancées de GroupDocs.Conversion pour des cas d’utilisation plus complexes.

Prêt à améliorer l’efficacité de votre application ? Commencez à déployer cette solution dès aujourd’hui !

Section FAQ

Comment installer Redis sur ma machine locale ?
- Suivez le guide d’installation officiel de Redis pour votre système d’exploitation : Téléchargement de Redis.
Quels sont les avantages de l’utilisation d’un cache personnalisé avec GroupDocs.Conversion ?
- Réduit le traitement redondant, accélère les temps de conversion et diminue l’utilisation des ressources.
Puis-je utiliser cette configuration dans des environnements cloud ?
- Absolument ! Assurez-vous que votre instance Redis est accessible depuis votre environnement applicatif.