Í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 em C#
USANDO O IRONPDF

Como gerar PDFs dinamicamente em C# usando o IronPDF

Curtis Chau
Curtis Chau
Atualizado:

O IronPDF permite a criação dinâmica de PDFs em C# convertendo conteúdo HTML em PDFs em tempo de execução usando renderização baseada no Chrome. Isso possibilita a criação de documentos personalizados com dados variáveis ​​provenientes de bancos de dados, APIs ou entradas do usuário para faturas, relatórios e formulários em aplicativos .NET .

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, ferramentas confiáveis ​​são essenciais para gerar documentos PDF em tempo real. O IronPDF é uma solução líder que oferece renderização eficiente baseada no Chrome para criar documentos PDF com integração perfeita com C# para geração dinâmica de PDFs em ambientes .NET .

O banner promocional da biblioteca IronPDF C# para PDF demonstra os principais recursos: conversão de HTML para PDF, API de edição de PDF, opções de implantação na nuvem e oferta de avaliação gratuita

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

A geração dinâmica de PDFs em C# envolve a criação de documentos PDF em tempo de execução, utilizando dados variáveis ​​provenientes de 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 por dados. Essas funcionalidades são essenciais para faturas, relatórios em PDF , certificados e formulários que se adaptam às necessidades em constante mudança. Essa abordagem tornou-se crucial para aplicações modernas .NET e .NET Core . A documentação do IronPDF fornece guias completos para implementar esses recursos em seus aplicativos C#.

Gráfico de compatibilidade multiplataforma do IronPDF mostrando suporte para várias versões do .NET , linguagens de programação, sistemas operacionais e ambientes de implantação, incluindo plataformas em nuvem

Quando você deve usar a geração dinâmica de PDFs?

A geração dinâmica de PDFs é essencial quando sua aplicação requer documentos personalizados que se alteram com base em dados do usuário ou lógica de negócios. Os cenários comuns incluem a geração de relatórios mensais com atualizações automáticas de dados, a criação de faturas com informações específicas do cliente, a emissão de certificados com nomes de destinatários exclusivos e a criação de formulários que são preenchidos automaticamente com base nos perfis do usuário. Se o seu conteúdo varia a cada solicitação ou requer integração de dados em tempo real, a geração dinâmica é mais eficaz do que modelos estáticos. Considere o processamento assíncrono para cenários de alto volume e explore técnicas de otimização de desempenho para aplicações empresariais.

O que diferencia os PDFs dinâmicos dos PDFs estáticos?

Os PDFs estáticos permanecem inalterados após a sua criação, de forma semelhante aos documentos em papel tradicionais salvos digitalmente. Os PDFs dinâmicos geram conteúdo novo sempre que são solicitados, utilizando dados de fontes em tempo real. Por exemplo, um catálogo de produtos estático requer atualizações e redistribuição manuais, enquanto um catálogo dinâmico inclui automaticamente os preços mais recentes, os níveis de estoque e as descrições dos produtos. Os PDFs dinâmicos também podem incluir elementos interativos, conteúdo condicional e layouts personalizados com base nas preferências do usuário ou nas permissões de acesso. Saiba mais sobre os recursos de segurança de PDF para aprimorar seus documentos dinâmicos.

Quais setores se beneficiam mais com a geração dinâmica de PDFs?

Os serviços financeiros utilizam PDFs dinâmicos para extratos de conta, documentos de empréstimo e relatórios regulatórios que exigem precisão em tempo real. Os profissionais de saúde geram registros de pacientes, resultados de exames laboratoriais e formulários de seguro com segurança em conformidade com a HIPAA. As plataformas de comércio eletrônico criam confirmações de pedidos, etiquetas de envio e autorizações de devolução. Instituições de ensino produzem históricos escolares, certificados e materiais de aprendizagem personalizados. Órgãos governamentais simplificam pedidos de licenças, formulários fiscais e documentos de conformidade por meio da geração automatizada. As demonstrações do IronPDF mostram implementações reais em diversos setores.

Como começar a usar uma biblioteca PDF em C#?

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

Install-Package IronPdf
Install-Package IronPdf
SHELL 
dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Janela do Console do Gerenciador de Pacotes exibindo o processo de instalação do pacote NuGet IronPDF , mostrando vários downloads de dependências e seus respectivos tamanhos de arquivo

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 PDFs 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.

Quais são os requisitos de sistema para o IronPDF?

O IronPDF é compatível com ambientes Windows, Linux e macOS com .NET Framework 4.6.2 ou superior, ou .NET Core 3.1 ou superior. Para implantação no Windows, certifique-se de que o Visual C++ Runtime esteja instalado. Os sistemas Linux requerem a biblioteca libgdiplus e outras dependências. Os contêineres Docker precisam de imagens base específicas com bibliotecas gráficas. Plataformas em nuvem como o Azure exigem o nível B1 ou superior, enquanto as funções do AWS Lambda precisam de tempos de execução personalizados. Consulte o guia de instalação para obter informações sobre os requisitos específicos da plataforma e dicas de resolução de problemas.

Como configurar o ChromePdfRenderer para obter os melhores resultados?

Melhore a renderização com estas configurações essenciais:

using IronPdf;

var renderer = new ChromePdfRenderer();

// Set paper size and orientation
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;

// Configure margins (in millimeters)
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;

// Enable JavaScript execution
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.RenderDelay = 500; // milliseconds

// Set custom CSS media type
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Configure image quality
renderer.RenderingOptions.ImageQuality = 90;
using IronPdf;

var renderer = new ChromePdfRenderer();

// Set paper size and orientation
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;

// Configure margins (in millimeters)
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;

// Enable JavaScript execution
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.RenderDelay = 500; // milliseconds

// Set custom CSS media type
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Configure image quality
renderer.RenderingOptions.ImageQuality = 90;
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Set paper size and orientation
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait

' Configure margins (in millimeters)
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20

' Enable JavaScript execution
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.RenderDelay = 500 ' milliseconds

' Set custom CSS media type
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

' Configure image quality
renderer.RenderingOptions.ImageQuality = 90
$vbLabelText   $csharpLabel

O RenderDelay permite que o JavaScript complete a execução antes da renderização. A seleção do tipo de mídia CSS garante a aplicação de estilos otimizados para impressão. As configurações de qualidade de imagem equilibram o tamanho do arquivo com a fidelidade visual. Explore opções avançadas de renderização para requisitos específicos, como tamanhos de papel personalizados ou configurações de viewport. Aprenda sobre renderização em JavaScript para geração de conteúdo dinâmico.

Quais são os problemas comuns de instalação aos quais você deve estar atento?

A falta de dependências é a causa da maioria dos problemas de instalação. Não Windows, instale os Pacotes Redistribuíveis do Visual C++. Usuários de Linux devem instalar o libgdiplus e os pacotes de fontes. As implementações do Docker exigem imagens base específicas com suporte gráfico. O Azure Functions exige que os planos de consumo estejam desativados. Verifique as configurações do firewall para validação da licença. Analise cenários comuns de resolução de problemas e ative o registro de logs para diagnósticos detalhados.

Como criar documentos PDF dinamicamente usando modelos?

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

using IronPdf;
using System.Text;

var renderer = new ChromePdfRenderer();

// Define HTML string template with placeholders
string invoiceTemplate = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .header { background-color: #f0f0f0; padding: 20px; }
        table { width: 100%; border-collapse: collapse; }
        th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
    </style>
</head>
<body>
    <div class='header'>
        <h1>Invoice #[[INVOICE_NUMBER]]</h1>
        <p>Date: [[DATE]]</p>
        <p>Customer: [[CUSTOMER_NAME]]</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</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.Nãow.ToString("yyyy-MM-dd"),
    CustomerName = "John Doe",
    Total = 1250.00m
};

// Build items dynamically
var itemsHtml = new StringBuilder();
itemsHtml.Append("<tr><td>Web Development</td><td>40 hours</td><td>$1000.00</td></tr>");
itemsHtml.Append("<tr><td>Design Services</td><td>10 hours</td><td>$250.00</td></tr>");

string finalHtml = invoiceTemplate
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber)
    .Replace("[[DATE]]", invoiceData.Date)
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName)
    .Replace("[[ITEMS]]", itemsHtml.ToString())
    .Replace("[[TOTAL]]", invoiceData.Total.ToString());

// Generate PDF from populated HTML content
var pdf = renderer.RenderHtmlAsPdf(finalHtml);
pdf.SaveAs("invoice.pdf");
using IronPdf;
using System.Text;

var renderer = new ChromePdfRenderer();

// Define HTML string template with placeholders
string invoiceTemplate = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .header { background-color: #f0f0f0; padding: 20px; }
        table { width: 100%; border-collapse: collapse; }
        th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
    </style>
</head>
<body>
    <div class='header'>
        <h1>Invoice #[[INVOICE_NUMBER]]</h1>
        <p>Date: [[DATE]]</p>
        <p>Customer: [[CUSTOMER_NAME]]</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</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.Nãow.ToString("yyyy-MM-dd"),
    CustomerName = "John Doe",
    Total = 1250.00m
};

// Build items dynamically
var itemsHtml = new StringBuilder();
itemsHtml.Append("<tr><td>Web Development</td><td>40 hours</td><td>$1000.00</td></tr>");
itemsHtml.Append("<tr><td>Design Services</td><td>10 hours</td><td>$250.00</td></tr>");

string finalHtml = invoiceTemplate
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber)
    .Replace("[[DATE]]", invoiceData.Date)
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName)
    .Replace("[[ITEMS]]", itemsHtml.ToString())
    .Replace("[[TOTAL]]", invoiceData.Total.ToString());

// Generate PDF from populated HTML content
var pdf = renderer.RenderHtmlAsPdf(finalHtml);
pdf.SaveAs("invoice.pdf");
Imports IronPdf
Imports System.Text

Dim renderer As New ChromePdfRenderer()

' Define HTML string template with placeholders
Dim invoiceTemplate As String = "
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .header { background-color: #f0f0f0; padding: 20px; }
        table { width: 100%; border-collapse: collapse; }
        th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
    </style>
</head>
<body>
    <div class='header'>
        <h1>Invoice #[[INVOICE_NUMBER]]</h1>
        <p>Date: [[DATE]]</p>
        <p>Customer: [[CUSTOMER_NAME]]</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</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.0D
}

' Build items dynamically
Dim itemsHtml As New StringBuilder()
itemsHtml.Append("<tr><td>Web Development</td><td>40 hours</td><td>$1000.00</td></tr>")
itemsHtml.Append("<tr><td>Design Services</td><td>10 hours</td><td>$250.00</td></tr>")

Dim finalHtml As String = invoiceTemplate _
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber) _
    .Replace("[[DATE]]", invoiceData.Date) _
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName) _
    .Replace("[[ITEMS]]", itemsHtml.ToString()) _
    .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 marcadores de posição por valores em 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 técnicas avançadas de modelagem, incluindo estilização CSS e integração com JavaScript .

Saída

PDF viewer showing a generated invoice with number INV-2025-001, displaying customer details and a total of $1250.00, with Iron Software watermarks visible

Por que usar a geração de PDFs baseada em modelos?

A geração baseada em modelos separa a lógica de negócios da apresentação, permitindo fluxos de trabalho de desenvolvimento paralelos. Os designers podem aperfeiçoar os layouts HTML usando ferramentas familiares, enquanto os desenvolvedores implementam a vinculação de dados. Os modelos oferecem suporte a controle de versão, testes A/B e localização sem alterações de código. Componentes reutilizáveis ​​reduzem a duplicação e os custos de manutenção. As consultas de mídia CSS garantem que os designs responsivos sejam perfeitamente traduzidos para a saída em PDF. Essa abordagem se adapta desde cartas simples até relatórios complexos com várias páginas, mantendo uma identidade visual consistente. Explore técnicas de marca d'água para atender às suas necessidades de identidade visual.

Como lidar com estruturas de dados complexas em modelos?

Processar dados hierárquicos construindo seções HTML programaticamente antes da injeção do modelo. Utilize consultas LINQ para transformar coleções em tabelas ou listas HTML. Implemente a renderização condicional com instruções if que incluam ou excluam seções do modelo. Para dados aninhados, crie submodelos que construam o conteúdo recursivamente. Considere usar a sintaxe Razor para lógica complexa dentro de modelos. A serialização JSON permite passar dados estruturados para modelos aprimorados com JavaScript. Crie métodos auxiliares que convertam objetos de domínio em fragmentos HTML para uma organização de código mais limpa.

Quais são as melhores práticas para o design de espaços reservados em modelos?

Escolha uma sintaxe de marcador de posição distinta que não entre em conflito com HTML ou CSS, como [[FIELD_NAME]] ou {{field}}. Utilize nomes descritivos que indiquem os tipos de dados e as expectativas de formatação. Agrupe marcadores de posição relacionados com prefixos (CUSTOMER_NAME, CUSTOMER_EMAIL). Documente os espaços reservados disponíveis e suas fontes de dados para referência da equipe. Implemente valores alternativos para campos opcionais para evitar erros de renderização. Considere a codificação HTML para conteúdo gerado pelo usuário a fim de evitar ataques de injeção. Crie métodos de validação de modelo que verifiquem se todos os espaços reservados possuem valores de dados correspondentes.

Como escalar a geração de PDFs com processamento assíncrono?

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

using IronPdf;

// Async batch generation for multiple PDF documents
async Task GenerateMonthlyReportsAsync(List<Customer> customers)
{
    var renderer = new ChromePdfRenderer();

    // Configure for batch processing
    renderer.RenderingOptions.EnableJavaScript = false; // Faster without JS
    renderer.RenderingOptions.RenderDelay = 0;

    var semaphore = new SemaphoreSlim(5); // Limit concurrent operations
    var tasks = new List<Task>();

    foreach (var customer in customers)
    {
        tasks.Add(Task.Run(async () =>
        {
            await semaphore.WaitAsync();
            try
            {
                string html = $@"
                    <html>
                    <head>
                        <style>
                            body {{ font-family: Arial; margin: 40px; }}
                            .header {{ color: #333; border-bottom: 2px solid #4CAF50; }}
                            .metric-box {{
                                display: inline-block;
                                padding: 20px;
                                margin: 10px;
                                background: #f5f5f5;
                                border-radius: 5px;
                            }}
                        </style>
                    </head>
                    <body>
                        <div class='header'>
                            <h2>Monthly Report - {customer.Name}</h2>
                            <p>Report Period: {DateTime.Nãow:MMMM yyyy}</p>
                        </div>
                        <div class='metrics'>
                            <div class='metric-box'>
                                <h3>Account Balance</h3>
                                <p style='font-size: 24px; color: #4CAF50;'>${customer.Balance:F2}</p>
                            </div>
                            <div class='metric-box'>
                                <h3>Total Transactions</h3>
                                <p style='font-size: 24px; color: #2196F3;'>{customer.TransactionCount}</p>
                            </div>
                        </div>
                        <div style='page-break-after: always;'></div>
                    </body>
                    </html>";

                var document = await renderer.RenderHtmlAsPdfAsync(html);

                // Add metadata
                document.MetaData.Author = "Reporting System";
                document.MetaData.Title = $"Monthly Report - {customer.Name}";
                document.MetaData.CreationDate = DateTime.Nãow;

                await document.SaveAs($"reports/{customer.Id}_report_{DateTime.Nãow:yyyyMM}.pdf");
            }
            finally
            {
                semaphore.Release();
            }
        }));
    }

    await Task.WhenAll(tasks);
}
using IronPdf;

// Async batch generation for multiple PDF documents
async Task GenerateMonthlyReportsAsync(List<Customer> customers)
{
    var renderer = new ChromePdfRenderer();

    // Configure for batch processing
    renderer.RenderingOptions.EnableJavaScript = false; // Faster without JS
    renderer.RenderingOptions.RenderDelay = 0;

    var semaphore = new SemaphoreSlim(5); // Limit concurrent operations
    var tasks = new List<Task>();

    foreach (var customer in customers)
    {
        tasks.Add(Task.Run(async () =>
        {
            await semaphore.WaitAsync();
            try
            {
                string html = $@"
                    <html>
                    <head>
                        <style>
                            body {{ font-family: Arial; margin: 40px; }}
                            .header {{ color: #333; border-bottom: 2px solid #4CAF50; }}
                            .metric-box {{
                                display: inline-block;
                                padding: 20px;
                                margin: 10px;
                                background: #f5f5f5;
                                border-radius: 5px;
                            }}
                        </style>
                    </head>
                    <body>
                        <div class='header'>
                            <h2>Monthly Report - {customer.Name}</h2>
                            <p>Report Period: {DateTime.Nãow:MMMM yyyy}</p>
                        </div>
                        <div class='metrics'>
                            <div class='metric-box'>
                                <h3>Account Balance</h3>
                                <p style='font-size: 24px; color: #4CAF50;'>${customer.Balance:F2}</p>
                            </div>
                            <div class='metric-box'>
                                <h3>Total Transactions</h3>
                                <p style='font-size: 24px; color: #2196F3;'>{customer.TransactionCount}</p>
                            </div>
                        </div>
                        <div style='page-break-after: always;'></div>
                    </body>
                    </html>";

                var document = await renderer.RenderHtmlAsPdfAsync(html);

                // Add metadata
                document.MetaData.Author = "Reporting System";
                document.MetaData.Title = $"Monthly Report - {customer.Name}";
                document.MetaData.CreationDate = DateTime.Nãow;

                await document.SaveAs($"reports/{customer.Id}_report_{DateTime.Nãow:yyyyMM}.pdf");
            }
            finally
            {
                semaphore.Release();
            }
        }));
    }

    await Task.WhenAll(tasks);
}
Imports IronPdf
Imports System.Threading

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

    ' Configure for batch processing
    renderer.RenderingOptions.EnableJavaScript = False ' Faster without JS
    renderer.RenderingOptions.RenderDelay = 0

    Dim semaphore As New SemaphoreSlim(5) ' Limit concurrent operations
    Dim tasks As New List(Of Task)()

    For Each customer In customers
        tasks.Add(Task.Run(Async Function()
                               Await semaphore.WaitAsync()
                               Try
                                   Dim html As String = $"
                    <html>
                    <head>
                        <style>
                            body {{ font-family: Arial; margin: 40px; }}
                            .header {{ color: #333; border-bottom: 2px solid #4CAF50; }}
                            .metric-box {{
                                display: inline-block;
                                padding: 20px;
                                margin: 10px;
                                background: #f5f5f5;
                                border-radius: 5px;
                            }}
                        </style>
                    </head>
                    <body>
                        <div class='header'>
                            <h2>Monthly Report - {customer.Name}</h2>
                            <p>Report Period: {DateTime.Now:MMMM yyyy}</p>
                        </div>
                        <div class='metrics'>
                            <div class='metric-box'>
                                <h3>Account Balance</h3>
                                <p style='font-size: 24px; color: #4CAF50;'>${customer.Balance:F2}</p>
                            </div>
                            <div class='metric-box'>
                                <h3>Total Transactions</h3>
                                <p style='font-size: 24px; color: #2196F3;'>{customer.TransactionCount}</p>
                            </div>
                        </div>
                        <div style='page-break-after: always;'></div>
                    </body>
                    </html>"

                                   Dim document = Await renderer.RenderHtmlAsPdfAsync(html)

                                   ' Add metadata
                                   document.MetaData.Author = "Reporting System"
                                   document.MetaData.Title = $"Monthly Report - {customer.Name}"
                                   document.MetaData.CreationDate = DateTime.Now

                                   Await document.SaveAs($"reports/{customer.Id}_report_{DateTime.Now:yyyyMM}.pdf")
                               Finally
                                   semaphore.Release()
                               End Try
                           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 significativamente o desempenho ao gerar documentos PDF em lotes. Task.WhenAll garante que todos os arquivos PDF estejam completos antes de prosseguir. O código 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. O SemaphoreSlim evita o esgotamento da memória limitando as operações simultâneas. Analise a documentação sobre geração assíncrona de PDFs para aplicações web empresariais.

Quando você deve usar a geração assíncrona de PDFs?

O processamento assíncrono é ideal em aplicações web onde operações de bloqueio impactam a experiência do usuário. Utilize métodos assíncronos ao gerar vários documentos simultaneamente, processar arquivos HTML grandes ou integrar-se com APIs externas lentas. Serviços em segundo plano se beneficiam de padrões assíncronos para a geração de relatórios agendados. Os manipuladores de webhook podem processar solicitações sem expirar o tempo limite. Operações em lote, como a emissão de faturas mensais, são concluídas mais rapidamente com o processamento paralelo. Não entanto, a geração simples de um único documento pode não se beneficiar da complexidade adicional.

Como gerenciar o uso de memória durante o processamento em lote?

Implemente padrões de descarte para liberar recursos prontamente. Utilize fluxos de memória em vez de operações de arquivo para armazenamento temporário. Configure a coleta de lixo para cargas de trabalho do servidor. Limitar operações simultâneas com SemaphoreSlim ou mecanismos de limitação semelhantes. Monitore o uso de memória com contadores de desempenho. Considere dividir grandes conjuntos de dados em lotes menores. Comprima os PDFs de saída para reduzir os requisitos de armazenamento. Consulte os guias de otimização de desempenho para obter estratégias adicionais.

Quais métricas de desempenho você deve monitorar?

Monitore o tempo de geração de PDFs por documento para identificar gargalos. Monitore o consumo de memória durante picos de carga. Meça a utilização da CPU durante as operações de renderização. Registre as gerações com falha, incluindo detalhes do erro, para facilitar a resolução de problemas. Calcule a taxa de transferência em documentos por minuto. Monitore a taxa de transferência de armazenamento para detectar restrições de capacidade. Monitore a latência da rede ao renderizar URLs externas. Configure alertas para tempos limite de renderização ou pressão de memória. Utilize o registro personalizado para capturar métricas detalhadas.

Como criar formulários PDF interativos dinamicamente?

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

using IronPdf;

// Enable form fields creation in rendering options
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

// Define HTML string with form elements
string formHtml = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        form { background: #f9f9f9; padding: 30px; border-radius: 8px; }
        h2 { color: #333; margin-bottom: 20px; }
        label { display: block; margin: 15px 0 5px; font-weight: bold; }
        input[type='text'], input[type='email'], textarea, select {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
            box-sizing: border-box;
        }
        textarea { height: 100px; resize: vertical; }
        input[type='checkbox'] { margin-right: 8px; }
        .checkbox-group { margin: 15px 0; }
        button {
            background: #4CAF50;
            color: white;
            padding: 12px 24px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <form>
        <h2>Customer Survey Form</h2>

        <label for='name'>Full Name:</label>
        <input type='text' id='name' name='name' required>

        <label for='email'>Email Address:</label>
        <input type='email' id='email' name='email' required>

        <label for='satisfaction'>Overall Satisfaction:</label>
        <select id='satisfaction' name='satisfaction'>
            <option value=''>Please select...</option>
            <option value='excellent'>Excellent</option>
            <option value='good'>Good</option>
            <option value='fair'>Fair</option>
            <option value='poor'>Poor</option>
        </select>

        <div class='checkbox-group'>
            <label>Services Used:</label>
            <label><input type='checkbox' name='services' value='support'> Technical Support</label>
            <label><input type='checkbox' name='services' value='training'> Training</label>
            <label><input type='checkbox' name='services' value='consulting'> Consulting</label>
        </div>

        <label for='comments'>Additional Comments:</label>
        <textarea id='comments' name='comments' placeholder='Share your feedback...'></textarea>

        <button type='submit'>Submit Survey</button>
    </form>
</body>
</html>";

// Create a PDF with interactive form fields
var pdfDocument = renderer.RenderHtmlAsPdf(formHtml);

// Set form field properties programmatically
var formManager = pdfDocument.Form;
formManager.FindField("name").Value = "";
formManager.FindField("email").Required = true;

// Save the interactive PDF
pdfDocument.SaveAs("customer_survey_form.pdf");
using IronPdf;

// Enable form fields creation in rendering options
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

// Define HTML string with form elements
string formHtml = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        form { background: #f9f9f9; padding: 30px; border-radius: 8px; }
        h2 { color: #333; margin-bottom: 20px; }
        label { display: block; margin: 15px 0 5px; font-weight: bold; }
        input[type='text'], input[type='email'], textarea, select {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
            box-sizing: border-box;
        }
        textarea { height: 100px; resize: vertical; }
        input[type='checkbox'] { margin-right: 8px; }
        .checkbox-group { margin: 15px 0; }
        button {
            background: #4CAF50;
            color: white;
            padding: 12px 24px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <form>
        <h2>Customer Survey Form</h2>

        <label for='name'>Full Name:</label>
        <input type='text' id='name' name='name' required>

        <label for='email'>Email Address:</label>
        <input type='email' id='email' name='email' required>

        <label for='satisfaction'>Overall Satisfaction:</label>
        <select id='satisfaction' name='satisfaction'>
            <option value=''>Please select...</option>
            <option value='excellent'>Excellent</option>
            <option value='good'>Good</option>
            <option value='fair'>Fair</option>
            <option value='poor'>Poor</option>
        </select>

        <div class='checkbox-group'>
            <label>Services Used:</label>
            <label><input type='checkbox' name='services' value='support'> Technical Support</label>
            <label><input type='checkbox' name='services' value='training'> Training</label>
            <label><input type='checkbox' name='services' value='consulting'> Consulting</label>
        </div>

        <label for='comments'>Additional Comments:</label>
        <textarea id='comments' name='comments' placeholder='Share your feedback...'></textarea>

        <button type='submit'>Submit Survey</button>
    </form>
</body>
</html>";

// Create a PDF with interactive form fields
var pdfDocument = renderer.RenderHtmlAsPdf(formHtml);

// Set form field properties programmatically
var formManager = pdfDocument.Form;
formManager.FindField("name").Value = "";
formManager.FindField("email").Required = true;

// Save the interactive PDF
pdfDocument.SaveAs("customer_survey_form.pdf");
Imports IronPdf

' Enable form fields creation in rendering options
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True

' Define HTML string with form elements
Dim formHtml As String = "
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        form { background: #f9f9f9; padding: 30px; border-radius: 8px; }
        h2 { color: #333; margin-bottom: 20px; }
        label { display: block; margin: 15px 0 5px; font-weight: bold; }
        input[type='text'], input[type='email'], textarea, select {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
            box-sizing: border-box;
        }
        textarea { height: 100px; resize: vertical; }
        input[type='checkbox'] { margin-right: 8px; }
        .checkbox-group { margin: 15px 0; }
        button {
            background: #4CAF50;
            color: white;
            padding: 12px 24px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <form>
        <h2>Customer Survey Form</h2>

        <label for='name'>Full Name:</label>
        <input type='text' id='name' name='name' required>

        <label for='email'>Email Address:</label>
        <input type='email' id='email' name='email' required>

        <label for='satisfaction'>Overall Satisfaction:</label>
        <select id='satisfaction' name='satisfaction'>
            <option value=''>Please select...</option>
            <option value='excellent'>Excellent</option>
            <option value='good'>Good</option>
            <option value='fair'>Fair</option>
            <option value='poor'>Poor</option>
        </select>

        <div class='checkbox-group'>
            <label>Services Used:</label>
            <label><input type='checkbox' name='services' value='support'> Technical Support</label>
            <label><input type='checkbox' name='services' value='training'> Training</label>
            <label><input type='checkbox' name='services' value='consulting'> Consulting</label>
        </div>

        <label for='comments'>Additional Comments:</label>
        <textarea id='comments' name='comments' placeholder='Share your feedback...'></textarea>

        <button type='submit'>Submit Survey</button>
    </form>
</body>
</html>"

' Create a PDF with interactive form fields
Dim pdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Set form field properties programmatically
Dim formManager = pdfDocument.Form
formManager.FindField("name").Value = ""
formManager.FindField("email").Required = True

' Save the interactive PDF
pdfDocument.SaveAs("customer_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 simplifica os fluxos de trabalho, eliminando formulários em papel, ao mesmo tempo que mantém os padrões familiares de desenvolvimento em HTML. O objeto PdfDocument fornece acesso para manipular campos de formulário programaticamente. Aprenda sobre manipulação de formulários PDF para implementações avançadas.

Saída

Visualizador de PDF exibindo um formulário de pesquisa de satisfação do cliente com campos para nome, e-mail, menu suspenso de satisfação definido como 'Excelente' e seção de comentários, com marcas d'água da Iron Software visíveis

Quais elementos de formulário HTML são suportados?

O IronPDF suporta todos os elementos padrão de formulário HTML, incluindo campos de texto, áreas de texto, caixas de seleção, botões de opção, listas suspensas e botões. Os campos de senha são convertidos em entradas de texto seguras. Os campos de entrada para upload de arquivos se tornam espaços reservados para anexos. Os campos ocultos preservam os dados do formulário sem exibi-los. Os tipos de entrada HTML5, como email, tel e number, mantêm regras de validação. O estilo personalizado aplica-se à aparência do formulário. Consulte a documentação dos formulários para obter informações sobre os comportamentos e limitações específicos de cada elemento.

Como validar os dados de um formulário em PDF?

Implemente a validação no lado do cliente usando JavaScript antes da geração do PDF. Defina os atributos obrigatórios nos campos do formulário para validação integrada. Utilize expressões regulares para correspondência de padrões em entradas de texto. Configure intervalos numéricos para campos numéricos. Adicione scripts de validação personalizados a formulários PDF usando JavaScript do Acrobat. Implemente a validação no servidor ao processar os formulários enviados. Considere o uso de assinaturas digitais para garantir a inviolabilidade dos documentos enviados.

É possível preencher campos de formulário dinamicamente?

Acesse os campos do formulário através da propriedade Form após a renderização. Defina os valores dos campos usando FindField("fieldName").Value. Preencher a partir de bancos de dados ou respostas de API. Crie modelos com valores padrão. Suporte à geração em massa de formulários com dados exclusivos por PDF. Ative os cálculos nos campos do formulário para valores computados. Considere as implicações de segurança dos dados sensíveis preenchidos previamente. Aprenda sobre gerenciamento de campos de formulário para cenários complexos.

Como se comparam as bibliotecas .NET para PDF em termos de geração dinâmica?

Ao escolher uma biblioteca PDF for .NET, os principais fatores a serem considerados são a precisão da renderização, o design da API, o suporte à plataforma e o licenciamento. A tabela abaixo compara o IronPDF com duas alternativas amplamente utilizadas.

IronPDF vs. Outras Bibliotecas PDF .NET
Recurso IronPDF iTextSharp wkhtmltopdf
Motor de renderização Chromium (versão mais recente) Motor de layout personalizado WebKit (sem manutenção)
Suporte a HTML/CSS CSS3/JS moderno completo CSS parcial CSS3 limitado
API assíncrona Sim Não Não
Formulários interativos Sim (a partir do HTML) Somente API manual Não
Assinaturas digitais Sim Sim Não
Conformidade com PDF/A Sim Sim Não
Multiplataforma Windows, Linux, macOS Windows, Linux, macOS Windows, Linux, macOS
Apoio comercial Suporte dedicado 24 horas por dia, 5 dias por semana. Fóruns da comunidade Nenhum
Tipo de licença Comercial AGPL / Comercial LGPL (gratuito)

O mecanismo de renderização Chrome do IronPDF garante precisão perfeita em cada pixel na criação de PDFs, eliminando as limitações das soluções de renderização WebKit mais antigas. Ao contrário das alternativas de código aberto que exigem executáveis ​​externos ou configurações de navegador sem interface gráfica, o IronPDF se integra diretamente ao seu projeto .NET sem nenhuma dependência adicional. Compare o IronPDF com o iText para entender as diferenças em detalhes.

Visão geral dos recursos do IronPDF exibindo quatro categorias principais: Criar PDFs, Converter PDFs, Editar PDFs e Assinar e proteger PDFs, com listas detalhadas de funcionalidades em cada categoria sobre um fundo roxo escuro.

Quais são as principais vantagens do IronPDF para a geração dinâmica de PDFs?

Os recursos avançados incluem marca d'água, assinaturas digitais, criação de formulários, conformidade com PDF/A e criptografia. A integração com o .NET oferece suporte a todos os tipos de projeto, desde aplicativos de console até Funções do Azure. A compatibilidade entre plataformas garante resultados consistentes no Windows, Linux e macOS.

Visão geral dos recursos do IronPDF , destacando três benefícios principais: renderização perfeita em pixels com suporte a HTML/CSS/JS de nível Chromium, configuração em 5 minutos via gerenciador de pacotes e compatibilidade multiplataforma com Windows, Linux, macOS e serviços em nuvem.

Como funciona o licenciamento do IronPDF ?

O licenciamento começa em $799 para licenças de desenvolvedor individual, com opções disponíveis para equipes e empresas. Cada pacote oferece vantagens exclusivas, e o investimento se paga por si só através 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 ideal para o seu projeto.

Bibliotecas gratuitas geralmente carecem de suporte comercial, o que é crucial para aplicações de produção. As alternativas de código aberto podem ter restrições de licenciamento AGPL incompatíveis com o uso comercial. O IronPDF oferece licenciamento flexível para todos os cenários de implantação, desde projetos de startups até implementações corporativas.

IronPDF licensing page displaying four pricing tiers (Lite $749, Plus $999, Professional $1,999, and Unlimited $3,999) with developer, location, and project limits for each tier

Quais são os próximos passos para a geração dinâmica de PDFs em C#?

A geração dinâmica de PDFs em C# altera a forma como os aplicativos entregam documentos personalizados em tempo de execução. O IronPDF fornece ferramentas essenciais para criar 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 correspondam exatamente às especificações de design, enquanto o suporte assíncrono permite o processamento em larga escala. Consulte os tutoriais para obter orientações passo a passo sobre como implementar esses recursos.

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 ou de layouts complexos com múltiplas instâncias de documentos.

Comece com o teste gratuito de 30 dias do IronPDF para experimentar esses recursos. Explore a documentação completa, revise as referências de namespace na documentação da API e estude exemplos de código para acelerar seus projetos de geração de arquivos PDF. Para necessidades adicionais de processamento de documentos, incluindo manipulação de Excel e OCR , considere o pacote IronSuite .

Perguntas frequentes

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

A geração dinâmica de PDFs em C# envolve a criação programática de documentos PDF em tempo de execução, permitindo conteúdo personalizado como faturas, relatórios e formulários.

Como o IronPDF ajuda na geração dinâmica de PDFs?

O IronPDF oferece recursos avançados de renderização baseados no Chrome, que permitem uma integração perfeita com C# para criar documentos PDF dinâmicos com eficiência.

O IronPDF pode ser usado com o .NET Framework?

Sim, o IronPDF é totalmente compatível com o .NET Framework, o que o torna uma ferramenta robusta para geração dinâmica de PDFs nesse ambiente.

Quais são os casos de uso para a geração dinâmica de PDFs?

A geração dinâmica de PDFs é útil para criar faturas personalizadas, relatórios baseados em dados e campos de formulário customizados em aplicações web modernas.

Por que a renderização baseada no Chrome é importante na geração de PDFs?

A renderização baseada no Chrome garante uma aparência consistente e de alta qualidade aos documentos, além de oferecer suporte aos padrões e estilos modernos da web na geração de PDFs.

O IronPDF é adequado para criar relatórios em PDF baseados em dados?

Sim, o IronPDF é ideal para criar relatórios em PDF orientados a dados, permitindo que os desenvolvedores integrem dados dinamicamente em seus documentos PDF.

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