Boost Your .NET Application Performance with Custom Redis Caching Using GroupDocs.Conversion

Introduction

Are you experiencing slow document conversion processes in your .NET applications? Enhance performance and efficiency by leveraging a custom Redis cache alongside GroupDocs.Conversion for .NET. This tutorial guides you through caching operations to speed up document rendering.

What You’ll Learn:

  • Setting up GroupDocs.Conversion for .NET
  • Implementing a custom Redis cache for document conversion
  • Optimizing performance with effective caching strategies

We will walk you through enhancing your application’s efficiency using these powerful tools. Before we begin, make sure you understand the prerequisites.

Prerequisites

To follow this tutorial, ensure you have:

Required Libraries and Versions:

  • GroupDocs.Conversion for .NET (Version 25.3.0)
  • StackExchange.Redis library for Redis operations
  • A running instance of a Redis server (e.g., 192.168.222.4:6379)

Environment Setup Requirements:

  • Visual Studio or another compatible IDE supporting C#
  • .NET Framework or .NET Core installed

Knowledge Prerequisites:

  • Basic understanding of C# and .NET programming
  • Familiarity with Redis as a caching solution
  • Experience with document conversion processes in software applications

Setting Up GroupDocs.Conversion for .NET

To start using GroupDocs.Conversion, install it via the NuGet Package Manager Console or the .NET CLI.

NuGet Package Manager Console:

Install-Package GroupDocs.Conversion -Version 25.3.0

.NET CLI:

dotnet add package GroupDocs.Conversion --version 25.3.0

License Acquisition Steps:

  • Free Trial: Test features and functionality with a temporary license.
  • Temporary License: Obtain for extended evaluation without limitations.
  • Purchase: For long-term use, consider purchasing a full license.

After installation, initialize GroupDocs.Conversion in your C# application:

using GroupDocs.Conversion;

Implementation Guide

Custom Cache Implementation Using Redis

This section demonstrates creating a custom cache using Redis for document rendering operations to enhance conversion speed and efficiency.

Overview

We’ll implement a Redis-based caching mechanism that stores rendered documents, avoiding redundant processing and significantly speeding up conversion times.

Step 1: Define the RedisCache Class
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();
    }

    // Set data in the cache with a specific key
    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));
        }
    }

    // Try to retrieve data from the cache using a key
    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;
    }

    // Retrieve all keys that match a filter pattern from the 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();
    }
}

Explanation:

  • Set Method: Saves data in Redis using a specific cache key.
  • TryGetValue Method: Retrieves cached data, if available.
  • GetKeys Method: Fetches keys matching a specified pattern.
Step 2: Implement Document Conversion with Custom Cache
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();
        }
    }
}

Explanation:

  • RedisCache Initialization: Sets up a cache with a key prefix.
  • ConverterSettings: Integrates the custom cache into GroupDocs.Conversion settings.
  • Conversion Process: Measures and demonstrates performance improvements by caching conversion results.

Practical Applications

Use Cases:

  1. Enterprise Document Management Systems: Improve document rendering speed for large-scale applications.
  2. Web Services: Enhance response times for APIs dealing with frequent PDF conversions.
  3. Content Delivery Networks (CDNs): Cache and deliver pre-converted documents quickly.
  4. Data Analytics Platforms: Accelerate report generation that involves converting data to visual formats.
  5. E-commerce Sites: Optimize product catalog processing by caching converted images or document previews.

Integration Possibilities:

  • Combine with other .NET frameworks like ASP.NET Core for web applications.
  • Integrate into microservices architecture using Docker and Kubernetes.

Performance Considerations

To optimize performance, consider the following:

  • Cache Size Management: Regularly clear old entries to prevent memory overflow.
  • Connection Pooling: Use connection pooling in Redis to manage resources efficiently.
  • Data Serialization: Opt for efficient serialization formats (e.g., Protocol Buffers) for storing data in Redis.

Conclusion

Implementing a custom Redis cache with GroupDocs.Conversion for .NET can significantly boost your application’s document conversion performance. This tutorial provided step-by-step guidance on setting up and utilizing these powerful tools to optimize operations.

Next Steps:

  • Experiment with different cache configurations.
  • Explore advanced features of GroupDocs.Conversion for more complex use cases.

Ready to enhance your application’s efficiency? Start implementing this solution today!

FAQ Section

  1. How do I install Redis on my local machine?
    • Follow the official Redis installation guide for your OS: Redis Download.
  2. What are the benefits of using a custom cache with GroupDocs.Conversion?
    • Reduces redundant processing, speeds up conversion times, and lowers resource usage.
  3. Can I use this setup in cloud environments?
    • Absolutely! Ensure your Redis instance is accessible from your application environment.