Como posso converter HTML para PDF em C#?

Você pode usar o método RenderHtmlAsPdf do IronPDF para converter strings HTML em PDFs. Você também pode converter arquivos HTML em PDFs usando o RenderHtmlFileAsPdf .

Por que a programação orientada a eventos é importante em aplicações .NET?

A programação orientada a eventos é vital em aplicações .NET para melhorar a capacidade de resposta e garantir experiências de usuário fluidas, permitindo que tarefas sejam executadas de forma assíncrona sem bloquear a thread principal.

Como instalar a ferramenta necessária para geração de PDF em um projeto .NET?

Você pode instalar o IronPDF via NuGet executando o comando 'Install-Package IronPDF' no Console do Gerenciador de Pacotes do Visual Studio.

Como declarar um evento em C#?

Em C#, os eventos são declarados usando a palavra-chave 'event', geralmente com um tipo delegado como 'EventHandler'. Por exemplo: public event EventHandler PdfGenerated; .

O que é um delegate no tratamento de eventos em C#?

Em C#, um delegate é um ponteiro de função com tipagem estática que permite definir métodos que podem ser chamados em resposta a um evento.

Como adicionar métodos a eventos em C#?

Em C#, você pode adicionar métodos a eventos dinamicamente em tempo de execução usando a sintaxe '+=' para se inscrever em eventos.

Qual é a finalidade de criar uma classe EventArgs personalizada?

Uma classe EventArgs personalizada é usada para passar dados específicos do evento, como um caminho de arquivo, para os manipuladores de eventos de maneira estruturada e com segurança de tipos.

Por que usar um BackgroundWorker para gerar PDFs grandes?

Utilizar um BackgroundWorker permite executar tarefas de geração de PDF de forma assíncrona, evitando que a interface do usuário seja bloqueada e melhorando a experiência do usuário.

Quais são algumas dicas para trabalhar com eventos em .NET?

Algumas dicas importantes incluem evitar o bloqueio da thread da interface do usuário, atualizando-a somente após a conclusão das tarefas em segundo plano, tratar exceções de forma adequada e cancelar a inscrição em eventos quando não forem mais necessários para evitar vazamentos de memória.

Quais são as alternativas ao uso de manipuladores de eventos no .NET?

Alternativas incluem usar async/await e Task.Run para fluxos de trabalho mais novos e IProgress para atualizações em tempo real durante longas operações.

A biblioteca C# PDF

Explore IronPDF Comece seu teste gratuito

HTML para PDF

Online Demo Veja todos os exemplos de código %s

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

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

PM >Install-Package IronPdf

Install-Package IronPdf

ATUALIZAÇÕES DO DESENVOLVEDOR

Manipulador de eventos em C# (Como funciona para desenvolvedores)

Curtis Chau

Updated: 21 de abril de 2026

Em aplicações .NET modernas, a programação orientada a eventos desempenha um papel vital na melhoria da capacidade de resposta e na garantia de experiências de usuário fluidas. Quando tarefas como a geração de PDFs levam tempo, você não quer bloquear a thread principal. Em vez disso, você pode usar manipuladores de eventos para executar tarefas de forma assíncrona e reagir assim que um evento ocorrer, tornando seu aplicativo mais interativo e responsivo.

Neste guia, mostraremos como integrar métodos de tratamento de eventos em C# com o IronPDF para fluxos de trabalho de PDF perfeitos em ambientes desktop e web. Quer você utilize WinForms, WPF ou qualquer outra plataforma baseada na linguagem de programação C#, este guia tem tudo o que você precisa.

Configurando seu projeto IronPDF

Antes de abordarmos o tratamento de eventos, vamos configurar rapidamente o IronPDF em seu projeto .NET .

Instale o IronPDF via NuGet.

No console do Gerenciador de Pacotes do Visual Studio, execute:

PM > Install-Package IronPdf

Install-Package IronPdf

Isso instala tudo o que é necessário para começar a gerar PDFs usando o IronPDF.

Geração básica de PDF com IronPDF

Aqui está um exemplo rápido para garantir que o IronPDF esteja funcionando:

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Assim que isso estiver funcionando, você estará pronto para adicionar campos de evento, conectar delegados registrados e usar tipos de delegado para criar fluxos de trabalho orientados a eventos.

Fundamentos do Manipulador de Eventos em C# para Desenvolvedores .NET

Fundamentos da Programação Orientada a Eventos

Com a programação orientada a eventos, seu aplicativo responde quando um evento ocorre, como a conclusão da geração de um PDF. Em C#, os delegates são ponteiros de função com segurança de tipo, permitindo que você defina como seu aplicativo deve reagir.

Normalmente, você declara eventos usando a palavra-chave event, os conecta a métodos de tratamento de eventos e passa dados usando subclasses personalizadas de EventArgs.

Declare um evento com a palavra-chave `event`.

Em C#, utiliza-se a palavra-chave event para declarar membros de eventos. Por exemplo:

public event EventHandler PdfGenerated;

public event EventHandler PdfGenerated;

Public Event PdfGenerated As EventHandler

Public Event PdfGenerated As EventHandler

Esta linha declara um campo de evento chamado PdfGenerated. Ele usa o EventHandler, um delegado integrado com a seguinte lista de parâmetros: (object sender, EventArgs e) — frequentemente referido como o padrão de nomenclatura para eventos no .NET.

Definindo e Subscrevendo Eventos em C#

Adicionar métodos a eventos usando delegados

Em C#, os eventos permitem adicionar métodos dinamicamente em tempo de execução usando a sintaxe +=. Eis como:

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

Essa classe de assinante fica à escuta do evento PdfGenerated e executa uma chamada de método quando acionada.

Dados de evento personalizados

Para passar dados de eventos, como o caminho do arquivo gerado, defina uma classe derivada de EventArgs:

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Em seguida, redefina o evento usando um tipo de delegado genérico:

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

Isso fornece dados estruturados e com tipagem estática quando o evento é acionado, tornando sua lógica de resposta mais poderosa.

Gerenciando múltiplos eventos

Você pode definir vários eventos:

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Cada campo de evento é tratado por uma classe de assinante, permitindo métodos de tratamento de eventos distintos por estágio. Essa separação de responsabilidades faz sentido em fluxos de trabalho complexos.

Utilizando manipuladores de eventos com o IronPDF

Ao gerar PDFs grandes, faz sentido executar o IronPDF em uma thread em segundo plano e notificar a interface do usuário quando o processo for concluído. Eis como o design orientado a eventos pode ajudar:

Utilize um BackgroundWorker para gerar PDFs de forma assíncrona
Gere eventos quando cada etapa for concluída
Transmita dados de resultado usando objetos de dados de evento

Exemplo de código – Gerar PDFs de forma assíncrona

O exemplo a seguir é o código completo para usar o tratamento de eventos com o IronPDF:

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Saída do console

Manipulador de eventos em C# (Como funciona para desenvolvedores): Figura 1 - Saída do console

Saída em PDF

Manipulador de eventos em C# (Como funciona para desenvolvedores): Figura 2 - Saída em PDF

Principais características deste código

public event EventHandler<PdfGeneratedEventArgs>: Declara um evento fortemente tipado
PdfGeneratedEventArgs: Classe personalizada para dados do evento
BackgroundWorker: Permite execução assíncrona para evitar bloqueio de UI
?.Invoke(...): Invocação segura de eventos
Tuple<string, string>: Passa HTML e caminho de saída para o thread em segundo plano

Dicas para trabalhar com eventos em .NET

1. Evite o bloqueio da thread da interface do usuário

Utilize manipuladores de eventos como RunWorkerCompleted para executar atualizações da interface do usuário somente após a conclusão de tarefas em segundo plano.

2. Lidar com exceções de forma elegante

Envolva sua lógica de trabalho em blocos try-catch dentro de DoWork e passe as exceções para RunWorkerCompleted através de e.Error.

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

3. Cancelar a inscrição quando necessário

Em aplicativos de longa duração, cancele a inscrição em eventos quando não forem mais necessários para evitar vazamentos de memória:

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork

pdfWorker.DoWork -= PdfWorker_DoWork

Considerações finais

O uso de manipuladores de eventos, tipos de delegados e campos de eventos com o IronPDF adiciona uma vantagem moderna e responsiva aos aplicativos .NET . Seja para gerar documentos em uma classe base, criar lógica reutilizável em classes derivadas ou simplesmente explorar o modelo de eventos do .NET, esse padrão é escalável e limpo.

Quando usar essa abordagem

Você deseja gerar um evento quando uma tarefa for concluída.

É necessário separar claramente a lógica da interface do usuário.
Você está trabalhando com BackgroundWorker, eventos e delegados
Você prefere a mecânica de pontos de função com segurança de tipos do C#

Alternativas a explorar

async/await e Task.Run para fluxos de trabalho mais recentes
IProgress<t> para atualizações em tempo real durante operações longas, IronPDF combinado com eventos C# facilita a criação de aplicativos poderosos e responsivos de geração de PDF com usabilidade no mundo real em mente. Pronto para implementar a geração de PDFs orientada a eventos em seu aplicativo .NET ? Experimente com a versão de avaliação gratuita do IronPDF e mantenha seus usuários satisfeitos com experiências fluidas e sem bloqueios!

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 bem estruturados e visualmente atraentes.

...