Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. BackgroundWorker em C#
AJUDA DO .NET

BackgroundWorker em C# (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

Gerar PDFs com o IronPDF é uma tarefa comum para desenvolvedores .NET , especialmente na criação de relatórios dinâmicos, faturas ou sistemas de automação de documentos. Mas se você já gerou um PDF na thread principal da interface do usuário em um aplicativo Windows Forms ou WPF, provavelmente já viu a interface congelar ou parar de responder. Isso é especialmente comum ao renderizar conteúdo HTML extenso ou processar layouts de PDF complexos.

É aí que entra a classe BackgroundWorker do C#. Este artigo explica como integrar o IronPDF com o BackgroundWorker para lidar com operações assíncronas em um aplicativo de desktop sem bloquear a interface do usuário.

Por que usar BackgroundWorker com IronPDF?

Mantenha sua interface de usuário responsiva.

Ao executar tarefas que exigem muito da CPU ou que demandam muitas operações de E/S, como a geração de PDFs, na thread principal, a interface do usuário trava. Os usuários não podem clicar, arrastar ou interagir com o aplicativo enquanto ele estiver em uso. Ao usar um objeto BackgroundWorker, você pode mover o trabalho para uma thread separada, mantendo sua interface ágil e utilizável durante o processamento em segundo plano.

Ideal para geração de relatórios e tarefas de longa duração.

Se o seu aplicativo envolve exportação de dados, conversão de HTML para PDF ou renderização de relatórios detalhados, delegar essas tarefas a um processo em segundo plano torna seu aplicativo mais profissional e eficiente.

Compatível com aplicativos WinForms legados

Embora os aplicativos modernos frequentemente usem async/await, muitos projetos mais antigos ainda se beneficiam do BackgroundWorker devido à sua simplicidade e suporte em tempo de design no Visual Studio.

O que é o IronPDF?

C# BackgroundWorker (Como funciona para desenvolvedores): Figura 1 - IronPDF

IronPDF é uma poderosa biblioteca .NET projetada para gerar, editar e trabalhar com documentos PDF em C#. Ele utiliza um navegador Chromium sem interface gráfica, permitindo que os desenvolvedores convertam HTML, CSS, JavaScript e até mesmo páginas da web complexas em PDFs precisos e com qualidade de impressão. Diferentemente dos geradores de PDF tradicionais, o IronPDF renderiza documentos exatamente como eles apareceriam em um navegador — combinando layout, fontes, imagens e estilos pixel por pixel.

Principais características

  • Conversão de HTML para PDF – Converta strings HTML, URLs ou páginas web completas em PDFs.
  • Renderização de imagens e texto – Adicione cabeçalhos, rodapés, marcas d'água e imagens programaticamente.
  • Fusão e divisão de PDFs – Combine vários documentos ou extraia páginas específicas.
  • Preenchimento de formulários e anotações – Trabalhe com formulários PDF interativos.
  • Sem dependências externas – Funciona sem a necessidade de instalar o Adobe Acrobat ou o Microsoft Office.

O IronPDF é compatível com .NET Framework, .NET Core e .NET 6/7+, sendo ideal tanto para aplicações .NET para desktop quanto para aplicações web.

Instalando o IronPDF via NuGet

Para começar, instale o IronPDF em seu projeto usando o Gerenciador de Pacotes NuGet :

Install-Package IronPdf

Isso adicionará todas as referências necessárias para que você possa começar a usar o ChromePdfRenderer, o HtmlToPdf e outros recursos avançados do IronPDF.

Neste exemplo, usaremos um aplicativo Windows Forms criado com o Visual Studio, com um botão que inicia a geração de PDF e um rótulo para indicar quando o processo estiver concluído.

Implementando BackgroundWorker para IronPDF

Agora, usaremos os seguintes exemplos de código para detalhar o processo de utilização do BackgroundWorker de forma estruturada e segura:

Etapa 1 – Defina o BackgroundWorker

Você pode criar e configurar um BackgroundWorker tanto no designer quanto no código. Eis a abordagem em código:

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

Isso inicializa o processo de trabalho e configura os eventos necessários para a execução e conclusão em segundo plano.

Etapa 2 – Lidar com o evento DoWork

O método DoWork é executado em uma thread diferente, realizando a operação em segundo plano (geração do 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
$vbLabelText   $csharpLabel

Observação: você não pode interagir com os controles da interface do usuário aqui, pois o processo é executado em uma thread de trabalho .

Etapa 3 – Use RunWorkerCompleted para notificar a conclusão

Assim que a thread em segundo plano for concluída, você poderá atualizar a interface do usuário com os resultados sem problemas.

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

Etapa 4 – Acionando o BackgroundWorker a partir da interface do usuário

Adicione um botão Iniciar para executar a tarefa em segundo plano ao ser clicado:

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

Exemplo de código completo

Aqui está tudo reunido em um único trecho de código funcional do 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();
            }
        }
    }
}
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

Saída do formulário

C# BackgroundWorker (Como funciona para desenvolvedores): Figura 2 - Saída do formulário após a criação do PDF

Saída em PDF

C# BackgroundWorker (Como funciona para desenvolvedores): Figura 3 - Saída em PDF

Melhores práticas

Evite o acesso à interface do usuário no DoWork.

O manipulador de eventos DoWork é executado em uma thread diferente, portanto você não pode acessar elementos da interface do usuário diretamente. Use RunWorkerCompleted ou controle as chamadas Invoke() para atualizações seguras da interface do usuário.

Suporte ao cancelamento assíncrono

Se a sua tarefa for longa, habilite WorkerSupportsCancellation = true e monitore CancellationPending dentro do DoWork para dar suporte ao cancelamento solicitado.

Usar o recurso de atualizações de progresso do relatório (opcional)

Você pode habilitar WorkerReportsProgress = true e usar o evento ProgressChanged para exibir uma barra de progresso ou mensagens.

Validar o argumento de entrada

Ao usar RunWorkerAsync(argumento), valide o argumento em DoWork e retorne quaisquer resultados do método através de e.Result.

Conclusão

Utilizar o BackgroundWorker com o IronPDF permite executar tarefas complexas de renderização de PDF em uma thread em segundo plano, mantendo a responsividade da sua aplicação. Isso é especialmente valioso ao trabalhar com aplicativos WinForms ou WPF que exigem atualizações de interface do usuário responsivas durante tarefas de longa duração, como a geração de PDFs.

Ao lidar com o manipulador de eventos dowork, monitorar o resultado final e atualizar com segurança a interface do usuário no evento runworkercompleted, você garante que suas operações em segundo plano sejam executadas sem problemas.

Embora async/await seja frequentemente a escolha preferida para novas aplicações, BackgroundWorker continua sendo uma ferramenta confiável para projetos legados ou WinForms. Quer esteja a exportar relatórios ou a gerar documentos instantaneamente, esta abordagem ajudá-lo-á a tirar o máximo partido do IronPDF , mantendo a sua aplicação fluida e intuitiva.

Pronto para experimentar você mesmo?

Baixe a versão de avaliação gratuita do IronPDF e comece a criar soluções poderosas em PDF usando C# hoje mesmo. O período de teste oferece acesso completo aos recursos apresentados neste artigo — sem necessidade de cartão de crédito.

Perguntas frequentes

Como posso gerar um PDF em uma aplicação Windows Forms em C# sem congelar a interface do usuário?

Você pode utilizar a classe BackgroundWorker do C# em conjunto com o IronPDF para gerar PDFs em uma thread separada. Isso garante que a thread principal da interface do usuário permaneça responsiva durante o processo.

Qual é a função do manipulador de eventos DoWork no BackgroundWorker?

O manipulador de eventos DoWork é onde você executa tarefas de longa duração, como a geração de PDFs usando o IronPDF. Ele é executado em uma thread separada da interface do usuário, evitando que a interface trave.

Como posso atualizar a interface do usuário com os resultados de uma tarefa de geração de PDF em segundo plano?

Use o evento RunWorkerCompleted para atualizar a interface do usuário com os resultados da geração do PDF. Esse evento é acionado assim que a tarefa em segundo plano é concluída, permitindo a interação segura com os elementos da interface.

Quais são os benefícios de usar o BackgroundWorker para processamento de PDF em aplicações .NET mais antigas?

O BackgroundWorker oferece uma maneira direta de implementar operações assíncronas em aplicativos WinForms legados, fornecendo um modelo simples para lidar com tarefas como processamento de PDF com IronPDF, mantendo a interface do usuário responsiva.

Posso cancelar uma tarefa de geração de PDF usando BackgroundWorker?

Sim, o BackgroundWorker suporta o cancelamento de tarefas. Você pode implementar o cancelamento verificando a propriedade CancellationPending no seu manipulador de eventos DoWork e encerrando a tarefa de forma controlada.

Como posso acompanhar o progresso da geração de PDF usando BackgroundWorker?

Você pode relatar o progresso do método DoWork usando o método ReportProgress do BackgroundWorker. Isso permite atualizar a interface do usuário com informações de progresso durante a geração do PDF.

Por que as atualizações da interface do usuário devem ser evitadas no manipulador de eventos DoWork?

As atualizações da interface do usuário devem ser evitadas no manipulador de eventos DoWork, pois ele é executado em uma thread separada. A manipulação direta da interface do usuário pode causar problemas de multithreading. Em vez disso, use os eventos RunWorkerCompleted ou ProgressChanged para atualizações da interface do usuário.

Quais são os passos envolvidos na configuração de um BackgroundWorker para geração de PDF em C#?

A configuração de um BackgroundWorker envolve a inicialização do worker, o tratamento dos eventos DoWork e RunWorkerCompleted e o início da tarefa usando RunWorkerAsync . Essa configuração é usada para executar tarefas como a geração de PDFs com o IronPDF.

É necessário usar padrões modernos de async/await para geração de PDFs em aplicações .NET?

Embora os padrões modernos de async/await sejam recomendados para novas aplicações, o BackgroundWorker continua sendo útil em aplicações WinForms mais antigas para lidar com tarefas assíncronas, como a geração de PDFs com o IronPDF, devido à sua simplicidade e facilidade de uso.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim