How to Generate PDFs with Async & Multithreading in C#

Why Should I Use Async Methods for PDF Generation?

Async methods provide key advantages for PDF generation workflows. They maintain application responsiveness during resource-intensive operations, enable better resource utilization on multi-core processors, and improve scalability in server environments. When handling complex HTML to PDF conversions, async operations prevent timeout issues and improve user experience.

:path=/static-assets/pdf/content-code-examples/how-to/async-async.cs

using IronPdf;
using System.Threading.Tasks;

// Instantiate ChromePdfRenderer
ChromePdfRenderer renderer = new ChromePdfRenderer();

string[] htmlStrings = {"<h1>Html 1</h1>", "<h1>Html 2</h1>", "<h1>Html 3</h1>"};

// Create an array to store the tasks for rendering
var renderingTasks = new Task<PdfDocument>[htmlStrings.Length];

for (int i = 0; i < htmlStrings.Length; i++)
{
    int index = i; // Capturing the loop variable
    renderingTasks[i] = Task.Run(async () =>
    {
        // Render HTML to PDF
        return await renderer.RenderHtmlAsPdfAsync(htmlStrings[index]);
    });
}

// Wait for all rendering tasks to complete
// await Task.WhenAll(renderingTasks);

What Are Common Patterns for Batch Processing?

Batch processing PDFs requires careful consideration of memory usage and performance. Effective patterns include using Task.WhenAll for parallel execution of multiple PDF generations, implementing producer-consumer patterns with channels for large batches, and utilizing parallel processing examples from the IronPDF documentation.

// Batch processing with progress tracking
public async Task<List<PdfDocument>> ProcessBatchAsync(List<string> htmlContents, IProgress<int> progress)
{
    var renderer = new ChromePdfRenderer();
    var results = new List<PdfDocument>();
    var completed = 0;

    var tasks = htmlContents.Select(async html => {
        var pdf = await renderer.RenderHtmlAsPdfAsync(html);
        Interlocked.Increment(ref completed);
        progress?.Report(completed);
        return pdf;
    });

    results.AddRange(await Task.WhenAll(tasks));
    return results;
}

// Batch processing with progress tracking
public async Task<List<PdfDocument>> ProcessBatchAsync(List<string> htmlContents, IProgress<int> progress)
{
    var renderer = new ChromePdfRenderer();
    var results = new List<PdfDocument>();
    var completed = 0;

    var tasks = htmlContents.Select(async html => {
        var pdf = await renderer.RenderHtmlAsPdfAsync(html);
        Interlocked.Increment(ref completed);
        progress?.Report(completed);
        return pdf;
    });

    results.AddRange(await Task.WhenAll(tasks));
    return results;
}

How Do I Handle Errors in Async PDF Operations?

Error handling in async PDF operations requires comprehensive exception management strategies. Use try-catch blocks within async methods, implement retry logic for transient failures, and consider using Polly for advanced retry policies. For detailed performance troubleshooting, IronPDF provides extensive logging capabilities.

public async Task<PdfDocument> RenderWithRetryAsync(string html, int maxRetries = 3)
{
    var renderer = new ChromePdfRenderer();

    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return await renderer.RenderHtmlAsPdfAsync(html);
        }
        catch (Exception ex) when (i < maxRetries - 1)
        {
            // Log the exception
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, i))); // Exponential backoff
        }
    }

    throw new InvalidOperationException("Failed to render PDF after maximum retries");
}

public async Task<PdfDocument> RenderWithRetryAsync(string html, int maxRetries = 3)
{
    var renderer = new ChromePdfRenderer();

    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return await renderer.RenderHtmlAsPdfAsync(html);
        }
        catch (Exception ex) when (i < maxRetries - 1)
        {
            // Log the exception
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, i))); // Exponential backoff
        }
    }

    throw new InvalidOperationException("Failed to render PDF after maximum retries");
}

When Should I Choose Multi-Threading Over Async?

Multi-threading is ideal for CPU-bound operations where you need to process multiple PDFs simultaneously with sufficient system resources. Choose multi-threading when processing large batches of PDFs on multi-core systems, when each PDF generation is independent, and when memory usage can be controlled. Async is better for I/O-bound operations and maintaining application responsiveness.

What Are the Thread-Safety Considerations?

IronPDF's ChromePdfRenderer is designed to be thread-safe, but certain considerations apply. Create separate renderer instances for each thread when using custom settings, avoid sharing PdfDocument instances between threads without synchronization, and monitor memory consumption when processing large documents concurrently. The installation overview provides additional details on configuring IronPDF for optimal thread safety.

// Thread-safe PDF generation with custom settings per thread
public void ProcessPdfsInParallel(List<string> htmlContents)
{
    Parallel.ForEach(htmlContents, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, 
        html =>
        {
            // Create a new renderer instance for each thread
            var renderer = new ChromePdfRenderer
            {
                RenderingOptions = new ChromePdfRenderOptions
                {
                    MarginTop = 10,
                    MarginBottom = 10,
                    PaperSize = IronPdf.Rendering.PdfPaperSize.A4
                }
            };

            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs($"output_{Thread.CurrentThread.ManagedThreadId}_{DateTime.Now.Ticks}.pdf");
        });
}

// Thread-safe PDF generation with custom settings per thread
public void ProcessPdfsInParallel(List<string> htmlContents)
{
    Parallel.ForEach(htmlContents, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, 
        html =>
        {
            // Create a new renderer instance for each thread
            var renderer = new ChromePdfRenderer
            {
                RenderingOptions = new ChromePdfRenderOptions
                {
                    MarginTop = 10,
                    MarginBottom = 10,
                    PaperSize = IronPdf.Rendering.PdfPaperSize.A4
                }
            };

            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs($"output_{Thread.CurrentThread.ManagedThreadId}_{DateTime.Now.Ticks}.pdf");
        });
}

How Many Concurrent Threads Should I Use?

The optimal number of concurrent threads depends on CPU cores, available memory, and PDF complexity. General guidelines include using Environment.ProcessorCount for CPU-bound operations, limiting to 2-4 threads for memory-intensive PDFs, and monitoring system resources to find the optimal configuration. The async examples demonstrate various threading strategies.

Why Does Async Perform Better Than Synchronous?

Async operations excel because they allow efficient thread pool resource management, prevent main thread blocking, and enable better CPU utilization during I/O operations. The performance improvement comes from starting multiple rendering operations simultaneously rather than waiting for each to complete sequentially.

How Can I Measure Performance in My Application?

Measuring PDF generation performance requires proper benchmarking and monitoring. Use System.Diagnostics.Stopwatch for accurate timing measurements, implement custom performance counters for production monitoring, and leverage application insights or similar APM tools. Consider using the quickstart guide examples as a baseline for performance testing.

public async Task<PerformanceMetrics> MeasurePerformanceAsync(string html, int iterations)
{
    var metrics = new PerformanceMetrics();
    var renderer = new ChromePdfRenderer();
    var stopwatch = new Stopwatch();

    // Warm-up run
    await renderer.RenderHtmlAsPdfAsync(html);

    for (int i = 0; i < iterations; i++)
    {
        stopwatch.Restart();
        await renderer.RenderHtmlAsPdfAsync(html);
        stopwatch.Stop();

        metrics.AddMeasurement(stopwatch.ElapsedMilliseconds);
    }

    return metrics;
}

public async Task<PerformanceMetrics> MeasurePerformanceAsync(string html, int iterations)
{
    var metrics = new PerformanceMetrics();
    var renderer = new ChromePdfRenderer();
    var stopwatch = new Stopwatch();

    // Warm-up run
    await renderer.RenderHtmlAsPdfAsync(html);

    for (int i = 0; i < iterations; i++)
    {
        stopwatch.Restart();
        await renderer.RenderHtmlAsPdfAsync(html);
        stopwatch.Stop();

        metrics.AddMeasurement(stopwatch.ElapsedMilliseconds);
    }

    return metrics;
}

What Factors Affect PDF Generation Speed?

Several factors impact PDF generation performance. HTML complexity, including JavaScript execution and CSS rendering, directly affects processing time. External resource loading, such as images and fonts, can introduce delays. System resources like CPU, memory, and disk I/O play crucial roles. IronPDF configuration, including rendering options and engine settings, also influences speed. Understanding these factors helps optimize your PDF generation workflow for maximum efficiency.

For complex scenarios involving heavy JavaScript or delayed rendering, consider using WaitFor mechanisms to ensure complete page rendering before PDF generation. This approach guarantees accurate output while maintaining predictable performance characteristics.