Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Uso de ironpdf
  4. Imprimir formulario a PDF con C#
USANDO IRONPDF

C# Imprimir formulario a PDF usando IronPDF

Curtis Chau
Curtis Chau
Actualizado:

Imprimir un formulario de Windows en PDF en C# es sencillo con IronPDF: renderice la representación HTML del formulario usando ChromePdfRenderer, guárdelo en el disco o la memoria y entregue un PDF con píxeles perfectos en solo unas pocas líneas de código.

Exportar una aplicación de Windows Forms a PDF es un requisito común en el software de línea de negocios. Ya sea que necesite archivar pantallas de ingreso de datos, generar informes para el cliente a partir del estado de un formulario o capturar vistas previas de impresión sin tocar la impresora, convertir un formulario C# a PDF elimina la fricción de los flujos de trabajo cotidianos. IronPDF proporciona una API nativa de .NET que maneja el proceso de conversión desde la representación HTML hasta la salida final en PDF, lo que le permite omitir los frágiles trucos de impresión de GDI+.

¿Cómo se instala IronPDF?

Agregue IronPDF a su proyecto a través de NuGet. Abra la Consola del Administrador de Paquetes y ejecute:

Install-Package IronPdf
Install-Package IronPdf
SHELL

O usa la CLI de .NET:

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Después de la instalación, agregue using IronPdf; en la parte superior de cualquier archivo que llame a la API. El paquete también está disponible directamente en NuGet.org/packages/ IronPDF . Hay una clave de licencia de prueba gratuita disponible en IronPDF para desbloquear la salida sin marca de agua durante la evaluación.

¿Cómo convertir un formulario de Windows a PDF usando HTML?

El método más confiable para convertir un formulario C# a PDF es crear una instantánea HTML de los datos del formulario y renderizar esa instantánea con ChromePdfRenderer. Este enfoque desacopla la representación visual de la superficie GDI+ de WinForms, lo que proporciona una salida nítida y portátil que luce idéntica en todos los visores 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

El ChromePdfRenderer controla un motor Chromium sin interfaz gráfica, por lo que los diseños CSS, las fuentes integradas e incluso las consultas de medios impresos se representan fielmente. Cambie los valores de campo codificados por datos enlazados desde los controles de su formulario en tiempo de ejecución para un enfoque totalmente dinámico. La guía práctica de conversión de HTML a PDF cubre todas las opciones de renderizado disponibles en detalle.

¿Cómo extraer datos en vivo de los controles de formulario?

En lugar de codificar manualmente el HTML, lea los valores directamente desde sus controles WinForms e inyéctelos en la plantilla:

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 fragmento trata la exportación del formulario como un mini trabajo de informe: recopila valores de campo, los integra en una plantilla HTML, los renderiza y luego los guarda donde elija el usuario. Puede ampliar la tabla HTML con tantos campos como contenga el formulario. Para formularios con múltiples pestañas, cree bloques <section> separados por pestaña y deje que IronPDF realice la paginación de forma natural.

¿Cómo agregar encabezados y pies de página?

Los encabezados y pies de página perfeccionan un formulario de exportación para uso profesional. La clase TextHeaderFooter de IronPDF estampa texto en la parte superior e inferior de cada página sin alterar el cuerpo HTML:

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

Los tokens dinámicos como {page}, {total-pages} y {date} se resuelven automáticamente durante el renderizado. Para obtener una salida de marca, cambie TextHeaderFooter por HtmlHeaderFooter y proporcione el marcado HTML completo, incluyendo los logotipos de la empresa. La guía práctica de encabezados y pies de página muestra todas las opciones de diseño y token disponibles.

¿Cómo convertir un formulario en una matriz de bytes en lugar de un archivo?

Guardar directamente en el disco es conveniente, pero muchas aplicaciones necesitan transmitir el PDF por HTTP, almacenarlo en una base de datos o pasarlo a un servicio de bajada. En esos casos, omita el archivo y trabaje con los bytes sin procesar:

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

La propiedad BinaryData realiza una copia O(1) de la matriz de bytes precalculada. La propiedad Stream devuelve un nuevo MemoryStream que admite el acceso buscable para bibliotecas que esperan entradas de flujo, lo cual es útil al encadenar la compresión o el cifrado antes de entregar los bytes finales. Hay más detalles disponibles sobre el manejo de PDF en memoria en la guía de flujo de memoria PDF .

¿Cómo aplicar la configuración de seguridad antes de guardar?

Las exportaciones de formularios a menudo contienen datos confidenciales. La API de seguridad de IronPDF cifra el PDF y restringe lo que los destinatarios pueden hacer con él:

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

Establecer una contraseña de propietario permite a los administradores controlar los permisos, mientras que la contraseña de usuario limita por completo el acceso al documento. La bandera AllowUserPrinting es particularmente relevante aquí: puede permitir que el destinatario vuelva a imprimir el formulario exportado sin darle derechos de edición. Los detalles completos aparecen en la guía de permisos y contraseñas en PDF .

¿Cómo se comparan los enfoques de impresión para formularios C#?

La elección entre el PrintDocument nativo de WinForms, la captura de mapas de bits GDI+ y la representación HTML de IronPDF depende de compensaciones en fidelidad, complejidad y portabilidad:

Comparación de los enfoques de conversión de formularios de C# a PDF
Acercarse Fidelidad de salida Complejidad del código Multiplataforma Soporte CSS Mejor para
Controlador de impresora PrintDocument + PDF Medio Medio Sólo Windows Ninguno WinForms heredados con lógica de impresión existente
Captura de mapa de bits GDI+ (Control.DrawToBitmap) Alto (raster) Bajo Sólo Windows Ninguno Capturas rápidas de estilo captura de pantalla
Renderización HTML en IronPDF Alto (vector) Bajo Windows, Linux, macOS, Docker CSS3 completo Exportaciones profesionales, portátiles y basadas en datos
Visor de informes (RDLC) Alto Alto Sólo Windows Limitado Informes paginados complejos con agrupación

El enfoque basado en HTML de IronPDF produce una salida PDF vectorial que se escala perfectamente a cualquier nivel de zoom y se imprime con gran nitidez en cualquier dispositivo. Dado que el motor de renderizado es Chromium, las consultas de medios CSS, los diseños de Flexbox y las fuentes de Google funcionan correctamente, algo que la captura de mapa de bits de GDI+ no puede replicar. La biblioteca también se ejecuta en entornos Linux y dentro de contenedores Docker , lo que la convierte en la única opción de esta tabla que funciona fuera de Windows.

¿Qué sucede cuando el formulario tiene varias pestañas?

Los WinForms con múltiples pestañas son comunes en las aplicaciones comerciales. Dado que el PDF se genera desde HTML en lugar de desde la superficie GDI+ en vivo, usted controla exactamente qué contenido de pestaña aparece. Construya una sección HTML por pestaña y concatenelas antes de renderizar. El flujo de trabajo fluye desde las cadenas HTML de las pestañas a través de ChromePdfRenderer hasta un único PDF continuo de varias páginas: una sección lógica por pestaña. Como alternativa, represente cada pestaña de forma independiente y fusione los objetos PdfDocument resultantes con la API de fusión de IronPDF .

¿Cómo se gestiona la validación del formulario antes de la exportación?

Exportar únicamente datos de formulario válidos. Un patrón de protección simple evita que se generen archivos PDF a partir de envíos incompletos: valide los campos primero y solo proceda a la generación y representación del HTML cuando se pasen todos los campos requeridos. Si algún campo falla, resalte el error en la interfaz de usuario y cancele la exportación. Esto mantiene la coherencia de los PDF exportados y evita confusiones posteriores a partir de datos parciales. Según la documentación de Microsoft sobre la validación de Windows Forms , ErrorProvider es el mecanismo estándar para la retroalimentación de validación a nivel de campo antes de cualquier acción.

¿Cómo se sirve la exportación de PDF desde ASP.NET Core?

Los formularios web creados con ASP.NET Core se pueden exportar a PDF utilizando la misma API ChromePdfRenderer. Los bytes renderizados se devuelven directamente como resultado de archivo:

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 recibe datos del formulario como JSON, genera el PDF en la memoria y lo transmite como una descarga de archivo. No se crean archivos temporales en el servidor. Para las aplicaciones Blazor , el enfoque es similar: llamar al mismo código de representación desde un servicio y enviar los bytes al navegador a través de IJSRuntime. Los patrones de integración ASP.NET completos están documentados en la guía de ASP.NET a PDF .

¿Qué tipo MIME y disposición de contenido debería utilizar?

Devuelve siempre application/pdf como tipo de contenido. Utilice Content-Disposition: inline para mostrar el PDF en el navegador, o Content-Disposition: attachment para forzar una descarga. El nombre del archivo aparece en el cuadro de diálogo para guardar del navegador cuando se usa attachment, así que elija un nombre significativo que incluya un ID de referencia o una fecha.

¿Cómo almacenar en caché los PDF generados?

Si se solicita repetidamente la misma exportación de formulario, almacene en caché la matriz de bytes para evitar volver a renderizarla. IMemoryCache funciona para implementaciones de servidor único; Utilice un caché distribuido como Redis para configuraciones de múltiples instancias. Establezca una fecha de vencimiento que se alinee con la frecuencia con la que cambian los datos del formulario subyacente.

¿Cuáles son las mejores prácticas para las exportaciones de formularios a PDF?

Las exportaciones de formularios consistentes y de alta calidad provienen de unos pocos patrones repetibles:

  • Mantenga el HTML simple. Evite las plantillas con mucho JavaScript: el HTML y CSS puros se procesan más rápido y generan archivos PDF más pequeños. Habilite RenderingOptions.EnableJavaScript solo cuando los cálculos de formulario dependan de ello.
  • Use CSS de impresión. Establezca CssMediaType = PdfCssMediaType.Print y defina las reglas @media print en su hoja de estilos. Esto elimina el cromo de solo pantalla, como las barras de navegación y las barras laterales del PDF exportado.
  • Sanitizar la entrada del usuario. Escape las entidades HTML en cualquier valor de campo que inyecte en la plantilla para evitar un marcado incorrecto o, en casos extremos, la inyección de scripts en el PDF.
  • Eliminar objetos PdfDocument. Los recursos no administrados se conservan hasta su eliminación. Utilice las declaraciones using o llame a Dispose() explícitamente después de guardar.
  • Pruebe con datos de producción. Los formularios con texto largo, caracteres especiales o imágenes incrustadas pueden generar diseños sorprendentes. Ejecute exportaciones contra muestras de datos reales durante el desarrollo.

Las opciones de renderizado hacen referencia a todas las configuraciones disponibles, desde tamaños de papel personalizados hasta márgenes personalizados y orientación de página .

¿Cómo manejar formularios grandes o de varias páginas?

IronPDF pagina automáticamente según la altura del contenido y el tamaño de papel seleccionado. Inserte page-break-before: always en los contenedores de sección del CSS cuando una nueva sección de formulario siempre debe comenzar en una página nueva. Para formularios con cientos de campos, la preasignación de un MemoryStream con una capacidad estimada reduce la presión del GC durante la copia de la matriz de bytes.

¿Cómo agregar una firma digital?

Las exportaciones de formularios firmados tienen peso legal en muchas jurisdicciones. IronPDF admite certificados digitales almacenados en archivos PFX o almacenes de certificados de 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

Según la descripción general de firmas digitales de Adobe PDF , una firma digital certifica el origen del documento y detecta cualquier modificación realizada después de la firma. La guía de firma digital en PDF cubre la configuración del certificado y los campos de firma visibles en detalle.

¿Qué puntos claves debes tener en cuenta?

La conversión de un formulario de Windows C# a PDF con IronPDF se reduce a tres pasos: crear una representación HTML de los datos del formulario, pasarla a ChromePdfRenderer y guardar o transmitir el resultado. Este enfoque produce archivos PDF vectoriales que se imprimen con nitidez, funcionan en todas las plataformas y admiten el modelo de diseño CSS3 completo: ventajas que la captura de mapas de bits de GDI+ y los métodos de controladores de impresión tradicionales no pueden igualar.

Capacidades clave cubiertas en esta guía:

  • Representación de HTML a PDF con ChromePdfRenderer para WinForms y ASP.NET Core
  • Vinculación de datos en vivo desde controles WinForms a plantillas HTML
  • Encabezados, pies de página y numeración de páginas con TextHeaderFooter
  • Salida de matriz de bytes en memoria a través de BinaryData para respuestas HTTP y almacenamiento de base de datos
  • Configuración de seguridad de PDF: contraseñas de propietario/usuario y marcas de permiso
  • Adjunto firma digital para exportaciones legalmente vinculantes

Explore el conjunto de funciones de IronPDF para ver herramientas de anotación, edición de campos de formulario, compatibilidad con PDF/A y más. Pruebe IronPDF gratis con una licencia de prueba de 30 días y aplíquelo a su propio flujo de trabajo de exportación de formularios hoy mismo.

Preguntas Frecuentes

¿Cómo puedo convertir un formulario C# a PDF usando IronPDF?

Puede convertir un formulario C# a PDF usando IronPDF aprovechando su API intuitiva, que le permite gestionar eficientemente las conversiones de PDF sin código complejo.

¿Por qué es importante convertir documentos PDF a matrices de bytes en aplicaciones .NET?

Convertir documentos PDF a matrices de bytes es importante porque permite el almacenamiento de PDFs en bases de datos, la transmisión a través de APIs y la gestión del contenido de los documentos en memoria, que son operaciones críticas en las aplicaciones modernas de .NET.

¿Cuáles son los beneficios de usar IronPDF para la conversión de matrices de bytes?

IronPDF simplifica la conversión de matrices de bytes al proporcionar una API fácil de usar que agiliza el proceso, reduciendo la necesidad de código complejo y mejorando la eficiencia del desarrollo.

¿Puede IronPDF manejar la conversión de PDF en memoria?

Sí, IronPDF puede manejar la conversión de PDF en memoria, permitiendo a los desarrolladores gestionar el contenido del documento sin necesidad de guardar archivos en disco.

¿Es posible almacenar PDFs en una base de datos usando IronPDF?

Sí, puede almacenar PDFs en una base de datos convirtiéndolos en matrices de bytes usando IronPDF, lo que facilita una integración perfecta con los sistemas de bases de datos.

¿Cómo ayuda IronPDF en la transmisión de archivos PDF a través de APIs?

IronPDF ayuda en la transmisión de archivos PDF a través de APIs habilitando la conversión de PDFs a matrices de bytes, facilitando el envío y recepción de datos de documentos a través de protocolos de red.

¿Qué hace que la API de IronPDF sea intuitiva para los desarrolladores?

La API de IronPDF está diseñada para ser intuitiva para los desarrolladores al proporcionar métodos claros y directos que simplifican operaciones complejas de PDF, mejorando la productividad y reduciendo las curvas de aprendizaje.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame