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

Gardez votre interface utilisateur réactive

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.

Parfait pour la génération de rapports et les tâches de longue durée

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.

Compatible avec les applications WinForms héritées

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.

Installation d'IronPDF via NuGet

Pour commencer, installez IronPDF dans votre projet à l'aide du gestionnaire de packages NuGet :

Install-Package IronPdf

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é.

Étape 1 – Définir le BackgroundWorker

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 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 Sub

Cela initialise le travailleur et connecte les événements nécessaires pour l'exécution et l'achèvement en arrière-plan.

Étape 2 – Gérer l'événement DoWork

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 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 Sub

Remarque : Vous ne pouvez pas interagir avec les contrôles de l'interface utilisateur ici car cela s'exécute sur un thread de travail.

Étape 3 – Utiliser RunWorkerCompleted pour notifier l'achèvement

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

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 Sub

Étape 4 – Déclencher BackgroundWorker depuis l'interface utilisateur

Ajoutez 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 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 Sub

Éviter l'accès à l'interface utilisateur dans DoWork

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.

Soutien pour l'annulation asynchrone

Si votre tâche est longue, activez WorkerSupportsCancellation = true et surveillez CancellationPending à l'intérieur de DoWork pour soutenir l'annulation demandée.

Utiliser les mises à jour de progression du rapport (facultatif)

Vous pouvez activer WorkerReportsProgress = true et utiliser l'événement ProgressChanged pour afficher une barre de progression ou des messages.

Valider l'argument d'entrée

Lors de l'utilisation de RunWorkerAsync(argument), validez l'argument dans DoWork et retournez les résultats de toute méthode via e.Result.