Aumente o desempenho do seu aplicativo .NET com cache Redis personalizado usando GroupDocs.Conversion

Introdução

Você está enfrentando processos lentos de conversão de documentos em seus aplicativos .NET? Melhore o desempenho e a eficiência utilizando um cache Redis personalizado em conjunto com o GroupDocs.Conversion para .NET. Este tutorial orienta você nas operações de cache para acelerar a renderização de documentos.

O que você aprenderá:

  • Configurando GroupDocs.Conversion para .NET
  • Implementando um cache Redis personalizado para conversão de documentos
  • Otimizando o desempenho com estratégias de cache eficazes

Vamos orientá-lo sobre como aprimorar a eficiência do seu aplicativo usando essas ferramentas poderosas. Antes de começar, certifique-se de entender os pré-requisitos.

Pré-requisitos

Para seguir este tutorial, certifique-se de ter:

Bibliotecas e versões necessárias:

  • GroupDocs.Conversion para .NET (Versão 25.3.0)
  • StackExchange.Redis biblioteca para operações Redis
  • Uma instância em execução de um servidor Redis (por exemplo, 192.168.222.4:6379)

Requisitos de configuração do ambiente:

  • Visual Studio ou outro IDE compatível com C#
  • .NET Framework ou .NET Core instalado

Pré-requisitos de conhecimento:

  • Noções básicas de programação em C# e .NET
  • Familiaridade com o Redis como solução de cache
  • Experiência com processos de conversão de documentos em aplicações de software

Configurando GroupDocs.Conversion para .NET

Para começar a usar o GroupDocs.Conversion, instale-o por meio do Console do Gerenciador de Pacotes NuGet ou do .NET CLI.

Console do gerenciador de pacotes NuGet:

Install-Package GroupDocs.Conversion -Version 25.3.0

CLI .NET:

dotnet add package GroupDocs.Conversion --version 25.3.0

Etapas de aquisição de licença:

  • Teste gratuito: Teste recursos e funcionalidades com uma licença temporária.
  • Licença temporária: Obtenha uma avaliação estendida sem limitações.
  • Comprar: Para uso a longo prazo, considere comprar uma licença completa.

Após a instalação, inicialize GroupDocs.Conversion no seu aplicativo C#:

using GroupDocs.Conversion;

Guia de Implementação

Implementação de cache personalizado usando Redis

Esta seção demonstra a criação de um cache personalizado usando o Redis para operações de renderização de documentos para melhorar a velocidade e a eficiência da conversão.

Visão geral

Implementaremos um mecanismo de cache baseado em Redis que armazena documentos renderizados, evitando processamento redundante e acelerando significativamente os tempos de conversão.

Etapa 1: definir a 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();
    }

    // Definir dados no cache com uma chave específica
    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));
        }
    }

    // Tente recuperar dados do cache usando uma chave
    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;
    }

    // Recuperar todas as chaves que correspondem a um padrão de filtro do 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();
    }
}

Explicação:

  • Método de configuração: Salva dados no Redis usando uma chave de cache específica.
  • Método TryGetValue: Recupera dados em cache, se disponíveis.
  • Método GetKeys: Busca chaves que correspondem a um padrão especificado.
Etapa 2: implementar conversão de documentos com cache personalizado
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();
        }
    }
}

Explicação:

  • Inicialização do RedisCache: Configura um cache com um prefixo de chave.
  • Configurações do conversor: Integra o cache personalizado nas configurações do GroupDocs.Conversion.
  • Processo de conversão: Mede e demonstra melhorias de desempenho armazenando em cache os resultados de conversão.

Aplicações práticas

Casos de uso:

  1. Sistemas de gerenciamento de documentos empresariais: Melhore a velocidade de renderização de documentos para aplicativos de grande escala.
  2. Serviços Web: Melhore os tempos de resposta para APIs que lidam com conversões frequentes de PDF.
  3. Redes de distribuição de conteúdo (CDNs): Armazene em cache e entregue documentos pré-convertidos rapidamente.
  4. Plataformas de análise de dados: Acelere a geração de relatórios que envolvem a conversão de dados em formatos visuais.
  5. Sites de comércio eletrônico: Otimize o processamento do catálogo de produtos armazenando em cache imagens convertidas ou visualizações de documentos.

Possibilidades de integração:

  • Combine com outras estruturas .NET, como o ASP.NET Core, para aplicativos web.
  • Integre à arquitetura de microsserviços usando Docker e Kubernetes.

Considerações de desempenho

Para otimizar o desempenho, considere o seguinte:

  • Gerenciamento do tamanho do cache: Limpe regularmente entradas antigas para evitar estouro de memória.
  • Pool de conexões: Use o pool de conexões no Redis para gerenciar recursos com eficiência.
  • Serialização de dados: Opte por formatos de serialização eficientes (por exemplo, Protocol Buffers) para armazenar dados no Redis.

Conclusão

Implementar um cache Redis personalizado com o GroupDocs.Conversion para .NET pode aumentar significativamente o desempenho de conversão de documentos do seu aplicativo. Este tutorial oferece orientações passo a passo sobre como configurar e utilizar essas ferramentas poderosas para otimizar as operações.

Próximos passos:

  • Experimente diferentes configurações de cache.
  • Explore recursos avançados do GroupDocs.Conversion para casos de uso mais complexos.

Pronto para aumentar a eficiência do seu aplicativo? Comece a implementar esta solução hoje mesmo!

Seção de perguntas frequentes

  1. Como instalo o Redis na minha máquina local?
    • Siga o guia oficial de instalação do Redis para seu sistema operacional: Baixar Redis.
  2. Quais são os benefícios de usar um cache personalizado com o GroupDocs.Conversion?
    • Reduz o processamento redundante, acelera os tempos de conversão e diminui o uso de recursos.
  3. Posso usar esta configuração em ambientes de nuvem?
    • Com certeza! Certifique-se de que sua instância do Redis esteja acessível a partir do seu ambiente de aplicação.