Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# BackgroundWorker Anleitung
.NET HILFE

C# BackgroundWorker (Wie es für Entwickler funktioniert)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Erstellen von PDFs mit IronPDF ist eine gängige Aufgabe für .NET-Entwickler – besonders beim Erstellen dynamischer Berichte, Rechnungen oder Dokumentenautomatisierungssysteme. Wenn Sie jedoch jemals die PDF-Erstellung im Haupt-UI-Thread in einer Windows Forms- oder WPF-App ausgelöst haben, haben Sie wahrscheinlich bemerkt, dass Ihre Benutzeroberfläche einfriert oder nicht mehr reagiert. Dies gilt insbesondere, wenn große HTML-Inhalte gerendert oder komplexe PDF-Layouts verarbeitet werden.

Hier kommt die C# BackgroundWorker-Klasse ins Spiel. Dieser Artikel zeigt, wie IronPDF mit BackgroundWorker integriert wird, um asynchrone Operationen in einer Desktop-App zu behandeln, ohne die Benutzeroberfläche zu blockieren.

Warum BackgroundWorker mit IronPDF verwenden?

Halten Sie Ihre Benutzeroberfläche responsiv

Wenn Sie CPU-intensive oder IO-gebundene Aufgaben wie die PDF-Erstellung im Hauptthread ausführen, blockiert dies die Benutzeroberfläche. Benutzer können nicht klicken, ziehen oder mit der Anwendung interagieren, während sie beschäftigt ist. Durch die Verwendung eines BackgroundWorker-Objekts können Sie die Arbeit in einen separaten Thread verlagern und Ihre Benutzeroberfläche während der Hintergrundverarbeitung reaktionsschnell und benutzbar halten.

Perfekt für die Berichterstellung und langwierige Aufgaben

Wenn Ihre App das Exportieren von Daten, die Umwandlung von HTML in PDF oder das Erstellen detaillierter Berichte umfasst, verbessert das Auslagern an einen Hintergrundarbeiter die Professionalität und Leistung Ihrer Anwendung.

Kompatibel mit älteren WinForms-Anwendungen

Obwohl moderne Apps oft async/await verwenden, profitieren viele ältere Projekte immer noch von BackgroundWorker aufgrund seiner Einfachheit und Designzeitunterstützung in Visual Studio.

Was ist IronPDF?

C# BackgroundWorker (Wie es für Entwickler funktioniert): Abbildung 1 - IronPDF

IronPDF ist eine leistungsstarke .NET-Bibliothek zum Erstellen, Bearbeiten und Arbeiten mit PDF-Dokumenten in C#. Es verwendet einen headless Chromium-Browser im Hintergrund, der es Entwicklern erlaubt, HTML, CSS, JavaScript und sogar komplexe Webseiten in genaue, druckqualitative PDFs umzuwandeln. Im Gegensatz zu herkömmlichen PDF-Generatoren rendert IronPDF Dokumente genau so, wie sie in einem Browser erscheinen würden – mit exakt gleichen Layouts, Schriftarten, Bildern und Stilen.

Hauptfunktionen

  • HTML-zu-PDF-Konvertierung – Rendern von HTML-Strings, URLs oder vollständigen Webseiten zu PDFs.
  • Bild- und Textrendering – Hinzufügen von Kopf- und Fußzeilen, Wasserzeichen und Bildern programmatisch.
  • Zusammenführen und Teilen von PDFs – Kombinieren mehrerer Dokumente oder Extrahieren bestimmter Seiten.
  • Formularausfüllung und Annotationen – Arbeiten mit interaktiven PDF-Formularen.
  • Keine externen Abhängigkeiten – Funktioniert ohne Installationen von Adobe Acrobat oder Microsoft Office.

IronPDF unterstützt das .NET Framework, .NET Core und .NET 6/7+, wodurch es ideal für sowohl Desktop- als auch webbasierte .NET-Anwendungen ist.

Installation von IronPDF über NuGet

Um zu beginnen, installieren Sie IronPDF in Ihrem Projekt mit dem NuGet-Paket-Manager:

Install-Package IronPdf

Dies fügt alle notwendigen Referenzen hinzu, sodass Sie mit der Verwendung von IronPDFs ChromePdfRenderer, HtmlToPdf und anderen leistungsstarken Funktionen beginnen können.

In diesem Beispiel verwenden wir eine mit Visual Studio erstellte Windows Forms-Anwendung mit einem Button, der die PDF-Erstellung auslöst, und einem Label, das anzeigt, wann der Vorgang abgeschlossen ist.

Implementierung von BackgroundWorker für IronPDF

Nun werden wir anhand der folgenden Codebeispiele den Prozess der Verwendung von BackgroundWorker in einer strukturierten und sicheren Weise aufschlüsseln:

Schritt 1 - Definieren Sie den BackgroundWorker

Sie können einen BackgroundWorker entweder im Designer oder im Code erstellen und konfigurieren. Hier ist die Code-Methode:

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
$vbLabelText   $csharpLabel

Dies initialisiert den Worker und verdrahtet die notwendigen Ereignisse für die Hintergrundausführung und den Abschluss.

Schritt 2 - Das DoWork-Ereignis behandeln

Die DoWork-Methode läuft in einem anderen Thread und führt die Hintergrundoperation (Erstellen des PDFs) aus:

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
$vbLabelText   $csharpLabel

Hinweis: Sie können hier nicht mit UI-Steuerelementen interagieren, da es auf einem Worker-Thread läuft.

Schritt 3 - RunWorkerCompleted verwenden, um die Fertigstellung zu melden

Sobald der Hintergrund-Thread abgeschlossen ist, können Sie die Benutzeroberfläche sicher mit den Ergebnissen aktualisieren.

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
$vbLabelText   $csharpLabel

Schritt 4 - Auslösen von BackgroundWorker aus der Benutzeroberfläche

Fügen Sie eine Start-Schaltfläche hinzu, um die Hintergrundaufgabe bei Klick auszuführen:

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
$vbLabelText   $csharpLabel

Vollständiges Codebeispiel

Hier wird alles in einem funktionierenden Windows Forms-Beispiel zusammengefasst:

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();
            }
        }
    }
}
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 Namespace
$vbLabelText   $csharpLabel

Formularausgabe

C# BackgroundWorker (Wie es für Entwickler funktioniert): Abbildung 2 - Formularausgabe nach PDF-Erstellung

PDF-Ausgabe

C# BackgroundWorker (Wie es für Entwickler funktioniert): Abbildung 3 - PDF-Ausgabe

Bewährte Verfahren

Umgehen Sie den UI-Zugriff in DoWork

Der DoWork-Ereignishandler läuft in einem anderen Thread, sodass Sie nicht direkt auf UI-Elemente zugreifen können. Verwenden Sie RunWorkerCompleted oder steuern Sie Invoke()-Aufrufe für sichere UI-Updates.

Unterstützung asynchroner Abbrüche

Wenn Ihre Aufgabe lang ist, aktivieren Sie WorkerSupportsCancellation = true und überwachen im DoWork-Abbruchsvorgang die CancellationPending, um eine angeforderte Abbruch zu unterstützen.

Verwendung von Fortschrittsberichten (optional)

Sie können WorkerReportsProgress = true aktivieren und das ProgressChanged-Ereignis verwenden, um eine Fortschrittsanzeige oder Nachrichten anzuzeigen.

Eingabeargument validieren

Wenn Sie RunWorkerAsync(argument) verwenden, validieren Sie das Argument im DoWork und geben Sie die Ergebnisse der Methode über e.Result zurück.

Abschluss

Die Verwendung von BackgroundWorker mit IronPDF ermöglicht es Ihnen, umfangreiche PDF-Rendering-Aufgaben auf einem Hintergrund-Thread auszuführen und so Ihre Anwendung reaktionsfähig zu halten. Dies ist besonders wertvoll, wenn Sie mit WinForms- oder WPF-Apps arbeiten, die reaktionsfähige UI-Updates während lang laufender Aufgaben wie der PDF-Erstellung erfordern.

Indem Sie den dowork-Ereignishandler behandeln, das Endergebnis überwachen und die Benutzeroberfläche sicher im runworkercompleted-Ereignis aktualisieren, stellen Sie sicher, dass Ihre Hintergrundoperationen reibungslos laufen.

Während async/await oft die erste Wahl für neue Anwendungen ist, bleibt BackgroundWorker ein zuverlässiges Werkzeug für Legacy- oder WinForms-Projekte. Egal, ob Sie Berichte exportieren oder Dokumente schnell erstellen – dieser Ansatz hilft Ihnen, das Beste aus IronPDF herauszuholen, während Sie Ihre App reibungslos und benutzerfreundlich halten.

Bereit, es selbst auszuprobieren?

Laden Sie die kostenlose IronPDF-Testversion herunter und beginnen Sie noch heute, leistungsstarke PDF-Lösungen in C# zu erstellen. Die Testversion bietet Ihnen vollständigen Zugriff auf die in diesem Artikel gezeigten Funktionen – keine Kreditkarte erforderlich.

Häufig gestellte Fragen

Wie kann ich die PDF-Erstellung in einer C# Windows Forms-Anwendung ausführen, ohne die Benutzeroberfläche einzufrieren?

Sie können die C# BackgroundWorker-Klasse in Verbindung mit IronPDF nutzen, um die PDF-Erstellung in einem separaten Thread durchzuführen. Dies stellt sicher, dass der Haupt-UI-Thread während des Prozesses reaktionsfähig bleibt.

Welche Rolle spielt der DoWork-Ereignishandler im BackgroundWorker?

Der DoWork-Ereignishandler ist der Ort, an dem Sie die langwierige Aufgabe ausführen, wie z.B. die PDF-Erstellung mit IronPDF. Er läuft in einem separaten Thread von der Benutzeroberfläche und verhindert das Einfrieren der Oberfläche.

Wie kann ich die Benutzeroberfläche mit Ergebnissen einer Hintergrundaufgabe zur PDF-Erstellung aktualisieren?

Verwenden Sie das RunWorkerCompleted-Ereignis, um die Benutzeroberfläche mit den Ergebnissen Ihrer PDF-Erstellung zu aktualisieren. Dieses Ereignis wird ausgelöst, sobald die Hintergrundaufgabe abgeschlossen ist, und ermöglicht eine sichere Interaktion mit UI-Elementen.

Welche Vorteile bietet die Verwendung von BackgroundWorker für die PDF-Verarbeitung in älteren .NET-Anwendungen?

BackgroundWorker bietet eine einfache Möglichkeit, asynchrone Operationen in Legacy-WinForms-Anwendungen zu implementieren. Er stellt ein einfaches Modell zur Verfügung, um Aufgaben wie die PDF-Verarbeitung mit IronPDF zu handhaben und dabei die Benutzeroberfläche reaktionsfähig zu halten.

Kann ich eine PDF-Erstellungsaufgabe mit BackgroundWorker abbrechen?

Ja, BackgroundWorker unterstützt die Beendigung von Aufgaben. Sie können die Beendigung implementieren, indem Sie die CancellationPending-Eigenschaft in Ihrem DoWork-Ereignishandler überprüfen und die Aufgabe sanft beenden.

Wie kann ich den Fortschritt der PDF-Erstellung mit BackgroundWorker überwachen?

Sie können den Fortschritt von der DoWork-Methode aus mit der ReportProgress-Methode des BackgroundWorker melden. Dies ermöglicht es Ihnen, die Benutzeroberfläche während der PDF-Erstellung mit Fortschrittsinformationen zu aktualisieren.

Warum sollten UI-Updates im DoWork-Ereignishandler vermieden werden?

UI-Updates sollten im DoWork-Ereignishandler vermieden werden, da dieser in einem separaten Thread läuft. Direkte UI-Manipulation könnte zu Threading-Problemen führen. Verwenden Sie stattdessen die RunWorkerCompleted- oder ProgressChanged-Ereignisse für UI-Updates.

Welche Schritte sind erforderlich, um einen BackgroundWorker für die PDF-Erstellung in C# einzurichten?

Das Einrichten eines BackgroundWorker umfasst die Initialisierung des Workers, die Behandlung der DoWork- und RunWorkerCompleted-Ereignisse und den Start der Aufgabe mit RunWorkerAsync. Dieses Setup wird verwendet, um Aufgaben wie die PDF-Erstellung mit IronPDF auszuführen.

Ist es notwendig, moderne async/await-Muster für die PDF-Erstellung in .NET-Anwendungen zu verwenden?

Obwohl moderne async/await-Muster für neue Anwendungen empfohlen werden, bleibt BackgroundWorker in älteren WinForms-Anwendungen für die Handhabung asynchroner Aufgaben wie die PDF-Erstellung mit IronPDF aufgrund seiner Einfachheit und Benutzerfreundlichkeit nützlich.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen