using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
C# Async Await (Comment cela fonctionne pour les développeurs)
Chaknith Bin
janvier 14, 2025
Partager:
Tirez parti de la puissance de la programmation asynchrone pour un meilleur traitement des PDF dans les applications .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'ils sont combinés avec des bibliothèques puissantes comme IronPDF, les développeurs peuvent tirer pleinement parti d'une méthode asynchrone, notamment lorsqu'ils travaillent avec des tâches liées à l'I/O telles que la génération et la manipulation de PDF.
Dans cet article, nous explorerons comment écrire du code asynchrone avec IronPDF, comparerons la programmation synchrone et la programmation asynchrone, et fournirons des exemples concrets pour des tâches telles que la génération de PDF, l'extraction et la manipulation de texte. En outre, nous aborderons les meilleures pratiques pour gérer plusieurs tâches et démontrerons comment écrire du code qui intègre à la fois du code synchrone et asynchrone de manière transparente.
Introduction à la programmation asynchrone
La programmation asynchrone en C# est une technique essentielle qui permet à vos applications d'exécuter des tâches sans bloquer le thread principal. Il est particulièrement bénéfique pour gérer des opérations de longue durée telles que les requêtes de bases de données, les entrées/sorties de fichiers, ou dans ce cas, la génération ou la manipulation de fichiers PDF.
IronPDF est une bibliothèque robuste qui simplifie la manipulation des PDF dans les applications .NET. Il permet diverses opérations PDF, allant de la conversion de 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 les performances des applications traitant des PDFs.
Comprendre Async/Await en C
Avant d'explorer comment utiliser async/await avec IronPDF, examinons d'abord rapidement ce que font ces mots-clés et pourquoi ils sont importants dans le développement moderne de .NET.
Qu'est-ce que 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 exécute une opération sans bloquer l'exécution du thread principal de l'application, permettant ainsi à l'application de rester réactive même lorsqu'elle effectue des tâches longues.
async : Ce mot-clé est appliqué aux méthodes qui sont censées effectuer des opérations asynchrones. Cela 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. Cela garantit que le thread est libre d'exécuter d'autres tâches en attendant que l'opération se termine.
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
Les méthodes asynchrones améliorent la réactivité en libérant le thread principal pour gérer d'autres opérations en attendant que les tâches se terminent.
Principaux avantages de la programmation asynchrone
Opérations non bloquantes : Avec la programmation asynchrone, les opérations chronophages (telles que les entrées/sorties de fichiers ou les requêtes réseau) ne bloquent pas le thread principal. Ceci est crucial pour les applications web, où les opérations non bloquantes garantissent que le serveur peut gérer plusieurs requêtes simultanément.
Amélioration de l'évolutivité : Le mot-clé async permet à l'application de gérer plus d'opérations concurrentes 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 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 essentiel pour une conception d'application efficace.
La 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 du 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 cette approche soit simple, elle peut entraîner des goulets d'étranglement de performance, en particulier dans les applications web gérant plusieurs tâches ou dans des scénarios nécessitant un I/O intensif.
La programmation asynchrone permet aux opérations de s'exécuter sans bloquer le thread principal. Cela est particulièrement bénéfique pour les tâches dépendantes des entrées/sorties, comme la génération de PDF, où vous pouvez utiliser du code asynchrone pour maintenir l'application réactive.
Dans la section suivante, nous explorerons comment intégrer la programmation asynchrone avec IronPDF pour améliorer votre traitement de PDF.
Intégration d'Async/Await avec IronPDF
IronPDF est une bibliothèque puissante de manipulation de PDF pour .NET, conçue pour faciliter le travail avec les fichiers PDF. Il offre des fonctionnalités qui vous permettent de générer, modifier et extraire du contenu de fichiers PDF avec un minimum de configuration et d'effort de codage. Lorsqu'il est combiné avec le modèle async/await de C#, IronPDF peut effectuer des opérations relatives aux PDF de manière non bloquante, améliorant à la fois la performance et l'évolutivité dans les applications nécessitant un traitement intensif des PDF.
Présentation 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 offertes par IronPDF :
Conversion HTML en 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 générer des pages Web dynamiques ou des rapports sous forme de PDF.
É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 PDF, facilitant ainsi l'analyse et l'interprétation du contenu PDF.
Remplissage de formulaires : IronPDF prend en charge le remplissage des champs de formulaire dans les PDFs, ce qui est utile pour générer des documents personnalisés.
Filigrane : Il est également possible d'ajouter des filigranes aux documents PDF pour le branding ou la protection des droits d'auteur.
Pourquoi utiliser IronPDF avec Async/Await ?
Bien qu'IronPDF ne soit pas asynchrone de manière native, il est bien adapté aux modèles async/await en raison de la nature liée à l'I/O de la plupart des tâches de traitement PDF. Par exemple, la conversion d'HTML en PDF ou le chargement d'un document PDF volumineux peut prendre un temps significatif, mais cela peut être fait de manière asynchrone pour éviter de bloquer le fil principal.
Voici quelques exemples de la façon dont IronPDF s'intègre bien avec la programmation asynchrone :
Génération de PDF : Si votre application doit générer plusieurs PDFs à partir de contenu dynamique, exécuter ces processus de manière asynchrone permet au système de rester réactif pendant la création des PDFs.
Manipulation de PDF : Si vous avez besoin de modifier de gros PDF, tels que l'ajout de filigranes ou la fusion de 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.
Entrée/Sortie de fichier : La lecture et l'écriture de PDF sont des opérations liées à l'entrée/sortie. La programmation asynchrone est parfaite pour ces tâches, car elle libère les ressources système et évite les blocages inutiles.
Exemple de base : Génération PDF asynchrone avec IronPDF
Voici un exemple d'écriture de 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
Comment cela fonctionne
Création du convertisseur HTML en PDF :
La classe ChromePdfRenderer est utilisée pour convertir du contenu HTML en PDF. Dans cet exemple, nous passons un contenu HTML simple sous forme de chaîne ("
Exemple de PDF Asynchrone
"), mais dans une application réelle, cela pourrait être un HTML dynamique, tel qu'un modèle de rapport.
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éléguer la génération de PDF à un thread en arrière-plan. C'est important car la génération de PDF peut être gourmande en ressources et prendre du temps, notamment lorsqu'il s'agit de documents volumineux ou complexes.
Enregistrement 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'entrée/sortie est également encapsulée dans un Task.Run() pour s'assurer qu'elle ne bloque pas le thread principal lors de l'enregistrement du fichier.
Opérations en attente :
Le mot-clé await garantit que chaque opération asynchrone est terminée avant que la suivante ne commence. En attendant que la génération du PDF se termine, le thread principal reste libre de gérer d'autres tâches (par exemple, traiter d'autres requêtes HTTP dans une application web).
Gestion de plusieurs tâches avec IronPDF
Pour les applications traitant de grands fichiers PDF, vous devrez peut-être effectuer plusieurs opérations, comme diviser, fusionner ou ajouter du contenu à ces fichiers volumineux. L'utilisation de l'async garantit que pendant qu'une opération est en cours de traitement, l'application reste réactive aux entrées ou demandes des utilisateurs.
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
Dans cet exemple, nous chargeons un fichier PDF et en créons un nouveau, ajoutons un filigrane, fusionnons les deux PDF ensemble et l'enregistrons, tout cela sans bloquer le thread principal.
Meilleures pratiques pour les opérations asynchrones avec IronPDF
Considérations sur le Pool de Threads : Étant donné qu'IronPDF repose sur des threads en arrière-plan pour le traitement, faites attention au pool de threads lorsque vous utilisez Task.Run(). Pour les tâches à haute fréquence, envisagez d'utiliser un service d'arrière-plan dédié ou de mettre en file d'attente les tâches afin d'éviter de surcharger le pool de threads.
Éviter 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 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 erreurs pour les exceptions qui peuvent survenir pendant le traitement PDF, telles que des 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 PDF polyvalente et puissante qui fonctionne exceptionnellement bien avec le modèle async/await de C#. En exploitant la programmation asynchrone avec IronPDF, vous pouvez améliorer considérablement la performance et l'évolutivité de vos applications .NET qui traitent de la génération et de la manipulation de PDF. Que vous génériez des rapports dynamiques, extrayiez des données de documents ou modifiiez des PDF, 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 vous donne 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 serez en mesure de créer des applications plus rapides et plus efficaces qui s'adaptent mieux aux charges de travail croissantes.
Chaknith travaille sur IronXL et IronBarcode. Il possède une expertise approfondie en C# et .NET, aidant à améliorer le logiciel et à soutenir les clients. Ses idées issues des interactions avec les utilisateurs contribuent à de meilleurs produits, une documentation améliorée et une expérience globale enrichie.
< PRÉCÉDENT Événements C# (Comment cela fonctionne pour les développeurs)
SUIVANT > Format TimeSpan en C# (Comment cela fonctionne pour les développeurs)
Des millions d'ingénieurs dans le monde entier lui font confiance
Réservez une démo en direct gratuite
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
Voici ce à quoi vous pouvez vous attendre :
Une démonstration en direct de notre produit et de ses principales fonctionnalités
Obtenez des recommandations de fonctionnalités spécifiques au projet
Toutes vos questions trouvent réponse pour vous assurer de disposer de toutes les informations dont vous avez besoin. (Aucun engagement de votre part.)
CHOISIR L'HEURE
VOS INFORMATIONS
Réservez votre démo en direct gratuite
Fiable par plus de 2 millions d'ingénieurs dans le monde entier