Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Usando o IronPDF
  4. Geração dinâmica de PDFs
USANDO O IRONPDF

Como gerar PDFs dinamicamente em C#

Curtis Chau
Curtis Chau
Atualizado:

As aplicações web modernas exigem mais do que a criação de documentos estáticos. Seja para gerar faturas personalizadas, criar relatórios em PDF baseados em dados ou produzir campos de formulário personalizados, os desenvolvedores precisam de ferramentas robustas para gerar documentos PDF em tempo de execução. O IronPDF surge como a solução líder, oferecendo renderização poderosa baseada no Chrome para criar documentos PDF com integração perfeita com C# para geração dinâmica de PDFs em ambientes C# e .NET Framework .

Como gerar PDFs dinamicamente em C#: Figura 1 - Multiplataforma

What is Dynamic PDF Generation in C#?

A geração dinâmica de PDFs em C# cria documentos PDF em tempo de execução, utilizando dados variáveis ​​de múltiplas fontes, incluindo bancos de dados, APIs ou entradas do usuário. Ao contrário dos arquivos PDF estáticos, a geração em tempo de execução permite conteúdo personalizado, seções condicionais e layouts orientados a dados, recursos essenciais para faturas, relatórios em PDF, certificados e formulários que se adaptam a requisitos em constante mudança. Essa abordagem para criar PDFs programaticamente tornou-se crucial para aplicações modernas do .NET Framework e .NET Core .

Como gerar PDFs dinamicamente em C#: Figura 2 - Multiplataforma

Primeiros passos com o IronPDF

Comece instalando o pacote NuGet IronPDF através do Console do Gerenciador de Pacotes no Visual Studio:

Install-Package IronPdf

Como gerar PDFs dinamicamente em C#: Figura 3 - Instalação

Ou utilize a interface do Gerenciador de Pacotes NuGet para baixar e instalar. Inicialize o ChromePdfRenderer para geração de PDFs com perfeição de pixels:

using IronPdf;
// Create Chrome renderer instance
var renderer = new ChromePdfRenderer();
// Configure rendering options for PDF format
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
using IronPdf;
// Create Chrome renderer instance
var renderer = new ChromePdfRenderer();
// Configure rendering options for PDF format
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
Imports IronPdf

' Create Chrome renderer instance
Dim renderer As New ChromePdfRenderer()

' Configure rendering options for PDF format
renderer.RenderingOptions.MarginTop = 50
renderer.RenderingOptions.MarginBottom = 50
renderer.RenderingOptions.PrintHtmlBackgrounds = True
$vbLabelText   $csharpLabel

A classe ChromePdfRenderer fornece a base para gerar um PDF em tempo de execução. A definição de margens garante espaço para cabeçalhos e rodapés, enquanto PrintHtmlBackgrounds preserva os elementos de design. Essa configuração ajuda a criar documentos PDF com base no conteúdo HTML exato. Saiba mais sobre as opções de renderização para personalizar seus documentos PDF.

Como criar documentos PDF dinamicamente usando um modelo

Crie modelos HTML reutilizáveis ​​com espaços reservados para injeção dinâmica de dados:

// Define HTML string template with placeholders
string invoiceTemplate = @"
<html>
<body>
    <h1>Invoice #[[INVOICE_NUMBER]]</h1>
    <p>Date: [[DATE]]</p>
    <p>Customer: [[CUSTOMER_NAME]]</p>
    <table>
        <tr><th>Item</th><th>Price</th></tr>
        [[ITEMS]]
    </table>
    <p><strong>Total: $[[TOTAL]]</strong></p>
</body>
</html>";
// Replace placeholders with dynamic data
var invoiceData = new {
    InvoiceNumber = "INV-2025-001",
    Date = DateTime.Now.ToString("yyyy-MM-dd"),
    CustomerName = "John Doe",
    Total = 1250.00m
};
string finalHtml = invoiceTemplate
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber)
    .Replace("[[DATE]]", invoiceData.Date)
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName)
    .Replace("[[TOTAL]]", invoiceData.Total.ToString());
// Generate PDF from populated HTML content
var pdf = renderer.RenderHtmlAsPdf(finalHtml);
pdf.SaveAs("invoice.pdf");
// Define HTML string template with placeholders
string invoiceTemplate = @"
<html>
<body>
    <h1>Invoice #[[INVOICE_NUMBER]]</h1>
    <p>Date: [[DATE]]</p>
    <p>Customer: [[CUSTOMER_NAME]]</p>
    <table>
        <tr><th>Item</th><th>Price</th></tr>
        [[ITEMS]]
    </table>
    <p><strong>Total: $[[TOTAL]]</strong></p>
</body>
</html>";
// Replace placeholders with dynamic data
var invoiceData = new {
    InvoiceNumber = "INV-2025-001",
    Date = DateTime.Now.ToString("yyyy-MM-dd"),
    CustomerName = "John Doe",
    Total = 1250.00m
};
string finalHtml = invoiceTemplate
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber)
    .Replace("[[DATE]]", invoiceData.Date)
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName)
    .Replace("[[TOTAL]]", invoiceData.Total.ToString());
// Generate PDF from populated HTML content
var pdf = renderer.RenderHtmlAsPdf(finalHtml);
pdf.SaveAs("invoice.pdf");
' Define HTML string template with placeholders
Dim invoiceTemplate As String = "
<html>
<body>
    <h1>Invoice #[[INVOICE_NUMBER]]</h1>
    <p>Date: [[DATE]]</p>
    <p>Customer: [[CUSTOMER_NAME]]</p>
    <table>
        <tr><th>Item</th><th>Price</th></tr>
        [[ITEMS]]
    </table>
    <p><strong>Total: $[[TOTAL]]</strong></p>
</body>
</html>"

' Replace placeholders with dynamic data
Dim invoiceData = New With {
    .InvoiceNumber = "INV-2025-001",
    .Date = DateTime.Now.ToString("yyyy-MM-dd"),
    .CustomerName = "John Doe",
    .Total = 1250.00D
}

Dim finalHtml As String = invoiceTemplate _
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber) _
    .Replace("[[DATE]]", invoiceData.Date) _
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName) _
    .Replace("[[TOTAL]]", invoiceData.Total.ToString())

' Generate PDF from populated HTML content
Dim pdf = renderer.RenderHtmlAsPdf(finalHtml)
pdf.SaveAs("invoice.pdf")
$vbLabelText   $csharpLabel

Essa abordagem baseada em modelos separa a apresentação dos dados, permitindo que os designers modifiquem layouts complexos enquanto os desenvolvedores se concentram na integração de dados. O método Replace substitui os marcadores de posição de ID do modelo por valores de tempo de execução, criando documentos PDF personalizados. Para converter conteúdo HTML com seções repetidas, construa o HTML dinamicamente usando loops antes da conversão para PDF. Explore mais exemplos de HTML para PDF para modelos avançados.

Saída

Como gerar PDFs dinamicamente em C#: Figura 4 - Saída em PDF

Vinculação de dados avançada com processamento assíncrono

Aumente a escala da geração de PDFs com métodos assíncronos para processamento de alto volume:

// Async batch generation for multiple PDF documents
public async Task GenerateMonthlyReportsAsync(List<Customer> customers)
{
    var renderer = new ChromePdfRenderer();
    var tasks = new List<Task>();
    foreach (var customer in customers)
    {
        tasks.Add(Task.Run(async () =>
        {
            // Create HTML content with dynamic data
            string html = $@"
                <h2>Monthly Report - {customer.Name}</h2>
                <p>Account Balance: ${customer.Balance:F2}</p>
                <p>Transactions: {customer.TransactionCount}</p>
                <div style='page-break-after: always;'></div>";
            // Convert HTML to PDF format
            var document = await renderer.RenderHtmlAsPdfAsync(html);
            await document.SaveAs($"reports/{customer.Id}_report.pdf");
        }));
    }
    await Task.WhenAll(tasks);
}
// Async batch generation for multiple PDF documents
public async Task GenerateMonthlyReportsAsync(List<Customer> customers)
{
    var renderer = new ChromePdfRenderer();
    var tasks = new List<Task>();
    foreach (var customer in customers)
    {
        tasks.Add(Task.Run(async () =>
        {
            // Create HTML content with dynamic data
            string html = $@"
                <h2>Monthly Report - {customer.Name}</h2>
                <p>Account Balance: ${customer.Balance:F2}</p>
                <p>Transactions: {customer.TransactionCount}</p>
                <div style='page-break-after: always;'></div>";
            // Convert HTML to PDF format
            var document = await renderer.RenderHtmlAsPdfAsync(html);
            await document.SaveAs($"reports/{customer.Id}_report.pdf");
        }));
    }
    await Task.WhenAll(tasks);
}
Imports System.Threading.Tasks
Imports System.Collections.Generic

' Async batch generation for multiple PDF documents
Public Async Function GenerateMonthlyReportsAsync(customers As List(Of Customer)) As Task
    Dim renderer = New ChromePdfRenderer()
    Dim tasks = New List(Of Task)()

    For Each customer In customers
        tasks.Add(Task.Run(Async Function()
                               ' Create HTML content with dynamic data
                               Dim html As String = $"
                                   <h2>Monthly Report - {customer.Name}</h2>
                                   <p>Account Balance: ${customer.Balance:F2}</p>
                                   <p>Transactions: {customer.TransactionCount}</p>
                                   <div style='page-break-after: always;'></div>"
                               ' Convert HTML to PDF format
                               Dim document = Await renderer.RenderHtmlAsPdfAsync(html)
                               Await document.SaveAs($"reports/{customer.Id}_report.pdf")
                           End Function))
    Next

    Await Task.WhenAll(tasks)
End Function
$vbLabelText   $csharpLabel

O padrão assíncrono permite a geração simultânea de PDFs, melhorando drasticamente a produtividade ao gerar documentos PDF em lote. O Task.WhenAll garante que todos os arquivos PDF estejam completos antes de prosseguir. O código acima utiliza propriedades CSS de quebra de página para controlar a paginação, garantindo que o relatório de cada cliente comece em uma nova página. Analise a documentação sobre geração assíncrona de PDFs para aplicações web empresariais.

Criação dinâmica de formulários PDF interativos

Transforme páginas web com formulários HTML em PDFs preenchíveis programaticamente:

// Enable form fields creation in rendering options
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
// Define HTML string with form elements
string formHtml = @"
<form>
    <h2>Customer Survey</h2>
    <label>Name: 
    <label>Email: 
    <label>Satisfaction:
        <select name='satisfaction'>
            <option>Excellent</option>
            <option>Good</option>
            <option>Fair</option>
        </select>
    </label><br>
    <label>Comments: <textarea name='comments'></textarea></label>
</form>";
// Create a PDF with interactive form fields
var pdfDocument = renderer.RenderHtmlAsPdf(formHtml);
pdfDocument.SaveAs("survey_form.pdf");
// Enable form fields creation in rendering options
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
// Define HTML string with form elements
string formHtml = @"
<form>
    <h2>Customer Survey</h2>
    <label>Name: 
    <label>Email: 
    <label>Satisfaction:
        <select name='satisfaction'>
            <option>Excellent</option>
            <option>Good</option>
            <option>Fair</option>
        </select>
    </label><br>
    <label>Comments: <textarea name='comments'></textarea></label>
</form>";
// Create a PDF with interactive form fields
var pdfDocument = renderer.RenderHtmlAsPdf(formHtml);
pdfDocument.SaveAs("survey_form.pdf");
' Enable form fields creation in rendering options
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
' Define HTML string with form elements
Dim formHtml As String = "
<form>
    <h2>Customer Survey</h2>
    <label>Name: 
    <label>Email: 
    <label>Satisfaction:
        <select name='satisfaction'>
            <option>Excellent</option>
            <option>Good</option>
            <option>Fair</option>
        </select>
    </label><br>
    <label>Comments: <textarea name='comments'></textarea></label>
</form>"
' Create a PDF with interactive form fields
Dim pdfDocument = renderer.RenderHtmlAsPdf(formHtml)
pdfDocument.SaveAs("survey_form.pdf")
$vbLabelText   $csharpLabel

A configuração CreatePdfFormsFromHtml converte elementos de formulário HTML em campos de formulário PDF interativos. Os usuários podem preencher, salvar e enviar esses documentos PDF eletronicamente. Essa funcionalidade agiliza os fluxos de trabalho, eliminando formulários em papel, ao mesmo tempo que mantém os padrões de desenvolvimento HTML já conhecidos. O objeto PDFDocument permite manipular campos de formulário programaticamente. Aprenda sobre manipulação de formulários PDF para implementações avançadas, incluindo assinaturas digitais.

Saída

Como gerar PDFs dinamicamente em C#: Figura 5 - Saída de formulário PDF interativo

Por que escolher o IronPDF em vez de outros métodos?

O mecanismo de renderização Chrome do IronPDF garante precisão perfeita em cada pixel ao criar PDFs, eliminando as limitações das soluções mais antigas com mecanismos de renderização WebKit. Ao contrário das alternativas de bibliotecas de código aberto que exigem executáveis ​​externos ou configurações de navegador sem interface gráfica, o IronPDF se integra perfeitamente, sem nenhuma dependência. A API fluente e o design de API de alto nível tornam-na superior às classes integradas ou às implementações complexas do Crystal Reports.

Como gerar PDFs dinamicamente em C#: Figura 6 - Recursos

Key advantages for dynamic PDF generation in C

  • Execução completa de JavaScript , ao contrário de outros métodos
  • Operações thread-safe para aplicações web
  • Suporte assíncrono abrangente com os seguintes padrões de exemplo
  • Controle de números de página e tamanho da fonte por meio de uma configuração simples de endpoint de API.
  • A conversão de HTML para PDF é idêntica à do Chrome.

Como gerar PDFs dinamicamente em C#: Figura 7 - Geração dinâmica de PDF - IronPDF

O licenciamento começa em $799 para licenças de desenvolvedor individual, com opções disponíveis para equipes e empresas. Cada pacote possui suas próprias vantagens, e o investimento se paga por meio da economia de tempo de desenvolvimento. Acesse sua chave de API instantaneamente após a compra. Veja as opções de licenciamento para encontrar o pacote NuGet certo para o seu projeto.

Como gerar PDFs dinamicamente em C#: Figura 8 - Licenciamento

Conclusão

A geração dinâmica de PDFs em C# transforma a maneira como os aplicativos entregam documentos personalizados em tempo de execução. O IronPDF fornece ferramentas essenciais para gerar arquivos PDF a partir de conteúdo HTML, páginas da web e fontes de dados. Sua renderização baseada no Chrome garante que seus PDFs em C# correspondam exatamente às especificações de design, enquanto o suporte assíncrono permite o processamento em escala empresarial.

O seguinte comando inicia sua jornada: Install-Package IronPDF. Com o IronPDF, você pode converter strings HTML, criar PDFs complexos com imagens e tabelas, adicionar números de página, controlar o tamanho da fonte e gerar relatórios em PDF a partir de qualquer fonte de dados. Cada novo documento se beneficia de uma renderização perfeita em pixels, seja na criação de uma página simples com variáveis ​​ou em layouts complexos com múltiplas instâncias de documentos com variáveis.

Comece com o pacote de avaliação gratuita de 30 dias do IronPDF.

Perguntas frequentes

O que é geração dinâmica de PDF em C#?

A geração dinâmica de PDFs em C# refere-se ao processo de criação de documentos PDF em tempo de execução, geralmente usando conteúdo baseado em dados ou modelos personalizados. O IronPDF facilita isso, fornecendo ferramentas robustas para integração perfeita com C# e .NET Framework.

Por que usar o IronPDF para gerar PDFs?

O IronPDF é uma solução líder para geração dinâmica de PDFs graças ao seu poderoso mecanismo de renderização baseado no Chrome, que garante resultados de alta qualidade. Ele se integra perfeitamente com C# e .NET Framework, tornando-o ideal para aplicações web modernas.

Como o IronPDF oferece suporte a desenvolvedores C#?

O IronPDF oferece suporte a desenvolvedores C# ao disponibilizar um conjunto abrangente de recursos para geração dinâmica de PDFs, incluindo a capacidade de criar faturas personalizadas, relatórios baseados em dados e campos de formulário customizados, tudo dentro do ambiente C#.

Quais são os benefícios da renderização baseada no Chrome no IronPDF?

A renderização baseada no Chrome do IronPDF fornece documentos PDF de alta fidelidade que mantêm a integridade de layouts e estilos complexos, garantindo que os PDFs gerados tenham uma aparência consistente em diferentes ambientes.

O IronPDF consegue gerar PDFs a partir de conteúdo HTML?

Sim, o IronPDF pode gerar PDFs a partir de conteúdo HTML, permitindo que desenvolvedores convertam páginas da web, strings HTML ou modelos em documentos PDF de qualidade profissional.

O IronPDF é compatível com o .NET Framework?

O IronPDF é totalmente compatível com o .NET Framework, tornando-se uma ferramenta versátil para desenvolvedores que trabalham nesse ambiente, permitindo a geração dinâmica de PDFs.

Que tipos de documentos podem ser criados usando o IronPDF?

Com o IronPDF, os desenvolvedores podem criar uma ampla variedade de documentos, incluindo faturas personalizadas, relatórios baseados em dados e campos de formulário customizados, todos gerados dinamicamente a partir de aplicativos C#.

O IronPDF suporta PDFs em vários idiomas?

Sim, o IronPDF suporta a geração de PDFs multilíngues, permitindo que os desenvolvedores criem documentos que atendam a diversos requisitos de idioma.

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