Comment générer des PDF avec Async & Multithreading en C

Pourquoi utiliser des méthodes asynchrones pour la génération de PDF ?

Les méthodes asynchrones offrent des avantages clés pour les flux de travail de génération de PDF. Ils maintiennent la réactivité des applications lors d'opérations gourmandes en ressources, permettent une meilleure utilisation des ressources sur les processeurs multicœurs et améliorent l'évolutivité dans les environnements de serveurs. Lors de la gestion de conversions HTML à PDF complexes, les opérations asynchrones évitent les problèmes de dépassement de délai et améliorent l'expérience de l'utilisateur.

: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);

Imports IronPdf
Imports System.Threading.Tasks

' Instantiate ChromePdfRenderer
Private renderer As New ChromePdfRenderer()

Private htmlStrings() As String = {"<h1>Html 1</h1>", "<h1>Html 2</h1>", "<h1>Html 3</h1>"}

' Create an array to store the tasks for rendering
Private renderingTasks = New Task(Of PdfDocument)(htmlStrings.Length - 1){}

For i As Integer = 0 To htmlStrings.Length - 1
	Dim index As Integer = i ' Capturing the loop variable
	renderingTasks(i) = Task.Run(Async Function()
		' Render HTML to PDF
		Return Await renderer.RenderHtmlAsPdfAsync(htmlStrings(index))
	End Function)
Next i

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

Quels sont les modèles courants de traitement par lots ?

Le traitement par lots des PDF nécessite une attention particulière à l'utilisation de la mémoire et aux performances. Les modèles efficaces comprennent l'utilisation de Task.WhenAll pour l'exécution parallèle de plusieurs générations de PDF, la mise en œuvre de modèles producteur-consommateur avec des canaux pour les grands lots et l'utilisation d'exemples de traitement parallèle tirés de la documentation IronPDF .

// 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;
}

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

' Batch processing with progress tracking
Public Async Function ProcessBatchAsync(htmlContents As List(Of String), progress As IProgress(Of Integer)) As Task(Of List(Of PdfDocument))
    Dim renderer As New ChromePdfRenderer()
    Dim results As New List(Of PdfDocument)()
    Dim completed As Integer = 0

    Dim tasks = htmlContents.Select(Async Function(html)
                                        Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
                                        Interlocked.Increment(completed)
                                        progress?.Report(completed)
                                        Return pdf
                                    End Function)

    results.AddRange(Await Task.WhenAll(tasks))
    Return results
End Function

Comment gérer les erreurs dans les opérations PDF asynchrones ?

La gestion des erreurs dans les opérations PDF asynchrones nécessite des stratégies complètes de gestion des exceptions. Utilisez des blocs try-catch dans les méthodes asynchrones, mettez en œuvre une logique de relance pour les échecs transitoires et envisagez d'utiliser Polly pour des politiques de relance avancées. Pour un dépannage détaillé des performances, IronPDF offre des fonctionnalités de journalisation étendues.

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");
}

Imports System
Imports System.Threading.Tasks

Public Class PdfRenderer
    Public Async Function RenderWithRetryAsync(html As String, Optional maxRetries As Integer = 3) As Task(Of PdfDocument)
        Dim renderer As New ChromePdfRenderer()

        For i As Integer = 0 To maxRetries - 1
            Try
                Return Await renderer.RenderHtmlAsPdfAsync(html)
            Catch ex As Exception When i < maxRetries - 1
                ' Log the exception
                Await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, i))) ' Exponential backoff
            End Try
        Next

        Throw New InvalidOperationException("Failed to render PDF after maximum retries")
    End Function
End Class

Quand choisir le multithreading plutôt que l'asynchrone?

Le multithreading est idéal pour les opérations liées à l'unité centrale, lorsque vous devez traiter plusieurs PDF simultanément avec des ressources système suffisantes. Choisissez le multithreading lorsque vous traitez des lots importants de PDF sur des systèmes multicœurs, lorsque chaque génération de PDF est indépendante et lorsque l'utilisation de la mémoire peut être contrôlée. Async est meilleur pour les opérations liées aux E/S et pour maintenir la réactivité de l'application.

Quelles sont les considérations relatives à la sécurité des threads ?

IronPDF's ChromePdfRenderer est conçu pour être sûr en matière de threads, mais certaines considérations s'appliquent. Créez des instances de rendu distinctes pour chaque thread lorsque vous utilisez des paramètres personnalisés, évitez de partager des instances PdfDocument entre les threads sans synchronisation et surveillez la consommation de mémoire lors du traitement simultané de documents volumineux. La vue d'ensemble de l'installation fournit des détails supplémentaires sur la configuration d'IronPdf pour une sécurité optimale des threads.

// 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");
        });
}

Imports System
Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks
Imports IronPdf

' Thread-safe PDF generation with custom settings per thread
Public Sub ProcessPdfsInParallel(htmlContents As List(Of String))
    Parallel.ForEach(htmlContents, New ParallelOptions With {.MaxDegreeOfParallelism = Environment.ProcessorCount},
        Sub(html)
            ' Create a new renderer instance for each thread
            Dim renderer = New ChromePdfRenderer With {
                .RenderingOptions = New ChromePdfRenderOptions With {
                    .MarginTop = 10,
                    .MarginBottom = 10,
                    .PaperSize = IronPdf.Rendering.PdfPaperSize.A4
                }
            }

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

Combien de threads simultanés dois-je utiliser?

Le nombre optimal de threads simultanés dépend des cœurs du processeur, de la mémoire disponible et de la complexité du PDF. Les directives générales comprennent l'utilisation de Environment.ProcessorCount pour les opérations gourmandes en ressources CPU, la limitation à 2-4 threads pour les PDF nécessitant beaucoup de mémoire et la surveillance des ressources système pour trouver la configuration optimale. Les exemples d'async démontrent différentes stratégies de threading.

Pourquoi l'asynchrone est-il plus performant que le synchrone?

Les opérations asynchrones sont excellentes parce qu'elles permettent une gestion efficace des ressources du pool de threads, empêchent le blocage du thread principal et permettent une meilleure utilisation de l'unité centrale pendant les opérations d'entrée/sortie. L'amélioration des performances provient du lancement simultané de plusieurs opérations de rendu au lieu d'attendre que chacune d'entre elles se termine de manière séquentielle.

Comment puis-je mesurer les performances de mon application ?

Pour mesurer les performances de la génération de PDF, il est nécessaire de procéder à une analyse comparative et à un suivi appropriés. Utilisez System.Diagnostics.Stopwatch pour des mesures de temps précises, implémentez des compteurs de performance personnalisés pour la surveillance de la production et tirez parti des informations sur l'application ou d'outils APM similaires. Envisagez d'utiliser les exemples du guide de démarrage rapide comme base de référence pour les tests de performance.

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;
}

Imports System.Diagnostics
Imports System.Threading.Tasks

Public Class PerformanceMetrics
    ' Assume this class has an AddMeasurement method
    Public Sub AddMeasurement(milliseconds As Long)
        ' Implementation here
    End Sub
End Class

Public Class ChromePdfRenderer
    ' Assume this class has a RenderHtmlAsPdfAsync method
    Public Async Function RenderHtmlAsPdfAsync(html As String) As Task
        ' Implementation here
    End Function
End Class

Public Class PerformanceTester
    Public Async Function MeasurePerformanceAsync(html As String, iterations As Integer) As Task(Of PerformanceMetrics)
        Dim metrics As New PerformanceMetrics()
        Dim renderer As New ChromePdfRenderer()
        Dim stopwatch As New Stopwatch()

        ' Warm-up run
        Await renderer.RenderHtmlAsPdfAsync(html)

        For i As Integer = 0 To iterations - 1
            stopwatch.Restart()
            Await renderer.RenderHtmlAsPdfAsync(html)
            stopwatch.Stop()

            metrics.AddMeasurement(stopwatch.ElapsedMilliseconds)
        Next

        Return metrics
    End Function
End Class

Quels sont les facteurs qui influencent la vitesse de génération des PDF ?

Plusieurs facteurs influent sur les performances de la génération de PDF. La complexité du HTML, y compris l'exécution de JavaScript et le rendu CSS, affecte directement le temps de traitement. Le chargement de ressources externes, telles que les images et les polices, peut entraîner des retards. Les ressources système telles que l'unité centrale, la mémoire et les entrées/sorties de disque jouent un rôle crucial. La configuration d'IronPDF, notamment les options de rendu et les paramètres du moteur, influe également sur la vitesse. La compréhension de ces facteurs permet d'optimiser votre flux de travail de génération de PDF pour une efficacité maximale.

Pour les scénarios complexes impliquant un JavaScript lourd ou un rendu différé, envisagez d'utiliser des mécanismes WaitFor pour garantir un rendu complet de la page avant la génération du PDF. Cette approche garantit un résultat précis tout en maintenant des caractéristiques de performance prévisibles.