Qu'est-ce qu'async/await ?

Les mots-clés async et await sont utilisés pour définir des méthodes asynchrones en C#. Une méthode asynchrone effectue une opération sans bloquer l'exécution du thread principal de l'application, permettant à celle-ci de rester réactive même lors de l'exécution de tâches longues.

• async : Ce mot-clé s'applique aux méthodes qui sont censées effectuer des opérations asynchrones. Il indique que la méthode contient au moins une expression await.
• await : Ce mot-clé est utilisé pour suspendre l'exécution de la méthode jusqu'à ce que la tâche attendue soit terminée. Il s'assure que le thread est libre pour exécuter d'autres tâches en attendant la fin de l'opération.

public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}

public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}

Public Async Function WaitExampleAsync() As Task
	Await Task.Delay(1000) ' Waits for 1 second without blocking the thread
	Console.WriteLine("Finished waiting asynchronously!")
End Function

Les méthodes asynchrones améliorent la réactivité en libérant le thread principal pour gérer d'autres opérations pendant l'attente de l'achèvement des tâches.

Principaux avantages de la programmation asynchrone

• Opérations non bloquantes : grâce à la programmation asynchrone, les opérations qui prennent du temps (comme les entrées/sorties de fichiers ou les requêtes réseau) ne bloquent pas le thread principal. C'est crucial pour les applications web, où des opérations non bloquantes garantissent que le serveur peut gérer plusieurs requêtes simultanément.
• Évolutivité améliorée : le mot-clé async permet à l'application de gérer davantage d'opérations simultanées avec moins de threads, améliorant ainsi l'évolutivité.
• Meilleure expérience utilisateur : pour les applications de bureau ou Web, les opérations asynchrones garantissent que l'interface utilisateur reste réactive aux entrées de l'utilisateur pendant que des tâches s'exécutent en arrière-plan.

Aperçu d'IronPDF

IronPDF permet aux développeurs .NET d'intégrer directement des fonctionnalités PDF dans leurs applications, que ce soit pour des environnements web ou de bureau. Voici quelques-unes des principales fonctionnalités qu'IronPDF offre :

• Conversion HTML vers PDF : IronPDF peut convertir le contenu HTML (y compris CSS, images et JavaScript) en PDF entièrement formatés. Ceci est particulièrement utile pour rendre des pages web dynamiques ou des rapports sous forme de PDFs.
• Édition de PDF : Avec IronPDF, vous pouvez manipuler des documents PDF existants en ajoutant du texte, des images et des graphiques, ainsi qu'en modifiant le contenu des pages existantes.
• Extraction de texte et d'images : La bibliothèque vous permet d' extraire du texte et des images à partir de fichiers PDF, ce qui facilite l'analyse du contenu des PDF.
• Remplissage de formulaires : IronPDF prend en charge le remplissage des champs de formulaire dans les PDF, ce qui est utile pour générer des documents personnalisés.
• Filigrane : Il est également possible d'ajouter des filigranes aux documents PDF à des fins de branding ou de protection des droits d'auteur.

Pourquoi utiliser IronPDF avec async/await ?

Bien qu'IronPDF ne soit pas nativement asynchrone, elle est bien adaptée aux modèles async/await en raison de la nature liée aux E/S de la plupart des tâches de traitement PDF. Par exemple, la conversion HTML en PDF ou le chargement d'un document PDF volumineux peut prendre un temps considérable, mais cela peut être fait de manière asynchrone pour éviter de bloquer le thread principal.

Voici quelques exemples de la façon dont IronPDF convient bien à la programmation asynchrone :

• Génération de PDF : Si votre application doit générer plusieurs PDF à partir de contenu dynamique, l'exécution asynchrone de ces processus permet au système de rester réactif pendant la création des PDF.
• Manipulation de fichiers PDF : Si vous devez modifier des fichiers PDF volumineux, par exemple en ajoutant des filigranes ou en fusionnant des documents, effectuer ces tâches de manière asynchrone garantit que votre application ne se bloque pas pendant le traitement de ces opérations longues en arrière-plan.
• E/S de fichiers : La lecture et l'écriture de fichiers PDF sont des opérations limitées par les E/S. La programmation asynchrone est parfaite pour ces tâches, car elle libère les ressources système et évite le blocage inutile.

Exemple de base : génération de PDF asynchrone avec IronPDF

Voici un exemple d'écriture d'un code asynchrone avec IronPDF pour générer un fichier PDF :

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));

        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));

        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}

Imports IronPdf

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Initialize renderer
		Dim renderer As New ChromePdfRenderer()

		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"))

		' Save the generated PDF to a file
		Await Task.Run(Function() pdf.SaveAs("output.pdf"))
	End Function
End Class

Comment cela fonctionne

1. Création du convertisseur HTML vers PDF :
   La classe ChromePdfRenderer est utilisée pour convertir du contenu HTML en PDF. Dans cet exemple, nous passons du contenu HTML simple sous forme de chaîne ("

   Async PDF Example

   "), mais dans une application réelle, cela pourrait être du HTML dynamique, comme un modèle de rapport.

2. Utilisation de Task.Run pour la génération asynchrone de PDF :
   La méthode RenderHtmlAsPdf n'est pas asynchrone par défaut, nous utilisons donc Task.Run() pour décharger la génération de PDF sur un thread d'arrière-plan. C'est important car la génération de PDF peut être gourmande en ressources et chronophage, en particulier lorsqu'elle traite des documents volumineux ou complexes.

3. Enregistrement du PDF :
   Une fois le PDF généré, il est enregistré dans le système de fichiers en utilisant pdf.SaveAs(). Cette opération d'E/S est également enveloppée dans un Task.Run() pour garantir qu'elle ne bloque pas le thread principal pendant l'enregistrement du fichier.

4. En attente d'opérations :
   Le mot-clé await garantit que chaque opération asynchrone est terminée avant que la suivante ne commence. En attendant la fin de la génération du PDF, le thread principal reste libre pour gérer d'autres tâches (par exemple, servir d'autres requêtes HTTP dans une application web).

Gestion de plusieurs tâches avec IronPDF

Pour les applications traitant de grands PDFs, vous pourriez avoir besoin d'effectuer plusieurs opérations, telles que diviser, fusionner ou ajouter du contenu à de grands fichiers. L'utilisation d'async garantit que pendant qu'une opération est en cours de traitement, l'application reste réactive aux entrées des utilisateurs ou aux requêtes.

Par exemple, vous pourriez combiner plusieurs opérations asynchrones dans un pipeline :

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));

        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));

        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}

using IronPdf;

public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");

        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));

        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));

        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}

Imports IronPdf

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim renderer As New ChromePdfRenderer()
		Dim page As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>")

		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() PdfDocument.FromFile("output.pdf"))

		' Perform some operations asynchronously
		Await Task.Run(Function() pdf.ApplyWatermark("Confidential"))

		Dim merged As PdfDocument = Await Task.Run(Function() PdfDocument.Merge(pdf, page))
		Await Task.Run(Function() merged.SaveAs("processed_output.pdf"))
	End Function
End Class

Dans cet exemple, nous chargeons un fichier PDF et en créons un nouveau, ajoutons un filigrane, fusionnons les deux PDFs et le sauvegardons, le tout sans bloquer le thread principal.

Meilleures pratiques pour les opérations asynchrones avec IronPDF

• Considérations relatives au pool de threads : étant donné IronPDF s'appuie sur des threads d'arrière-plan pour le traitement, tenez compte du pool de threads lors de l'utilisation de Task.Run(). Pour les tâches à fréquence élevée, envisagez d'utiliser un service en arrière-plan dédié ou de mettre en file d'attente les tâches pour éviter de submerger le pool de threads.
• Évitez les méthodes async void : utilisez toujours async Task pour les méthodes qui effectuent des opérations asynchrones. Réservez les méthodes async void pour les gestionnaires d'événements.
• Jetons d'annulation : Pour les opérations de longue durée comme la génération de PDF ou l'extraction de texte, il est judicieux de prendre en charge les jetons d'annulation afin de permettre aux utilisateurs d'annuler l'opération si nécessaire. Cela garantit que les ressources sont libérées si l'opération n'est plus nécessaire.

public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);

    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}

public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);

    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}

Public Async Function GeneratePdfWithCancellationAsync(ByVal cancellationToken As CancellationToken) As Task
	Dim renderer As New ChromePdfRenderer()
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken)

	If cancellationToken.IsCancellationRequested Then
		Console.WriteLine("Operation was canceled.")
		Return
	End If
	pdf.SaveAs("output.pdf")
End Function

• Gestion des erreurs : comme pour toute opération asynchrone, assurez-vous d'une gestion appropriée des erreurs pour les exceptions pouvant survenir lors du traitement des fichiers PDF, telles que les problèmes d'accès aux fichiers ou les données d'entrée non valides.

try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Try
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"))
	pdf.SaveAs("output.pdf")
Catch ex As Exception
	Console.WriteLine($"Error: {ex.Message}")
End Try