La génération de PDF avec IronPDF est une tâche courante pour les développeurs .NET—surtout lors de la création de rapports dynamiques, de factures ou de systèmes d'automatisation de documents. Mais si vous avez déjà déclenché la génération de PDF sur le thread principal de l'interface utilisateur dans une application Windows Forms ou WPF, vous avez probablement vu votre interface utilisateur se figer ou devenir non réactive. C'est particulièrement vrai lors du rendu de contenu HTML volumineux ou du traitement de mises en page PDF complexes.
C'est là que la classe C# BackgroundWorker intervient. Cet article explique comment intégrer IronPDF avec BackgroundWorker pour gérer les opérations asynchrones dans une application de bureau sans verrouiller l'interface utilisateur.
Lorsque vous exécutez des tâches gourmandes en CPU ou liées aux entrées/sorties comme la génération de PDF sur le thread principal, cela verrouille l'interface utilisateur. Les utilisateurs ne peuvent pas cliquer, faire glisser ou interagir avec l'application pendant qu'elle est occupée. En utilisant un objet BackgroundWorker, vous pouvez déplacer le travail vers un thread séparé, gardant votre interface rapide et utilisable pendant le traitement en arrière-plan.
Si votre application implique l'exportation de données, la conversion de HTML en PDF ou le rendu de rapports détaillés—déléguer cela à un travailleur en arrière-plan rend votre application plus professionnelle et performante.
Bien que les applications modernes utilisent souvent async/await, de nombreux anciens projets bénéficient encore de BackgroundWorker pour sa simplicité et son support de conception dans Visual Studio.
IronPDF est une puissante bibliothèque .NET conçue pour générer, modifier et travailler avec des documents PDF en C#. Cela utilise un navigateur Chromium sans tête sous le capot, permettant aux développeurs de convertir du HTML, du CSS, du JavaScript, et même des pages web complexes en PDF de qualité d'impression précise. Contrairement aux générateurs de PDF traditionnels, IronPDF rend les documents exactement comme ils apparaîtraient dans un navigateur—en respectant la mise en page, les polices, les images et les styles pixel par pixel.
Caractéristiques clés
IronPDF prend en charge .NET Framework, .NET Core, et .NET 6/7+, ce qui le rend idéal pour les applications .NET à la fois de bureau et basées sur le web.
Pour commencer, installez IronPDF dans votre projet à l'aide du gestionnaire de packages NuGet :
Cela ajoutera toutes les références nécessaires pour que vous puissiez commencer à utiliser les fonctionnalités puissantes de ChromePdfRenderer, HtmlToPdf, et autres d'IronPDF.
Pour cet exemple, nous utiliserons une application Windows Forms créée avec Visual Studio, avec un bouton qui déclenche la génération du PDF et une étiquette pour indiquer quand le processus est terminé.
Maintenant, nous utiliserons les exemples de code suivants pour décomposer le processus d'utilisation de BackgroundWorker de manière structurée et sûre :
Vous pouvez créer et configurer un BackgroundWorker soit dans le concepteur, soit dans le code. Voici l'approche par code :
private void SetupBackgroundWorker()
{
// new backgroundworker worker instance
worker = new BackgroundWorker(); // dowork event handler
worker.DoWork += PdfWorker_DoWork;
worker.RunWorkerCompleted += PdfWorker_RunWorkerCompleted; // final result handler
}Private Sub SetupBackgroundWorker()
' new backgroundworker worker instance
worker = New BackgroundWorker() ' dowork event handler
worker.DoWork += PdfWorker_DoWork
worker.RunWorkerCompleted += PdfWorker_RunWorkerCompleted ' final result handler
End SubCela initialise le travailleur et connecte les événements nécessaires pour l'exécution et l'achèvement en arrière-plan.
La méthode DoWork s'exécute sur un thread différent, effectuant l'opération en arrière-plan (générant le PDF) :
private void PdfWorker_DoWork(object sender, DoWorkEventArgs e)
{
var Renderer = new ChromePdfRenderer();
// Simulate input from UI or parameters
string htmlContent = "<h1>Monthly Report</h1><p>Generated with IronPDF.</p>";
string outputPath = Path.Combine(Environment.CurrentDirectory, "Report.pdf");
// Generate PDF
var pdf = Renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(outputPath);
// Optionally pass result info
e.Result = outputPath; // pass value to RunWorkerCompleted
}Private Sub PdfWorker_DoWork(ByVal sender As Object, ByVal e As DoWorkEventArgs)
Dim Renderer = New ChromePdfRenderer()
' Simulate input from UI or parameters
Dim htmlContent As String = "<h1>Monthly Report</h1><p>Generated with IronPDF.</p>"
Dim outputPath As String = Path.Combine(Environment.CurrentDirectory, "Report.pdf")
' Generate PDF
Dim pdf = Renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs(outputPath)
' Optionally pass result info
e.Result = outputPath ' pass value to RunWorkerCompleted
End SubRemarque : Vous ne pouvez pas interagir avec les contrôles de l'interface utilisateur ici car cela s'exécute sur un thread de travail.
Une fois le thread en arrière-plan terminé, vous pouvez mettre à jour l'interface utilisateur en toute sécurité avec les résultats.
private void PdfWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Error != null)
{
MessageBox.Show("Error: " + e.Error.Message);
}
else
{
string savedPath = e.Result.ToString();
MessageBox.Show("PDF created at:\n" + savedPath);
}
}Imports Microsoft.VisualBasic
Private Sub PdfWorker_RunWorkerCompleted(ByVal sender As Object, ByVal e As RunWorkerCompletedEventArgs)
If e.Error IsNot Nothing Then
MessageBox.Show("Error: " & e.Error.Message)
Else
Dim savedPath As String = e.Result.ToString()
MessageBox.Show("PDF created at:" & vbLf & savedPath)
End If
End SubAjoutez un bouton Démarrer pour exécuter la tâche en arrière-plan lorsqu'il est cliqué :
private void btnGeneratePDF_Click(object sender, EventArgs e)
{
if (pdfWorker == null)
SetupBackgroundWorker();
if (!pdfWorker.IsBusy)
{
btnGeneratePDF.Enabled = false;
pdfWorker.RunWorkerAsync(); // execute method in background
}
}Private Sub btnGeneratePDF_Click(ByVal sender As Object, ByVal e As EventArgs)
If pdfWorker Is Nothing Then
SetupBackgroundWorker()
End If
If Not pdfWorker.IsBusy Then
btnGeneratePDF.Enabled = False
pdfWorker.RunWorkerAsync() ' execute method in background
End If
End SubVoici tout réuni dans un seul extrait fonctionnel Windows Forms :
using System;
using System.ComponentModel;
using IronPdf;
using System.IO;
using System.Windows.Forms;
namespace TestApp
{
public partial class Form1 : Form
{
private BackgroundWorker worker;
public Form1()
{
InitializeComponent();
SetupBackgroundWorker(); }
private void SetupBackgroundWorker()
{
worker = new BackgroundWorker();
worker.DoWork += PdfWorker_DoWork;
worker.RunWorkerCompleted += PdfWorker_RunWorkerCompleted;
}
private void btnGeneratePDF_Click(object sender, EventArgs e)
{
if (!worker.IsBusy)
{
btnGeneratePDF.Enabled = false;
worker.RunWorkerAsync();
}
}
private void PdfWorker_DoWork(object sender, DoWorkEventArgs e)
{
var Renderer = new ChromePdfRenderer();
string htmlContent = "<h1>Report</h1><p>This PDF was generated in the background.</p>";
string outputPath = Path.Combine(Environment.CurrentDirectory, "Report.pdf");
var pdf = Renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(outputPath);
e.Result = outputPath;
}
private void PdfWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
btnGeneratePDF.Enabled = true;
if (e.Error != null)
{
MessageBox.Show("Failed: " + e.Error.Message);
}
else
{
MessageBox.Show("PDF created: " + e.Result.ToString());
}
}
private void btnGeneratePDF_Click_1(object sender, EventArgs e)
{
if (!worker.IsBusy)
{
btnGeneratePDF.Enabled = false;
worker.RunWorkerAsync();
}
}
}
}Imports System
Imports System.ComponentModel
Imports IronPdf
Imports System.IO
Imports System.Windows.Forms
Namespace TestApp
Partial Public Class Form1
Inherits Form
Private worker As BackgroundWorker
Public Sub New()
InitializeComponent()
SetupBackgroundWorker()
End Sub
Private Sub SetupBackgroundWorker()
worker = New BackgroundWorker()
AddHandler worker.DoWork, AddressOf PdfWorker_DoWork
AddHandler worker.RunWorkerCompleted, AddressOf PdfWorker_RunWorkerCompleted
End Sub
Private Sub btnGeneratePDF_Click(ByVal sender As Object, ByVal e As EventArgs)
If Not worker.IsBusy Then
btnGeneratePDF.Enabled = False
worker.RunWorkerAsync()
End If
End Sub
Private Sub PdfWorker_DoWork(ByVal sender As Object, ByVal e As DoWorkEventArgs)
Dim Renderer = New ChromePdfRenderer()
Dim htmlContent As String = "<h1>Report</h1><p>This PDF was generated in the background.</p>"
Dim outputPath As String = Path.Combine(Environment.CurrentDirectory, "Report.pdf")
Dim pdf = Renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs(outputPath)
e.Result = outputPath
End Sub
Private Sub PdfWorker_RunWorkerCompleted(ByVal sender As Object, ByVal e As RunWorkerCompletedEventArgs)
btnGeneratePDF.Enabled = True
If e.Error IsNot Nothing Then
MessageBox.Show("Failed: " & e.Error.Message)
Else
MessageBox.Show("PDF created: " & e.Result.ToString())
End If
End Sub
Private Sub btnGeneratePDF_Click_1(ByVal sender As Object, ByVal e As EventArgs)
If Not worker.IsBusy Then
btnGeneratePDF.Enabled = False
worker.RunWorkerAsync()
End If
End Sub
End Class
End NamespaceSortie du formulaire
Sortie PDF
Le gestionnaire d'événements DoWork s'exécute sur un thread différent, vous ne pouvez donc pas accéder directement aux éléments de l'interface utilisateur. Utilisez RunWorkerCompleted ou des appels Invoke() de contrôle pour des mises à jour sécurisées de l'interface utilisateur.
Si votre tâche est longue, activez WorkerSupportsCancellation = true et surveillez CancellationPending à l'intérieur de DoWork pour soutenir l'annulation demandée.
Vous pouvez activer WorkerReportsProgress = true et utiliser l'événement ProgressChanged pour afficher une barre de progression ou des messages.
Lors de l'utilisation de RunWorkerAsync(argument), validez l'argument dans DoWork et retournez les résultats de toute méthode via e.Result.
Utiliser BackgroundWorker avec IronPDF vous permet d'effectuer des tâches de rendu PDF lourdes sur un thread en arrière-plan, gardant votre application réactive. Cela est particulièrement précieux lorsque vous travaillez avec des applications WinForms ou WPF qui nécessitent des mises à jour réactives de l'interface utilisateur pendant des tâches de longue durée comme la génération de PDF.
En manipulant le gestionnaire d'événements dowork, en surveillant le résultat final, et en mettant à jour votre interface utilisateur en toute sécurité dans l'événement runworkercompleted, vous assurez que vos opérations en arrière-plan fonctionnent sans accroc.
Bien que async/await soit souvent le choix standard pour les nouvelles applications, BackgroundWorker reste un outil fiable pour les projets hérités ou WinForms. Que vous exportiez des rapports ou génériez des documents à la volée, cette approche vous aidera à tirer le meilleur parti d'IronPDF tout en gardant votre application fluide et conviviale.
Prêt à essayer par vous-même ?
Téléchargez l'essai gratuit d'IronPDF et commencez à créer des solutions PDF puissantes en C# dès aujourd'hui. L'essai vous donne un accès complet aux fonctionnalités présentées dans cet article—sans carte de crédit requise.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
