Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Usando o ironpdf
  4. Imprimir formulário em PDF em C#
USANDO O IRONPDF

C# Imprimir Formulário para PDF Usando IronPDF

Curtis Chau
Curtis Chau
Atualizado:

Imprimir um formulário do Windows em PDF em C# é simples com o IronPDF: renderize a representação HTML do formulário usando ChromePdfRenderer, salve em disco ou na memória e obtenha um PDF perfeito em pixels com apenas algumas linhas de código.

Exportar um aplicativo Windows Forms para PDF é um requisito comum em softwares de gestão empresarial. Seja para arquivar telas de entrada de dados, gerar relatórios para clientes a partir do estado de um formulário ou capturar pré-visualizações de impressão sem precisar ir à impressora, converter um formulário C# para PDF elimina os atritos dos fluxos de trabalho diários. O IronPDF fornece uma API nativa do .NET que lida com o pipeline de conversão, desde a renderização HTML até a saída final em PDF, permitindo que você ignore as frágeis soluções alternativas de impressão com GDI+.

Como instalar o IronPDF?

Adicione o IronPDF ao seu projeto através do NuGet. Abra o Console do Gerenciador de Pacotes e execute:

Install-Package IronPdf
Install-Package IronPdf
SHELL

Ou utilize a CLI do .NET :

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Após a instalação, adicione using IronPdf; no início de qualquer arquivo que chame a API. O pacote também está disponível diretamente em NuGet.org/packages/ IronPDF . Uma chave de licença de avaliação gratuita está disponível em IronPDF para desbloquear a saída sem marca d'água durante o período de avaliação.

Como converter um formulário do Windows em PDF usando HTML?

O método mais confiável para converter um formulário C# em PDF é criar um instantâneo HTML dos dados do formulário e renderizar esse instantâneo com ChromePdfRenderer. Essa abordagem desacopla a renderização visual da interface GDI+ do WinForms, proporcionando uma saída nítida e portátil com aparência idêntica em todos os visualizadores de PDF.

using IronPdf;

// Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY";

// Compose an HTML representation of your form data
string formHtml = $"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class="box">
            <div class="row"><label>Full Name:</label> Jane Smith</div>
            <div class="row"><label>Email:</label> jane@example.com</div>
            <div class="row"><label>Phone:</label> +1 555-0100</div>
            <div class="row"><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    """;

// Render HTML to PDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize       = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop       = 20;
renderer.RenderingOptions.MarginBottom    = 20;
renderer.RenderingOptions.MarginLeft      = 25;
renderer.RenderingOptions.MarginRight     = 25;
renderer.RenderingOptions.CssMediaType    = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("CustomerForm.pdf");

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).");
using IronPdf;

// Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY";

// Compose an HTML representation of your form data
string formHtml = $"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class="box">
            <div class="row"><label>Full Name:</label> Jane Smith</div>
            <div class="row"><label>Email:</label> jane@example.com</div>
            <div class="row"><label>Phone:</label> +1 555-0100</div>
            <div class="row"><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    """;

// Render HTML to PDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize       = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop       = 20;
renderer.RenderingOptions.MarginBottom    = 20;
renderer.RenderingOptions.MarginLeft      = 25;
renderer.RenderingOptions.MarginRight     = 25;
renderer.RenderingOptions.CssMediaType    = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("CustomerForm.pdf");

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).");
Imports IronPdf

' Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY"

' Compose an HTML representation of your form data
Dim formHtml As String = $"
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset='utf-8'>
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class='box'>
            <div class='row'><label>Full Name:</label> Jane Smith</div>
            <div class='row'><label>Email:</label> jane@example.com</div>
            <div class='row'><label>Phone:</label> +1 555-0100</div>
            <div class='row'><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    "

' Render HTML to PDF
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)
pdf.SaveAs("CustomerForm.pdf")

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).")
$vbLabelText   $csharpLabel

O ChromePdfRenderer controla um mecanismo Chromium sem interface gráfica, de modo que os layouts CSS, as fontes incorporadas e até mesmo as consultas de mídia de impressão são renderizados fielmente. Substitua os valores de campo fixos por dados vinculados aos controles do seu formulário em tempo de execução para uma abordagem totalmente dinâmica. O guia prático de conversão de HTML para PDF aborda detalhadamente todas as opções de renderização disponíveis.

Como extrair dados em tempo real de controles de formulário?

Em vez de codificar o HTML manualmente, leia os valores diretamente dos seus controles WinForms e insira-os no modelo:

using IronPdf;

// Called from a button click handler in your WinForms application
void ExportFormToPdf()
{
    // Read control values at the moment of export
    string name    = txtName.Text;
    string email   = txtEmail.Text;
    string phone   = txtPhone.Text;
    string notes   = rtbNotes.Text.Replace("\n", "<br>");

    string html = $"""
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        """;

    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

    // Prompt the user for a save location
    using var dialog = new SaveFileDialog();
    dialog.Filter   = "PDF Files|*.pdf";
    dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";

    if (dialog.ShowDialog() == DialogResult.OK)
    {
        pdf.SaveAs(dialog.FileName);
        MessageBox.Show("PDF exported successfully.", "Export Complete");
    }
}
using IronPdf;

// Called from a button click handler in your WinForms application
void ExportFormToPdf()
{
    // Read control values at the moment of export
    string name    = txtName.Text;
    string email   = txtEmail.Text;
    string phone   = txtPhone.Text;
    string notes   = rtbNotes.Text.Replace("\n", "<br>");

    string html = $"""
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        """;

    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

    // Prompt the user for a save location
    using var dialog = new SaveFileDialog();
    dialog.Filter   = "PDF Files|*.pdf";
    dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";

    if (dialog.ShowDialog() == DialogResult.OK)
    {
        pdf.SaveAs(dialog.FileName);
        MessageBox.Show("PDF exported successfully.", "Export Complete");
    }
}
Imports IronPdf

' Called from a button click handler in your WinForms application
Sub ExportFormToPdf()
    ' Read control values at the moment of export
    Dim name As String = txtName.Text
    Dim email As String = txtEmail.Text
    Dim phone As String = txtPhone.Text
    Dim notes As String = rtbNotes.Text.Replace(vbLf, "<br>")

    Dim html As String = $"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        "

    Dim renderer As New ChromePdfRenderer()
    Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)

    ' Prompt the user for a save location
    Using dialog As New SaveFileDialog()
        dialog.Filter = "PDF Files|*.pdf"
        dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf"

        If dialog.ShowDialog() = DialogResult.OK Then
            pdf.SaveAs(dialog.FileName)
            MessageBox.Show("PDF exported successfully.", "Export Complete")
        End If
    End Using
End Sub
$vbLabelText   $csharpLabel

Este trecho de código trata a exportação do formulário como uma mini-tarefa de relatório: coleta os valores dos campos, os incorpora em um modelo HTML, renderiza e, em seguida, salva no local escolhido pelo usuário. Você pode estender a tabela HTML com tantos campos quantos o formulário contiver. Para formulários com várias abas, crie blocos <section> separados para cada aba e deixe o IronPDF paginar automaticamente.

Como adicionar cabeçalhos e rodapés?

Cabeçalhos e rodapés aprimoram a exportação de um formulário para uso profissional. A classe TextHeaderFooter do IronPDF insere texto no início e no final de cada página sem alterar o HTML do corpo:

using IronPdf;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Stamp header and footer on every page
pdf.AddTextHeaders(new TextHeaderFooter
{
    CenterText      = "Confidential -- Internal Use Only",
    LeftText        = "{date}",
    RightText       = "Page {page} of {total-pages}",
    FontSize        = 9,
    DrawDividerLine = true
});

pdf.AddTextFooters(new TextHeaderFooter
{
    CenterText = "Generated by MyApp v2.0",
    FontSize   = 8
});

pdf.SaveAs("FormWithHeader.pdf");
using IronPdf;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Stamp header and footer on every page
pdf.AddTextHeaders(new TextHeaderFooter
{
    CenterText      = "Confidential -- Internal Use Only",
    LeftText        = "{date}",
    RightText       = "Page {page} of {total-pages}",
    FontSize        = 9,
    DrawDividerLine = true
});

pdf.AddTextFooters(new TextHeaderFooter
{
    CenterText = "Generated by MyApp v2.0",
    FontSize   = 8
});

pdf.SaveAs("FormWithHeader.pdf");
Imports IronPdf
Imports IronPdf.Rendering

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Stamp header and footer on every page
pdf.AddTextHeaders(New TextHeaderFooter With {
    .CenterText = "Confidential -- Internal Use Only",
    .LeftText = "{date}",
    .RightText = "Page {page} of {total-pages}",
    .FontSize = 9,
    .DrawDividerLine = True
})

pdf.AddTextFooters(New TextHeaderFooter With {
    .CenterText = "Generated by MyApp v2.0",
    .FontSize = 8
})

pdf.SaveAs("FormWithHeader.pdf")
$vbLabelText   $csharpLabel

Tokens dinâmicos como {page}, {total-pages} e {date} são resolvidos automaticamente no momento da renderização. Para uma saída personalizada com a marca, substitua TextHeaderFooter por HtmlHeaderFooter e forneça a marcação HTML completa, incluindo os logotipos da empresa. O guia prático de cabeçalhos e rodapés mostra todos os tokens e opções de layout disponíveis.

Como converter um formulário em uma matriz de bytes em vez de um arquivo?

Salvar diretamente no disco é conveniente, mas muitas aplicações precisam transmitir o PDF via HTTP, armazená-lo em um banco de dados ou passá-lo para um serviço subsequente. Nesses casos, ignore o arquivo e trabalhe com os bytes brutos:

using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Get raw bytes -- no file required
byte[] pdfBytes = pdf.BinaryData;

// Alternatively, get a MemoryStream for APIs that accept streams
using System.IO.MemoryStream stream = pdf.Stream;
byte[] fromStream = stream.ToArray();

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes");

// Example: return as HTTP response in ASP.NET Core
// return File(pdfBytes, "application/pdf", "form-export.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Get raw bytes -- no file required
byte[] pdfBytes = pdf.BinaryData;

// Alternatively, get a MemoryStream for APIs that accept streams
using System.IO.MemoryStream stream = pdf.Stream;
byte[] fromStream = stream.ToArray();

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes");

// Example: return as HTTP response in ASP.NET Core
// return File(pdfBytes, "application/pdf", "form-export.pdf");
Imports IronPdf
Imports System.IO

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Get raw bytes -- no file required
Dim pdfBytes As Byte() = pdf.BinaryData

' Alternatively, get a MemoryStream for APIs that accept streams
Using stream As MemoryStream = pdf.Stream
    Dim fromStream As Byte() = stream.ToArray()
End Using

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes")

' Example: return as HTTP response in ASP.NET Core
' Return File(pdfBytes, "application/pdf", "form-export.pdf")
$vbLabelText   $csharpLabel

A propriedade BinaryData realiza uma cópia O(1) da matriz de bytes pré-computada. A propriedade Stream retorna um novo MemoryStream que suporta acesso de busca para bibliotecas que esperam entradas de fluxo -- útil ao encadear compressão ou criptografia antes de entregar os bytes finais. Mais detalhes sobre o processamento de PDFs na memória estão disponíveis no guia de fluxo de memória de PDF .

Como aplicar as configurações de segurança antes de salvar?

Os formulários exportados frequentemente contêm dados sensíveis. A API de segurança do IronPDF criptografa o PDF e restringe o que os destinatários podem fazer com ele:

using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Restrict access
pdf.SecuritySettings.OwnerPassword          = "adminSecretKey";
pdf.SecuritySettings.UserPassword           = "viewerPass";
pdf.SecuritySettings.AllowUserPrinting      = true;   // allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = false; // block copy
pdf.SecuritySettings.AllowUserAnnotations   = false;

pdf.SaveAs("SecureForm.pdf");
Console.WriteLine("Password-protected PDF created.");
using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Restrict access
pdf.SecuritySettings.OwnerPassword          = "adminSecretKey";
pdf.SecuritySettings.UserPassword           = "viewerPass";
pdf.SecuritySettings.AllowUserPrinting      = true;   // allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = false; // block copy
pdf.SecuritySettings.AllowUserAnnotations   = false;

pdf.SaveAs("SecureForm.pdf");
Console.WriteLine("Password-protected PDF created.");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Restrict access
pdf.SecuritySettings.OwnerPassword = "adminSecretKey"
pdf.SecuritySettings.UserPassword = "viewerPass"
pdf.SecuritySettings.AllowUserPrinting = True ' allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = False ' block copy
pdf.SecuritySettings.AllowUserAnnotations = False

pdf.SaveAs("SecureForm.pdf")
Console.WriteLine("Password-protected PDF created.")
$vbLabelText   $csharpLabel

Definir uma senha de proprietário permite que os administradores controlem os sinalizadores de permissões, enquanto a senha de usuário restringe totalmente o acesso aos documentos. A flag AllowUserPrinting é particularmente relevante aqui -- você pode permitir que o destinatário reimprima o formulário exportado sem conceder a ele direitos de edição. Todos os detalhes constam no guia em PDF sobre permissões e senhas .

Como comparar as abordagens de impressão para formulários em C#?

A escolha entre a captura de bitmap nativa do WinForms (GDI+) e a renderização HTML do IronPDF depende de compensações em termos de fidelidade, complexidade e portabilidade:

Comparação de abordagens de conversão de formulário para PDF em C#
Abordagem Fidelidade de saída Complexidade do código Multiplataforma Suporte a CSS Ideal para
Driver de impressora PrintDocument + PDF Médio Médio Somente para Windows Nenhum WinForms legado com lógica de impressão existente
Captura de bitmap GDI+ (Control.DrawToBitmap) Alta (raster) Baixo Somente para Windows Nenhum Capturas rápidas no estilo de capturas de tela
Renderização HTML do IronPDF Alto (vetor) Baixo Windows, Linux, macOS, Docker CSS3 completo Exportações profissionais, portáteis e baseadas em dados
Visualizador de Relatórios (RDLC) Alto Alto Somente para Windows Limitado Relatórios paginados complexos com agrupamento

A abordagem baseada em HTML do IronPDF produz PDFs vetoriais que se adaptam perfeitamente a qualquer nível de zoom e imprimem com nitidez em qualquer dispositivo. Como o mecanismo de renderização é o Chromium, as consultas de mídia CSS, os layouts flexbox e as fontes do Google funcionam como esperado — algo que a captura de bitmaps com GDI+ não consegue replicar. A biblioteca também funciona em ambientes Linux e dentro de contêineres Docker , tornando-a a única opção nesta tabela que funciona fora do Windows.

O que acontece quando o formulário tem várias abas?

Formulários WinForms com várias abas são comuns em aplicações empresariais. Como o PDF é gerado a partir de HTML em vez da superfície GDI+ em tempo real, você controla exatamente qual conteúdo da guia aparece. Crie uma seção HTML por aba e concatene-as antes de renderizar. O fluxo de dados parte de strings HTML de abas, passando por ChromePdfRenderer, até um único PDF contínuo de várias páginas — uma seção lógica por aba. Alternativamente, renderize cada aba independentemente e mescle os objetos PdfDocument resultantes com a API de mesclagem do IronPDF .

Como você realiza a validação de formulários antes da exportação?

Exporte apenas dados de formulário válidos. Um padrão de verificação simples impede a geração de PDFs a partir de envios incompletos: valide os campos primeiro e só prossiga para a geração e renderização do HTML quando todos os campos obrigatórios forem aprovados. Se algum campo apresentar falha, destaque o erro na interface do usuário e cancele a exportação. Isso mantém a consistência dos PDFs exportados e evita confusões posteriores devido a dados incompletos. De acordo com a documentação da Microsoft sobre validação do Windows Forms , ErrorProvider é o mecanismo padrão para fornecer feedback de validação em nível de campo antes de qualquer ação.

Como disponibilizar a exportação para PDF a partir do ASP.NET Core?

Formulários web criados com ASP.NET Core podem ser exportados para PDF usando a mesma API ChromePdfRenderer. Os bytes renderizados são retornados diretamente como um arquivo de resultado:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/forms")]
public class FormExportController : ControllerBase
{
    [HttpPost("export")]
    public IActionResult ExportFormAsPdf([FromBody] FormDataModel formData)
    {
        // Build HTML from submitted form data
        string html = $"""
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            """;

        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
        byte[] pdfBytes = pdf.BinaryData;

        string fileName = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdfBytes, "application/pdf", fileName);
    }
}

public record FormDataModel(string FormTitle, string ApplicantName, string ReferenceId);
using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/forms")]
public class FormExportController : ControllerBase
{
    [HttpPost("export")]
    public IActionResult ExportFormAsPdf([FromBody] FormDataModel formData)
    {
        // Build HTML from submitted form data
        string html = $"""
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            """;

        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
        byte[] pdfBytes = pdf.BinaryData;

        string fileName = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdfBytes, "application/pdf", fileName);
    }
}

public record FormDataModel(string FormTitle, string ApplicantName, string ReferenceId);
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/forms")>
Public Class FormExportController
    Inherits ControllerBase

    <HttpPost("export")>
    Public Function ExportFormAsPdf(<FromBody> formData As FormDataModel) As IActionResult
        ' Build HTML from submitted form data
        Dim html As String = $"
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            "

        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

        Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
        Dim pdfBytes As Byte() = pdf.BinaryData

        Dim fileName As String = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf"
        Return File(pdfBytes, "application/pdf", fileName)
    End Function
End Class

Public Class FormDataModel
    Public Property FormTitle As String
    Public Property ApplicantName As String
    Public Property ReferenceId As String

    Public Sub New(formTitle As String, applicantName As String, referenceId As String)
        Me.FormTitle = formTitle
        Me.ApplicantName = applicantName
        Me.ReferenceId = referenceId
    End Sub
End Class
$vbLabelText   $csharpLabel

Este controlador recebe dados de formulário em formato JSON, gera o PDF na memória e o transmite de volta como um arquivo para download. Nenhum arquivo temporário é criado no servidor. Para aplicações Blazor , a abordagem é semelhante -- chamar o mesmo código de renderização de um serviço e enviar os bytes para o navegador via IJSRuntime. Os padrões completos de integração do ASP.NET estão documentados no guia ASP.NET para PDF .

Que tipo MIME e qual atributo Content-Disposition você deve usar?

Sempre retorne application/pdf como tipo de conteúdo. Use Content-Disposition: inline para exibir o PDF no navegador ou Content-Disposition: attachment para forçar o download. O nome do arquivo aparece na caixa de diálogo de salvar do navegador quando attachment é usado, portanto, escolha um nome significativo que inclua um ID de referência ou uma data.

Como armazenar em cache os PDFs gerados?

Se a mesma exportação de formulário for solicitada repetidamente, armazene em cache a matriz de bytes para evitar a renderização repetida. IMemoryCache funciona para implantações em servidor único; Utilize um cache distribuído, como o Redis, para configurações com múltiplas instâncias. Defina um prazo de validade que esteja de acordo com a frequência com que os dados do formulário subjacente são alterados.

Quais são as melhores práticas para exportar formulários para PDF?

Exportações de formulários consistentes e de alta qualidade provêm de alguns padrões repetíveis:

  • Mantenha o HTML simples. Evite modelos com uso intensivo de JavaScript — HTML e CSS puros são renderizados mais rapidamente e produzem PDFs menores. Habilite RenderingOptions.EnableJavaScript somente quando os cálculos do formulário dependerem dele.
  • Use CSS de impressão. Defina as regras CssMediaType = PdfCssMediaType.Print e @media print em sua folha de estilo. Isso elimina elementos gráficos exclusivos da tela, como barras de navegação e barras laterais, do PDF exportado.
  • Higienize a entrada do usuário. Escape as entidades HTML em qualquer valor de campo que você inserir no modelo para evitar marcação quebrada ou, em casos extremos, injeção de script no PDF.
  • Descartar objetos PdfDocument. Recursos não gerenciados são mantidos até o descarte. Use declarações using ou chame Dispose() explicitamente após salvar.
  • Teste com dados de produção. Formulários com textos longos, caracteres especiais ou imagens incorporadas podem gerar layouts surpreendentes. Execute exportações com base em amostras de dados reais durante o desenvolvimento.

As opções de renderização documentam todas as configurações disponíveis, desde tamanhos de papel personalizados até margens e orientação de página personalizadas.

Como lidar com formulários extensos ou com várias páginas?

O IronPDF pagina automaticamente com base na altura do conteúdo e no tamanho de papel selecionado. Insira page-break-before: always nos contêineres de seção no CSS quando uma nova seção do formulário precisar sempre começar em uma página nova. Para formulários com centenas de campos, a pré-alocação de um MemoryStream com capacidade estimada reduz a pressão do GC durante a cópia do array de bytes.

Como adicionar uma assinatura digital?

Os formulários de exportação assinados têm validade legal em muitas jurisdições. O IronPDF suporta certificados digitais armazenados em arquivos PFX ou em repositórios de certificados do Windows:

// Load the certificate and sign in one step
var signature = new IronPdf.Signing.PdfSignature("certificate.pfx", "certPassword");
pdf.Sign(signature);
pdf.SaveAs("SignedForm.pdf");
// Load the certificate and sign in one step
var signature = new IronPdf.Signing.PdfSignature("certificate.pfx", "certPassword");
pdf.Sign(signature);
pdf.SaveAs("SignedForm.pdf");
Imports IronPdf.Signing

' Load the certificate and sign in one step
Dim signature As New PdfSignature("certificate.pfx", "certPassword")
pdf.Sign(signature)
pdf.SaveAs("SignedForm.pdf")
$vbLabelText   $csharpLabel

De acordo com a visão geral das assinaturas digitais em PDF da Adobe , uma assinatura digital certifica a origem do documento e detecta quaisquer modificações feitas após a assinatura. O guia de assinatura digital em PDF aborda detalhadamente a configuração do certificado e os campos de assinatura visíveis.

Quais são os pontos principais que você deve reter?

Converter um formulário Windows em C# para PDF com o IronPDF se reduz a três etapas: construir uma representação HTML dos dados do formulário, passá-la para ChromePdfRenderer e salvar ou transmitir o resultado. Essa abordagem produz PDFs vetoriais que imprimem com nitidez, funcionam em diversas plataformas e suportam o modelo de layout CSS3 completo — vantagens que a captura de bitmap GDI+ e os métodos legados de drivers de impressão não conseguem igualar.

Principais funcionalidades abordadas neste guia:

  • Renderização de HTML para PDF com ChromePdfRenderer para WinForms e ASP.NET Core
  • Vinculação de dados em tempo real de controles WinForms para modelos HTML
  • Cabeçalhos, rodapés e numeração de páginas com TextHeaderFooter
  • Saída de matriz de bytes na memória via BinaryData para respostas HTTP e armazenamento em banco de dados
  • Configurações de segurança de PDF: senhas de proprietário/usuário e sinalizadores de permissão
  • Anexação de assinatura digital para exportações juridicamente vinculativas

Explore o conjunto de recursos do IronPDF para ver ferramentas de anotação, edição de campos de formulário, conformidade com PDF/A e muito mais. Experimente o IronPDF gratuitamente com uma licença de avaliação de 30 dias e aplique-o ao seu fluxo de trabalho de exportação de formulários hoje mesmo.

Perguntas frequentes

Como posso converter um formulário C# para PDF usando o IronPDF?

Você pode converter um formulário C# para PDF usando o IronPDF, aproveitando sua API intuitiva, que permite lidar com conversões de PDF de forma eficiente sem a necessidade de código complexo.

Por que a conversão de documentos PDF em matrizes de bytes é importante em aplicações .NET?

Converter documentos PDF em matrizes de bytes é importante porque permite o armazenamento de PDFs em bancos de dados, a transmissão por meio de APIs e o manuseio do conteúdo do documento na memória, que são operações críticas em aplicações .NET modernas.

Quais são os benefícios de usar o IronPDF para conversão de matrizes de bytes?

O IronPDF simplifica a conversão de matrizes de bytes, fornecendo uma API fácil de usar que agiliza o processo, reduzindo a necessidade de código complexo e melhorando a eficiência do desenvolvimento.

O IronPDF consegue lidar com a conversão de PDFs na memória?

Sim, o IronPDF consegue lidar com a conversão de PDFs na memória, permitindo que os desenvolvedores gerenciem o conteúdo dos documentos sem precisar salvar os arquivos em disco.

É possível armazenar PDFs em um banco de dados usando o IronPDF?

Sim, você pode armazenar PDFs em um banco de dados convertendo-os em matrizes de bytes usando o IronPDF, o que facilita a integração perfeita com sistemas de banco de dados.

Como o IronPDF auxilia na transmissão de arquivos PDF por meio de APIs?

O IronPDF auxilia na transmissão de arquivos PDF por meio de APIs, permitindo a conversão de PDFs em matrizes de bytes, o que facilita o envio e o recebimento de dados de documentos por meio de protocolos de rede.

O que torna a API do IronPDF intuitiva para desenvolvedores?

A API do IronPDF foi projetada para ser intuitiva para desenvolvedores, fornecendo métodos claros e diretos que simplificam operações complexas em PDFs, aumentando a produtividade e reduzindo a curva de aprendizado.

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