Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# Async Await
.NET AIDE

C# Async Await (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Leveraging Asynchronous Programming for Efficient PDF Processing in .NET

Dans les applications web et serveur modernes, la performance et la scalabilité sont primordiales. La programmation asynchrone en C# en utilisant les mots-clés async et await permet aux développeurs de créer des applications non bloquantes et très réactives. Lorsqu'elle est combinée avec des bibliothèques puissantes comme IronPDF, les développeurs peuvent pleinement tirer parti d'une méthode asynchrone, surtout lorsqu'il s'agit de tâches liées aux E/S, telles que la génération et la manipulation de PDF.

Dans cet article, nous allons explorer comment écrire du code asynchrone avec IronPDF, comparer la programmation synchrone et asynchrone, et fournir des exemples concrets pour des tâches comme la génération de PDF, l'extraction de texte et la manipulation. De plus, nous aborderons les meilleures pratiques pour gérer plusieurs tâches et démontrer comment écrire un code qui intègre harmonieusement le code synchrone et asynchrone.

Introduction à la programmation asynchrone

La programmation asynchrone en C# est une technique essentielle qui permet à vos applications d'effectuer des tâches sans bloquer le thread principal. Elle est particulièrement bénéfique pour gérer des opérations de longue durée telles que les requêtes de base de données, les E/S de fichiers, ou la génération ou la manipulation de fichiers PDF.

IronPDF est une bibliothèque robuste qui simplifie la manipulation de PDF dans les applications .NET. Elle permet de réaliser diverses opérations sur les PDF, de la conversion HTML en PDF à l'extraction de texte et d'images. En intégrant IronPDF avec des modèles de programmation asynchrone, les développeurs peuvent améliorer considérablement la performance des applications qui traitent des PDF.

Comprendre Async/Await en C#

Avant de plonger dans l'utilisation des mots-clés async/await avec IronPDF, examinons d'abord rapidement ce que font ces mots-clés et pourquoi ils sont importants dans le développement .NET moderne.

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é est appliqué 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
$vbLabelText   $csharpLabel

C# Async Await (Comment ça fonctionne pour les développeurs) : Figure 1

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 : Avec la programmation asynchrone, les opérations chronophages (telles que les E/S 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.
  • Amélioration de la scalabilité : Le mot-clé async permet à l'application de gérer plus d'opérations concurrentes avec moins de threads, améliorant ainsi la scalabilité.
  • Meilleure expérience utilisateur : Pour les applications de bureau ou web, les opérations asynchrones garantissent que l'interface utilisateur reste réactive aux inputs des utilisateurs pendant que les tâches s'exécutent en arrière-plan.

Code synchrone et asynchrone

Comprendre quand utiliser la programmation synchrone par rapport à la programmation asynchrone est crucial pour la conception efficace des applications.

  • Programmation synchrone : exécute une opération à la fois, bloquant le thread principal jusqu'à ce que l'opération soit terminée. Par exemple, une méthode qui génère un PDF avec un code synchrone pourrait ressembler à ceci :
public void GeneratePdfSync()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>");
    pdf.SaveAs("output.pdf");
}
public void GeneratePdfSync()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>");
    pdf.SaveAs("output.pdf");
}
Public Sub GeneratePdfSync()
	Dim renderer As New ChromePdfRenderer()
	Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>")
	pdf.SaveAs("output.pdf")
End Sub
$vbLabelText   $csharpLabel

Bien que simple, cette approche peut causer des goulets d'étranglement de performance, en particulier dans les applications web gérant plusieurs tâches ou dans des scénarios nécessitant des E/S intensives.

  • Programmation asynchrone : permet aux opérations de s'exécuter sans bloquer le thread principal. Ceci est particulièrement bénéfique pour les tâches liées aux E/S comme la génération de PDF, où vous pouvez utiliser du code asynchrone pour garder l'application réactive.

Dans la section suivante, nous explorerons comment intégrer la programmation asynchrone avec IronPDF pour améliorer votre traitement PDF.

Intégrer Async/Await avec IronPDF

IronPDF est une puissante bibliothèque de manipulation de PDFs pour .NET, conçue pour faciliter la manipulation des fichiers PDF. Elle offre des fonctionnalités qui vous permettent de générer, éditer et extraire du contenu de PDFs avec un minimum de configuration et d'effort de codage. Lorsque combinée avec le modèle C# async/await, IronPDF peut effectuer des opérations liées aux PDFs de manière non bloquante, améliorant ainsi la performance et la scalabilité des applications nécessitant un traitement de PDF intensif.

Aperçu d'IronPDF

C# Async Await (Comment ça fonctionne pour les développeurs) : Figure 2

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 en PDF : IronPDF peut convertir du contenu HTML (y compris CSS, images et JavaScript) en PDFs 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 éditant le contenu des pages existantes.
  • Extraction de texte et d'images : La bibliothèque permet de extraire des textes et des images de PDFs, facilitant ainsi le parsing et l'analyse du contenu PDF.
  • Remplissage de formulaires : IronPDF prend en charge le remplissage des champs de formulaires dans les PDFs, ce qui est utile pour générer des documents personnalisés.
  • Filigranage : Il est également possible d'ajouter des filigranes aux documents PDF pour le branding ou la protection du droit 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 PDFs basés sur un contenu dynamique, exécuter ces processus de manière asynchrone permet au système de rester réactif pendant que les PDFs sont créés.
  • Manipulation de PDF : Si vous devez modifier de grands PDFs, comme ajouter des filigranes ou fusionner des documents, effectuer ces tâches de manière asynchrone garantit que votre application ne se bloque pas pendant que ces opérations chronophages sont traitées en arrière-plan.
  • E/S de fichiers : Lire et écrire des PDFs est une opération liée aux 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
$vbLabelText   $csharpLabel

C# Async Await (Comment ça fonctionne pour les développeurs) : Figure 3

Comment cela fonctionne

  1. Création du convertisseur HTML en PDF : La classe ChromePdfRenderer est utilisée pour convertir du contenu HTML en PDF. In this example, we pass simple HTML content as a string ("

    Async PDF Example

    "), but in a real application, this could be dynamic HTML, such as a report template.

  2. Utilisation de Task.Run pour la génération de PDF asynchrone : La méthode RenderHtmlAsPdf n'est pas async par défaut, donc nous utilisons Task.Run() pour décharger la génération de PDF sur un thread en 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. Sauvegarde du PDF : Après la génération du PDF, il est sauvegardé 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 s'assurer qu'elle ne bloque pas le thread principal pendant la sauvegarde du fichier.

  4. Attend des opérations : Le mot-clé await garantit que chaque opération asynchrone est complété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
$vbLabelText   $csharpLabel

C# Async Await (Comment ça fonctionne pour les développeurs) : Figure 4

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 sur le pool de threads : Puisque IronPDF repose sur des threads en arrière-plan pour le traitement, soyez attentif au pool de threads lorsque vous utilisez 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.
  • Tokens 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 tokens d'annulation pour 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
$vbLabelText   $csharpLabel
  • Gestion des erreurs : Comme pour toute opération asynchrone, assurez-vous de gérer correctement les exceptions qui peuvent survenir lors du traitement des PDFs, telles que les problèmes d'accès aux fichiers ou des données d'entrée invalides.
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
$vbLabelText   $csharpLabel

Conclusion

IronPDF est une bibliothèque de manipulation de PDFs polyvalente et puissante qui fonctionne exceptionnellement bien avec le modèle C# async/await. En exploitant la programmation asynchrone avec IronPDF, vous pouvez améliorer considérablement la performance et la scalabilité de vos applications .NET qui traitent de la génération et de la manipulation de PDFs. Que ce soit pour générer des rapports dynamiques, extraire des données de documents ou éditer des PDFs, l'intégration transparente d'IronPDF avec la programmation asynchrone en fait un excellent choix pour les développeurs .NET modernes.

N'oubliez pas d'explorer l'essai gratuit d'IronPDF, qui offre un accès à toutes les fonctionnalités et vous permet de tester ces capacités dans vos propres projets. En incorporant des opérations asynchrones avec IronPDF, vous pourrez créer des applications plus rapides et plus efficaces qui évoluent mieux avec l'augmentation de la charge de travail.

Questions Fréquemment Posées

Comment puis-je convertir HTML en PDF en C# en utilisant la programmation asynchrone ?

Vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF conjointement avec Task.Run pour effectuer la conversion HTML en PDF de manière asynchrone. Cette approche garantit que le thread principal n'est pas bloqué pendant le processus de génération du PDF.

Quels sont les avantages de l'utilisation de la programmation asynchrone en C# ?

La programmation asynchrone en C# permet aux applications d'exécuter des tâches sans bloquer le thread principal, ce qui améliore la réactivité et l'évolutivité des applications. Cela est particulièrement utile lors de longues opérations comme le traitement de PDF avec des bibliothèques telles qu'IronPDF.

Comment async et await améliorent-ils les performances des applications C# ?

Les mots-clés async et await permettent aux applications de rester réactives en libérant le thread principal tout en attendant que les opérations longues se terminent. Cela améliore les performances et l'évolutivité, surtout lorsqu'ils sont utilisés avec des bibliothèques comme IronPDF pour des tâches telles que la génération de PDF.

La programmation asynchrone peut-elle être utilisée avec les bibliothèques PDF ?

Oui, la programmation asynchrone peut être intégrée efficacement avec des bibliothèques PDF comme IronPDF. Bien que ces bibliothèques ne soient pas nativement asynchrones, utiliser Task.Run vous permet d'effectuer des opérations PDF de manière non bloquante.

Quelles sont les bonnes pratiques pour utiliser async/await avec le traitement PDF en C# ?

Les bonnes pratiques incluent l'utilisation de jetons d'annulation pour les opérations longues, l'évitement des méthodes async void et l'assurance d'une bonne gestion des erreurs lors du traitement PDF avec des bibliothèques comme IronPDF. Cela garantit des applications robustes et réactives.

Comment la programmation asynchrone améliore-t-elle l'évolutivité des applications Web ?

La programmation asynchrone permet aux applications Web de gérer plus d'opérations simultanées avec moins de threads, améliorant l'évolutivité en gérant efficacement les ressources et en réduisant les goulots d'étranglement. Cela est particulièrement bénéfique pour les tâches impliquant le traitement de PDF avec des bibliothèques comme IronPDF.

Pourquoi la programmation asynchrone est-elle importante pour les applications Web modernes ?

La programmation asynchrone garantit des opérations non bloquantes, permettant aux serveurs Web de gérer plusieurs requêtes simultanément et d'offrir de meilleures expériences utilisateur avec des interfaces réactives. Cette approche bénéficie à des tâches telles que la génération de PDF lors de l'utilisation de bibliothèques comme IronPDF.

Quel est un exemple simple d'utilisation de async/await pour la génération de PDF en C# ?

Un exemple simple consiste à utiliser IronPDF pour convertir HTML en PDF de manière asynchrone en encapsulant le code de génération de PDF dans Task.Run et en utilisant await pour enregistrer le PDF, garantissant que l'opération ne bloque pas le thread principal.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit