Como converter PDF para TIFF em VB.NET

Por que o PictureBox não consegue exibir arquivos PDF diretamente?

O controle PictureBox no Windows Forms é projetado estritamente para formatos de imagem: BMP, PNG, JPG, GIF, TIFF, e uma mão cheia de outros. Quando você tenta atribuir um caminho de arquivo PDF a PictureBox.ImageLocation ou carregar um fluxo PDF em PictureBox.Image, o controle lança uma exceção porque o formato binário do PDF não é um formato de imagem reconhecido.

Algumas abordagens tentam contornar isso incorporando o Adobe Acrobat por meio da interoperabilidade COM. Isso cria uma forte dependência da instalação do Adobe Reader em todas as máquinas que executam o aplicativo — uma restrição de implantação difícil de gerenciar em ambientes corporativos. Isso também vincula o mecanismo de renderização à versão do Acrobat que o usuário possui, o que pode causar problemas de compatibilidade entre diferentes máquinas.

Uma abordagem mais limpa é usar uma biblioteca PDF .NET que converte páginas PDF em imagens bitmap em tempo de execução. IronPDF oferece exatamente essa capacidade por meio de seu método ToBitmap, que renderiza cada página de um documento PDF em um objeto AnyBitmap. Você pode então converter esse objeto em um System.Drawing.Bitmap padrão e atribuí-lo diretamente a PictureBox.Image. Não é necessária a instalação do Adobe, nenhum registro COM e nenhum visualizador externo incorporado na janela do aplicativo.

Essa técnica funciona no .NET Framework 4.6.2 e versões superiores, bem como no .NET 6, 8 e 10 no Windows. O mecanismo de renderização do IronPDF é baseado no Chrome, o que significa que produz resultados de alta fidelidade mesmo para PDFs com layouts complexos, fontes incorporadas e conteúdo misto de imagem e texto.

Como instalar o IronPDF em um projeto Windows Forms?

Antes de escrever qualquer código, você precisa adicionar o IronPDF ao seu projeto. A maneira mais rápida é através da linha de comando do Gerenciador de Pacotes NuGet :

dotnet add package IronPdf

Alternativamente, utilize o Console do Gerenciador de Pacotes do Visual Studio:

Install-Package IronPdf

Após a instalação, confirme se a referência ao pacote aparece no seu arquivo .csproj. IronPDF é direcionado ao Windows no .NET 6 e posterior, portanto, se você estiver usando um alvo multiplataforma no seu arquivo de projeto, adicione uma restrição <RuntimeIdentifiers> ou <Platforms> para o Windows. Para projetos do Windows Forms, isso geralmente já está configurado quando você cria o modelo de projeto no Visual Studio.

Para licenciamento em produção, insira sua chave de licença no código de inicialização do seu aplicativo antes de qualquer chamada do IronPDF :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Durante o desenvolvimento e a avaliação, o IronPDF é executado em modo de teste, o que adiciona uma marca d'água à saída renderizada. Uma licença de avaliação gratuita remove a marca d'água para fins de teste.

Como configurar a estrutura de um projeto do Windows Forms?

Abra o Visual Studio e crie um novo projeto Windows Forms App direcionado para .NET 10. O modelo do projeto gera um Form1.cs e um ponto de entrada Program.cs.

Na interface do designer, adicione os seguintes controles ao seu formulário:

• Um PictureBox chamado pictureBoxPdf cobrindo a maior parte do formulário, com SizeMode definido para Zoom
• Um Button chamado btnOpen com o texto "Abrir PDF"
• Um Button chamado btnPrevious com o texto "Anterior"
• Um Button chamado btnNext com o texto "Próximo"
• Um Button chamado btnSave com o texto "Salvar Página"
• Um Button chamado btnPrint com o texto "Imprimir"
• Um Label chamado lblPageInfo para mostrar o número da página atual

A configuração SizeMode = Zoom no PictureBox garante que as páginas PDF sejam escaladas proporcionalmente para se ajustarem ao controle sem distorcer a proporção. Isso é importante porque as páginas de PDF variam de tamanho — os formatos carta, A4 e ofício têm dimensões diferentes, e você quer que o visualizador lide com todos eles sem problemas.

Abaixo está o código completo do formulário para o aplicativo visualizador de PDF. Isso usa declarações de nível superior em Program.cs e coloca toda a lógica do visualizador dentro de Form1.cs:

using IronPdf;
using IronSoftware.Drawing;
using System.Drawing;

public partial class Form1 : Form
{
    private PdfDocument? currentPdf;
    private AnyBitmap[]? pageImages;
    private int currentPageIndex = 0;

    public Form1()
    {
        InitializeComponent();
        pictureBoxPdf.SizeMode = PictureBoxSizeMode.Zoom;
        UpdateNavigationState();
    }

    private void UpdateNavigationState()
    {
        bool hasPdf = pageImages != null && pageImages.Length > 0;
        btnPrevious.Enabled = hasPdf && currentPageIndex > 0;
        btnNext.Enabled = hasPdf && currentPageIndex < (pageImages?.Length - 1 ?? 0);
        btnSave.Enabled = hasPdf;
        btnPrint.Enabled = hasPdf;
        lblPageInfo.Text = hasPdf
            ? $"Page {currentPageIndex + 1} of {pageImages!.Length}"
            : "No document loaded";
    }
}

using IronPdf;
using IronSoftware.Drawing;
using System.Drawing;

public partial class Form1 : Form
{
    private PdfDocument? currentPdf;
    private AnyBitmap[]? pageImages;
    private int currentPageIndex = 0;

    public Form1()
    {
        InitializeComponent();
        pictureBoxPdf.SizeMode = PictureBoxSizeMode.Zoom;
        UpdateNavigationState();
    }

    private void UpdateNavigationState()
    {
        bool hasPdf = pageImages != null && pageImages.Length > 0;
        btnPrevious.Enabled = hasPdf && currentPageIndex > 0;
        btnNext.Enabled = hasPdf && currentPageIndex < (pageImages?.Length - 1 ?? 0);
        btnSave.Enabled = hasPdf;
        btnPrint.Enabled = hasPdf;
        lblPageInfo.Text = hasPdf
            ? $"Page {currentPageIndex + 1} of {pageImages!.Length}"
            : "No document loaded";
    }
}

Imports IronPdf
Imports IronSoftware.Drawing
Imports System.Drawing

Public Partial Class Form1
    Inherits Form

    Private currentPdf As PdfDocument
    Private pageImages As AnyBitmap()
    Private currentPageIndex As Integer = 0

    Public Sub New()
        InitializeComponent()
        pictureBoxPdf.SizeMode = PictureBoxSizeMode.Zoom
        UpdateNavigationState()
    End Sub

    Private Sub UpdateNavigationState()
        Dim hasPdf As Boolean = pageImages IsNot Nothing AndAlso pageImages.Length > 0
        btnPrevious.Enabled = hasPdf AndAlso currentPageIndex > 0
        btnNext.Enabled = hasPdf AndAlso currentPageIndex < If(pageImages?.Length - 1, 0)
        btnSave.Enabled = hasPdf
        btnPrint.Enabled = hasPdf
        lblPageInfo.Text = If(hasPdf, $"Page {currentPageIndex + 1} of {pageImages.Length}", "No document loaded")
    End Sub
End Class

O método auxiliar UpdateNavigationState desativa ou ativa os botões de navegação e ação com base em se um PDF foi carregado e qual página o visualizador está mostrando atualmente. Isso evita erros de referência nula quando os usuários clicam em botões antes de carregar um documento.

Como carregar e renderizar páginas PDF em um PictureBox?

Carregar um PDF e renderizá-lo no PictureBox envolve duas etapas: carregar o documento com PdfDocument.FromFile e, em seguida, chamar ToBitmap para converter todas as páginas em uma matriz de objetos bitmap.

O método de conversão de PDF para imagem ToBitmap renderiza cada página no PDF no DPI solicitado. Uma resolução DPI mais alta produz imagens mais nítidas, mas utiliza mais memória. Um valor de 150 DPI geralmente representa um bom equilíbrio para um visualizador de documentos — legível na tela sem exigir gigabytes de RAM para documentos grandes.

private void btnOpen_Click(object sender, EventArgs e)
{
    using OpenFileDialog openDialog = new OpenFileDialog();
    openDialog.Filter = "PDF Files|*.pdf";
    openDialog.Title = "Select a PDF Document";

    if (openDialog.ShowDialog() == DialogResult.OK)
    {
        LoadPdfDocument(openDialog.FileName);
    }
}

private void LoadPdfDocument(string filePath)
{
    currentPdf?.Dispose();
    currentPdf = PdfDocument.FromFile(filePath);

    // Render all pages as bitmaps at 150 DPI
    pageImages = currentPdf.ToBitmap(150);
    currentPageIndex = 0;

    DisplayCurrentPage();
    UpdateNavigationState();
}

private void DisplayCurrentPage()
{
    if (pageImages == null || pageImages.Length == 0) return;

    // Convert AnyBitmap to System.Drawing.Bitmap for PictureBox
    System.Drawing.Bitmap bitmap = pageImages[currentPageIndex].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    UpdateNavigationState();
}

private void btnOpen_Click(object sender, EventArgs e)
{
    using OpenFileDialog openDialog = new OpenFileDialog();
    openDialog.Filter = "PDF Files|*.pdf";
    openDialog.Title = "Select a PDF Document";

    if (openDialog.ShowDialog() == DialogResult.OK)
    {
        LoadPdfDocument(openDialog.FileName);
    }
}

private void LoadPdfDocument(string filePath)
{
    currentPdf?.Dispose();
    currentPdf = PdfDocument.FromFile(filePath);

    // Render all pages as bitmaps at 150 DPI
    pageImages = currentPdf.ToBitmap(150);
    currentPageIndex = 0;

    DisplayCurrentPage();
    UpdateNavigationState();
}

private void DisplayCurrentPage()
{
    if (pageImages == null || pageImages.Length == 0) return;

    // Convert AnyBitmap to System.Drawing.Bitmap for PictureBox
    System.Drawing.Bitmap bitmap = pageImages[currentPageIndex].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    UpdateNavigationState();
}

Private Sub btnOpen_Click(sender As Object, e As EventArgs) Handles btnOpen.Click
    Using openDialog As New OpenFileDialog()
        openDialog.Filter = "PDF Files|*.pdf"
        openDialog.Title = "Select a PDF Document"

        If openDialog.ShowDialog() = DialogResult.OK Then
            LoadPdfDocument(openDialog.FileName)
        End If
    End Using
End Sub

Private Sub LoadPdfDocument(filePath As String)
    currentPdf?.Dispose()
    currentPdf = PdfDocument.FromFile(filePath)

    ' Render all pages as bitmaps at 150 DPI
    pageImages = currentPdf.ToBitmap(150)
    currentPageIndex = 0

    DisplayCurrentPage()
    UpdateNavigationState()
End Sub

Private Sub DisplayCurrentPage()
    If pageImages Is Nothing OrElse pageImages.Length = 0 Then Return

    ' Convert AnyBitmap to System.Drawing.Bitmap for PictureBox
    Dim bitmap As System.Drawing.Bitmap = pageImages(currentPageIndex).ToImage(Of System.Drawing.Bitmap)()
    pictureBoxPdf.Image?.Dispose()
    pictureBoxPdf.Image = bitmap

    UpdateNavigationState()
End Sub

O método PdfDocument.FromFile carrega o PDF do disco para a memória. Chamar ToBitmap com um parâmetro de DPI retorna uma matriz de objetos AnyBitmap, um por página. O tipo AnyBitmap é a classe bitmap agnóstica de formato da IronPDF, e ToImage<System.Drawing.Bitmap>() a converte para o tipo System.Drawing.Bitmap que PictureBox.Image espera.

Observe que o PictureBox.Image anterior é descartado antes de atribuir um novo. Isso é importante -- cada objeto Bitmap mantém recursos não gerenciados do GDI+, e não descartar bitmaps antigos causa vazamentos de memória em aplicativos de longa duração.

Após o carregamento, o visualizador exibe a primeira página imediatamente. O rótulo lblPageInfo é atualizado para mostrar o número da página atual e a contagem total de páginas.

Como adicionar navegação entre páginas de um PDF?

Um visualizador de PDF que exibe apenas a primeira página não é útil para documentos com várias páginas. Os botões de navegação permitem que os usuários avancem e retrocedam na matriz de páginas renderizada:

private void btnPrevious_Click(object sender, EventArgs e)
{
    if (currentPageIndex > 0)
    {
        currentPageIndex--;
        DisplayCurrentPage();
    }
}

private void btnNext_Click(object sender, EventArgs e)
{
    if (pageImages != null && currentPageIndex < pageImages.Length - 1)
    {
        currentPageIndex++;
        DisplayCurrentPage();
    }
}

private void btnPrevious_Click(object sender, EventArgs e)
{
    if (currentPageIndex > 0)
    {
        currentPageIndex--;
        DisplayCurrentPage();
    }
}

private void btnNext_Click(object sender, EventArgs e)
{
    if (pageImages != null && currentPageIndex < pageImages.Length - 1)
    {
        currentPageIndex++;
        DisplayCurrentPage();
    }
}

Private Sub btnPrevious_Click(sender As Object, e As EventArgs)
    If currentPageIndex > 0 Then
        currentPageIndex -= 1
        DisplayCurrentPage()
    End If
End Sub

Private Sub btnNext_Click(sender As Object, e As EventArgs)
    If pageImages IsNot Nothing AndAlso currentPageIndex < pageImages.Length - 1 Then
        currentPageIndex += 1
        DisplayCurrentPage()
    End If
End Sub

Cada manipulador de cliques ajusta o currentPageIndex em um e chama DisplayCurrentPage, que troca o PictureBox.Image para o bitmap correspondente. As verificações de limites (currentPageIndex > 0 e currentPageIndex < pageImages.Length - 1) impedem exceções de índice fora dos limites, embora UpdateNavigationState também desative os botões quando eles estiverem fora do alcance.

Para documentos maiores, você também pode considerar adicionar um campo de entrada de número de página onde os usuários possam digitar um número de página específico para pular diretamente para essa página, ou uma faixa de miniaturas rolável ao lado. A matriz pageImages já contém todas as páginas renderizadas, então pular para uma página arbitrária é simplesmente uma questão de definir currentPageIndex para o índice alvo e chamar DisplayCurrentPage.

Como salvar e imprimir páginas em PDF a partir do visualizador?

Os visualizadores de documentos geralmente precisam oferecer suporte tanto para salvar a página atual como um arquivo de imagem quanto para enviar o documento para uma impressora. O IronPDF torna ambos os processos simples.

private void btnSave_Click(object sender, EventArgs e)
{
    if (pictureBoxPdf.Image == null) return;

    using SaveFileDialog saveDialog = new SaveFileDialog();
    saveDialog.Filter = "PNG Image|*.png|JPEG Image|*.jpg|TIFF Image|*.tif";
    saveDialog.Title = "Save Page As Image";
    saveDialog.FileName = $"page_{currentPageIndex + 1}";

    if (saveDialog.ShowDialog() == DialogResult.OK)
    {
        pictureBoxPdf.Image.Save(saveDialog.FileName);
    }
}

private void btnSave_Click(object sender, EventArgs e)
{
    if (pictureBoxPdf.Image == null) return;

    using SaveFileDialog saveDialog = new SaveFileDialog();
    saveDialog.Filter = "PNG Image|*.png|JPEG Image|*.jpg|TIFF Image|*.tif";
    saveDialog.Title = "Save Page As Image";
    saveDialog.FileName = $"page_{currentPageIndex + 1}";

    if (saveDialog.ShowDialog() == DialogResult.OK)
    {
        pictureBoxPdf.Image.Save(saveDialog.FileName);
    }
}

Private Sub btnSave_Click(sender As Object, e As EventArgs)
    If pictureBoxPdf.Image Is Nothing Then Return

    Using saveDialog As New SaveFileDialog()
        saveDialog.Filter = "PNG Image|*.png|JPEG Image|*.jpg|TIFF Image|*.tif"
        saveDialog.Title = "Save Page As Image"
        saveDialog.FileName = $"page_{currentPageIndex + 1}"

        If saveDialog.ShowDialog() = DialogResult.OK Then
            pictureBoxPdf.Image.Save(saveDialog.FileName)
        End If
    End Using
End Sub

private void btnPrint_Click(object sender, EventArgs e)
{
    if (currentPdf == null) return;

    using PrintDialog printDialog = new PrintDialog();
    if (printDialog.ShowDialog() == DialogResult.OK)
    {
        currentPdf.Print();
    }
}

private void btnPrint_Click(object sender, EventArgs e)
{
    if (currentPdf == null) return;

    using PrintDialog printDialog = new PrintDialog();
    if (printDialog.ShowDialog() == DialogResult.OK)
    {
        currentPdf.Print();
    }
}

Private Sub btnPrint_Click(sender As Object, e As EventArgs)
    If currentPdf Is Nothing Then Return

    Using printDialog As New PrintDialog()
        If printDialog.ShowDialog() = DialogResult.OK Then
            currentPdf.Print()
        End If
    End Using
End Sub

Como lidar corretamente com a memória e o descarte?

Documentos PDF e imagens bitmap renderizadas consomem uma quantidade significativa de memória, especialmente em configurações de DPI mais altas ou para documentos grandes. Sem o descarte adequado, um aplicativo visualizador de longa duração irá gradualmente esgotar a memória disponível.

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        currentPdf?.Dispose();
        pictureBoxPdf.Image?.Dispose();

        if (pageImages != null)
        {
            foreach (var bitmap in pageImages)
                bitmap.Dispose();
        }

        components?.Dispose();
    }
    base.Dispose(disposing);
}

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        currentPdf?.Dispose();
        pictureBoxPdf.Image?.Dispose();

        if (pageImages != null)
        {
            foreach (var bitmap in pageImages)
                bitmap.Dispose();
        }

        components?.Dispose();
    }
    base.Dispose(disposing);
}

Protected Overrides Sub Dispose(disposing As Boolean)
    If disposing Then
        currentPdf?.Dispose()
        pictureBoxPdf.Image?.Dispose()

        If pageImages IsNot Nothing Then
            For Each bitmap In pageImages
                bitmap.Dispose()
            Next
        End If

        components?.Dispose()
    End If
    MyBase.Dispose(disposing)
End Sub

Como faço para renderizar apenas a página visível em vez de todas as páginas?

Para PDFs grandes com dezenas ou centenas de páginas, renderizar todas as páginas antecipadamente com ToBitmap pode ser lento e consumir muita memória. Uma abordagem mais eficiente é renderizar apenas a página que o usuário deseja ver, sob demanda.

A abordagem RasterizeToImageFiles do IronPDF suporta renderização por página, mas para uso em memória você também pode usar PageCount e renderizar uma página de cada vez:

private void DisplayPageLazy(int pageIndex)
{
    if (currentPdf == null) return;

    // Render only the requested page
    AnyBitmap[] singlePage = currentPdf.ToBitmap(150, pageIndex, pageIndex);

    System.Drawing.Bitmap bitmap = singlePage[0].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    singlePage[0].Dispose();

    lblPageInfo.Text = $"Page {pageIndex + 1} of {currentPdf.PageCount}";
    UpdateNavigationState();
}

private void DisplayPageLazy(int pageIndex)
{
    if (currentPdf == null) return;

    // Render only the requested page
    AnyBitmap[] singlePage = currentPdf.ToBitmap(150, pageIndex, pageIndex);

    System.Drawing.Bitmap bitmap = singlePage[0].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    singlePage[0].Dispose();

    lblPageInfo.Text = $"Page {pageIndex + 1} of {currentPdf.PageCount}";
    UpdateNavigationState();
}

Private Sub DisplayPageLazy(pageIndex As Integer)
    If currentPdf Is Nothing Then Return

    ' Render only the requested page
    Dim singlePage As AnyBitmap() = currentPdf.ToBitmap(150, pageIndex, pageIndex)

    Dim bitmap As System.Drawing.Bitmap = singlePage(0).ToImage(Of System.Drawing.Bitmap)()
    pictureBoxPdf.Image?.Dispose()
    pictureBoxPdf.Image = bitmap

    singlePage(0).Dispose()

    lblPageInfo.Text = $"Page {pageIndex + 1} of {currentPdf.PageCount}"
    UpdateNavigationState()
End Sub

A sobrecarga ToBitmap(dpi, startPage, endPage) renderiza um intervalo específico de páginas. Ao passar o mesmo índice para ambos startPage e endPage, apenas uma página é renderizada por vez. Isso troca o tempo de renderização por navegação por menor uso máximo de memória, o que pode valer a pena para documentos muito grandes.

Para mais informações sobre os recursos de saída de imagem do IronPDF, consulte a documentação de conversão de PDF para imagem e o guia de rasterização de PDF .

Um visualizador de PDF prático também deve permitir que os usuários ampliem o conteúdo e girem as páginas. Para zoom, ajuste o DPI passado para ToBitmap dinamicamente -- armazene um campo currentDpi (começando em 150), incremente ou decrete em 50 nas cliques dos botões de zoom, e depois chame o renderizador de página preguiçoso com o DPI atualizado. DPI maior produz uma imagem maior, que o PictureBox no modo Zoom escala para se ajustar ao controle. Limite o intervalo entre 72 e 400 DPI usando Math.Min e Math.Max para evitar saída borrada no limite inferior ou consumo excessivo de memória no limite superior.

Para opções de renderização mais avançadas, incluindo a extração de texto de PDFs juntamente com a renderização de imagens, consulte o guia de extração de texto de PDF e a documentação de extração de imagens de PDF .

Você também pode explorar o suporte do IronPDF para mesclar documentos PDF, adicionar marcas d'água, girar páginas PDF, e adicionar anotações como recursos em um visualizador mais avançado.

Como escolher uma biblioteca de renderização de PDF para Windows Forms?

Ao escolher uma biblioteca de renderização de PDF para Windows Forms, existem diversas alternativas. Aqui está uma breve comparação para ajudá-lo a avaliar as opções:

A principal vantagem do IronPDF para casos de uso do Windows Forms é que ele é totalmente independente — nenhum software externo precisa ser instalado nas máquinas dos usuários finais. A página de licenciamento do IronPDF contém todos os detalhes sobre preços e a opção de avaliação gratuita. Você pode encontrar o pacote no NuGet , juntamente com estatísticas de download e histórico de versões. Para uma análise mais aprofundada de como a especificação PDF define a renderização de páginas, a norma ISO 32000-2, publicada pela ISO, descreve o formato que o IronPDF e outros renderizadores devem implementar.

Para obter mais informações sobre os recursos do IronPDF além da renderização de imagens, a página inicial da documentação do IronPDF aborda a criação de PDFs, a conversão de HTML para PDF, o gerenciamento de formulários, as assinaturas digitais e muito mais.

Quais são os seus próximos passos?

O padrão mostrado neste tutorial -- renderizar com ToBitmap, exibir em PictureBox, navegar com controles baseados em índice -- oferece a você um visualizador de PDF funcional e sem dependências no Windows Forms. A partir daqui, existem várias direções que vale a pena explorar, dependendo dos requisitos da sua aplicação.

Para um visualizador com qualidade de produção, considere a renderização de páginas sob demanda para lidar com documentos grandes de forma eficiente, adicionando um painel de miniaturas rolável ao lado do visualizador principal e expondo controles de zoom vinculados ao parâmetro DPI. Para aplicações de gerenciamento de documentos, combine o visualizador com os recursos de extração de texto e leitura de campos de formulário do IronPDF para criar índices de documentos pesquisáveis.

Se o seu fluxo de trabalho envolve a geração programática de PDFs antes da exibição, o IronPDF também oferece suporte à conversão de HTML para PDF e à criação de PDFs do zero , de forma que a mesma biblioteca lide tanto com a geração quanto com a visualização.

Comece um teste gratuito para obter uma chave de licença sem marca d'água para desenvolvimento, ou revise a referência completa da API para ver o conjunto completo de métodos disponíveis em PdfDocument, AnyBitmap, e as classes de renderização de suporte. A galeria de exemplos do IronPDF também possui exemplos de código prontos para rodar, cobrindo tarefas comuns de PDF em C#.