Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Formulario PDF .NET Sdk
USANDO IRONPDF

Cómo crear, llenar y extraer formularios PDF en C# usando un SDK de .NET

Curtis Chau
Curtis Chau
Actualizado:

Los formularios PDF interactivos convierten documentos estáticos en herramientas de recopilación de datos que puede generar y procesar completamente en código. Ya sea para crear portales de admisión de pacientes, automatizar solicitudes de préstamos o generar miles de formularios de cumplimiento previamente completados desde una base de datos, IronPDF ofrece a los desarrolladores de .NET una API única y consistente para cada tarea de formulario: creación, población de campos, extracción de datos y procesamiento masivo.

Esta guía recorre cada una de esas tareas con ejemplos de código C# funcionales que puede incorporar directamente a un proyecto .NET 10.

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 1 - IronPDF

¿Cómo empezar a utilizar IronPDF?

IronPDF está disponible en NuGet y lleva aproximadamente un minuto agregarlo a cualquier proyecto .NET . Abra la consola del gestor de paquetes en Visual Studio y ejecute:

Install-Package IronPdf
Install-Package IronPdf
SHELL

También puede buscar IronPDF en la GUI del Administrador de paquetes NuGet o agregarlo desde la CLI de .NET con dotnet add package IronPdf. No se requieren dependencias de tiempo de ejecución adicionales ni archivos de configuración: la biblioteca viene con todo lo que necesita para renderizar archivos PDF en Windows, Linux, macOS, Docker y Kubernetes.

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 3 - Instalación

El paquete está destinado a .NET Framework 4.6.2+ y todas las versiones modernas de .NET , incluidas .NET 8, .NET 9 y .NET 10. Una vez instalado el paquete, agregue using IronPdf; en la parte superior de su archivo y estará listo para generar su primer formulario PDF.

La flexibilidad de implementación multiplataforma es importante en los entornos de producción. IronPDF se ejecuta de manera consistente independientemente de si su aplicación apunta a Windows Server, un contenedor de Linux o una aplicación de función de Azure: el mismo código produce el mismo resultado en todos los entornos.

¿Qué hace que los formularios PDF funcionen? Entendiendo AcroForms

Antes de escribir código, es útil comprender lo que estás construyendo. La especificación AcroForm , parte del estándar PDF desde 1998, define campos de formulario interactivos que cualquier visor de PDF estándar puede mostrar y completar. AcroForms admite campos de texto, casillas de verificación, botones de opción, listas desplegables, cuadros de lista y campos de firma.

AcroForms es el formato que IronPDF crea y lee. A diferencia de los formularios XFA (un formato antiguo y propietario de Adobe), AcroForms funciona en Adobe Reader, visores de PDF basados ​​en navegador y aplicaciones móviles sin problemas de compatibilidad. Cuando crea formularios PDF con IronPDF, el resultado es un PDF AcroForm compatible con los estándares que cualquier espectador puede abrir.

Cada campo de formulario lleva un nombre, un tipo y un valor. El nombre es la clave que utiliza al leer o escribir datos mediante programación. Los nombres de los campos deben ser únicos dentro de un documento: si completa un formulario por nombre y el nombre del campo no coincide exactamente, la escritura silenciosa no tiene efecto, lo que es una fuente común de errores al completar formularios desde un esquema de base de datos.

Los tipos de campo determinan qué valores se aceptan. Los campos de texto aceptan cualquier cadena. Las casillas de verificación aceptan "Sí" o "No". Los botones de radio aceptan el valor de cadena de la opción seleccionada. Los menús desplegables aceptan el valor de cadena del elemento seleccionado, que debe ser una de las opciones definidas cuando se creó el campo.

¿Cómo crear un formulario PDF a partir de HTML?

La forma más rápida de crear un formulario PDF rellenable es escribirlo como HTML estándar y convertirlo. Cada elemento de formulario HTML se asigna directamente a su equivalente AcroForm: <input type="text"> se convierte en un campo de texto, <input type="checkbox"> se convierte en una casilla de verificación, <select> se convierte en un menú desplegable y <textarea> se convierte en un campo de texto de varias líneas.

Habilite la creación de formularios configurando CreatePdfFormsFromHtml = true en el RenderingOptions del renderizador. Sin esa bandera, los elementos del formulario HTML se representan como contenido visual estático: puedes verlos en el PDF, pero no son campos interactivos.

using IronPdf;

// HTML with form elements for PDF generation
string formHtml = @"
<html>
<body>
    <h2>Customer Registration</h2>
    <form>
        <label>Full Name:</label><br/>
        <input type='text' name='fullName'><br/>
        <label>Email Address:</label><br/>
        <input type='email' name='email'><br/>
        <label>Account Type:</label><br/>
        <select name='accountType'>
            <option value='personal'>Personal</option>
            <option value='business'>Business</option>
        </select><br/>
        <label>Newsletter:</label><br/>
        <input type='checkbox' name='newsletter' value='yes'>Subscribe<br/>
        <label>Comments:</label><br/>
        <textarea name='comments' rows='4' style='width:300px'></textarea>
    </form>
</body>
</html>";

// Enable form field generation from HTML
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

// Render and save the PDF with interactive fields
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("registration-form.pdf");
using IronPdf;

// HTML with form elements for PDF generation
string formHtml = @"
<html>
<body>
    <h2>Customer Registration</h2>
    <form>
        <label>Full Name:</label><br/>
        <input type='text' name='fullName'><br/>
        <label>Email Address:</label><br/>
        <input type='email' name='email'><br/>
        <label>Account Type:</label><br/>
        <select name='accountType'>
            <option value='personal'>Personal</option>
            <option value='business'>Business</option>
        </select><br/>
        <label>Newsletter:</label><br/>
        <input type='checkbox' name='newsletter' value='yes'>Subscribe<br/>
        <label>Comments:</label><br/>
        <textarea name='comments' rows='4' style='width:300px'></textarea>
    </form>
</body>
</html>";

// Enable form field generation from HTML
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

// Render and save the PDF with interactive fields
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("registration-form.pdf");
$vbLabelText   $csharpLabel

El atributo name de cada entrada HTML se convierte en el nombre del campo en el PDF. Ese nombre es el que utilizarás más adelante cuando leas o escribas valores de campo mediante programación. Elija nombres que coincidan con su modelo de datos: si va a completar este formulario desde un objeto de base de datos, nombre los campos según las propiedades del objeto.

Resultado

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 4 - Salida PDF

Las entradas de texto y las áreas de texto se representan como campos de texto editables. Los botones de opción con atributos name coincidentes se agrupan de modo que solo se puede seleccionar uno. Las casillas de verificación se representan como campos alternables. El PDF resultante se abre en cualquier visor estándar con todos los campos de formulario listos para completar.

Este enfoque basado en HTML funciona bien cuando los diseños de formularios ya existen como páginas web, cuando su equipo prefiere mantener los formularios en marcado o cuando necesita generar formularios que coincidan con precisión con las plantillas HTML existentes de su aplicación. El renderizador maneja todos los detalles de la especificación PDF.

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 5 - Características

¿Cómo agregar campos de formulario a un PDF mediante programación?

Cuando se requiere un control preciso de coordenadas o cuando se agregan campos de formulario a un documento PDF existente, la API de campo de formulario programático le brinda control directo sobre la posición, el tamaño y el valor predeterminado de cada campo.

Crear objetos de campo con coordenadas de página explícitas. El origen (0, 0) está en la esquina inferior izquierda de la página, con x aumentando hacia la derecha e y aumentando hacia arriba: el mismo sistema de coordenadas utilizado en toda la especificación PDF.

using IronPdf;
using IronSoftware.Forms;

// Generate a base PDF document to add fields to
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(
    "<h1>Application Form</h1><p>Please complete all fields below.</p>");

// Text field: name, default value, page index, x, y, width, height
var nameField = new TextFormField("applicantName", "", 0, 50, 700, 200, 20);
pdf.Form.Add(nameField);

// Checkbox field with default unchecked state
var termsCheckbox = new CheckboxFormField("agreeTerms", "no", 0, 50, 650, 15, 15);
pdf.Form.Add(termsCheckbox);

// Dropdown with a defined list of options
var departmentCombo = new ComboboxFormField(
    "department", "", 0, 50, 600, 150, 20,
    new List<string> { "Engineering", "Marketing", "Sales", "Support" });
pdf.Form.Add(departmentCombo);

// Save the output document
pdf.SaveAs("application-with-fields.pdf");
using IronPdf;
using IronSoftware.Forms;

// Generate a base PDF document to add fields to
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(
    "<h1>Application Form</h1><p>Please complete all fields below.</p>");

// Text field: name, default value, page index, x, y, width, height
var nameField = new TextFormField("applicantName", "", 0, 50, 700, 200, 20);
pdf.Form.Add(nameField);

// Checkbox field with default unchecked state
var termsCheckbox = new CheckboxFormField("agreeTerms", "no", 0, 50, 650, 15, 15);
pdf.Form.Add(termsCheckbox);

// Dropdown with a defined list of options
var departmentCombo = new ComboboxFormField(
    "department", "", 0, 50, 600, 150, 20,
    new List<string> { "Engineering", "Marketing", "Sales", "Support" });
pdf.Form.Add(departmentCombo);

// Save the output document
pdf.SaveAs("application-with-fields.pdf");
$vbLabelText   $csharpLabel

TextFormField crea una entrada de texto de una sola línea. CheckboxFormField coloca una casilla de verificación alternable. ComboboxFormField crea un menú desplegable restringido a la lista de opciones proporcionada. Cada clase expone propiedades adicionales para configurar el orden de tabulación, el texto de la información sobre herramientas, el estado de solo lectura y los indicadores de campos obligatorios.

Ambos enfoques (conversión HTML y creación de campos programáticos) se pueden combinar. Genere el diseño base desde HTML para un control eficiente de la plantilla, luego agregue campos especializados con posicionamiento preciso utilizando la API. La guía para completar y editar formularios cubre la gama completa de tipos de campos disponibles.

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 6 - PDF Forms .NET SDK - IronPDF

¿Cómo rellenar un formulario PDF existente?

Muchos flujos de trabajo comienzan con un formulario PDF preexistente: una plantilla gubernamental, un contrato con un proveedor o una aplicación estandarizada que su organización recibe de sus socios. Al completar estos formularios mediante programación, podrá automatizar la generación de documentos sin recrear el diseño original.

Cargue el PDF existente con PdfDocument.FromFile, ubique cada campo por su nombre usando FindFormField y asigne un valor a la propiedad Value del campo.

using IronPdf;

// Load the existing PDF containing AcroForm fields
PdfDocument pdf = PdfDocument.FromFile("existing-application.pdf");

// Fill text fields by exact field name
var nameField = pdf.Form.FindFormField("applicantName");
nameField.Value = "Sarah Johnson";

var emailField = pdf.Form.FindFormField("email");
emailField.Value = "sarah.johnson@example.com";

// Set checkbox and radio button values
var termsField = pdf.Form.FindFormField("agreeTerms");
termsField.Value = "Yes";

var accountTypeField = pdf.Form.FindFormField("accountType");
accountTypeField.Value = "business";

// Set dropdown selection to one of its defined options
var departmentField = pdf.Form.FindFormField("department");
departmentField.Value = "Engineering";

// Save the completed form
pdf.SaveAs("completed-application.pdf");
using IronPdf;

// Load the existing PDF containing AcroForm fields
PdfDocument pdf = PdfDocument.FromFile("existing-application.pdf");

// Fill text fields by exact field name
var nameField = pdf.Form.FindFormField("applicantName");
nameField.Value = "Sarah Johnson";

var emailField = pdf.Form.FindFormField("email");
emailField.Value = "sarah.johnson@example.com";

// Set checkbox and radio button values
var termsField = pdf.Form.FindFormField("agreeTerms");
termsField.Value = "Yes";

var accountTypeField = pdf.Form.FindFormField("accountType");
accountTypeField.Value = "business";

// Set dropdown selection to one of its defined options
var departmentField = pdf.Form.FindFormField("department");
departmentField.Value = "Engineering";

// Save the completed form
pdf.SaveAs("completed-application.pdf");
$vbLabelText   $csharpLabel

FindFormField localiza los campos por el nombre asignado durante la creación del formulario. La coincidencia de nombres de campo distingue entre mayúsculas y minúsculas y es exacta: "applicantName" y "ApplicantName" son campos diferentes. Si está completando un formulario de terceros y no está seguro de los nombres de los campos, itere pdf.Form para imprimir el nombre de cada campo antes de intentar completarlo por nombre.

Entrada

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 7 - Entrada de PDF de muestra

Resultado

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 8 - Salida de PDF rellenable

Los diferentes tipos de campos requieren formatos de valores apropiados. Los campos de texto aceptan cualquier cadena. Las casillas de verificación aceptan "Sí" o "No". Los botones de radio aceptan el valor de cadena de la opción deseada. Los menús desplegables aceptan el valor de cadena de una de las opciones definidas: establecer un valor que no esté en la lista de opciones no tiene efecto.

Al procesar formularios con muchos campos, itere sobre pdf.Form directamente en lugar de llamar a FindFormField repetidamente. La iteración es más eficiente para operaciones masivas y evita búsquedas lineales repetidas a través de la colección de campos.

¿Cómo leer y extraer datos de campos de formulario?

La extracción de datos de formularios de archivos PDF enviados es la operación inversa: cargar un formulario completo, luego leer el nombre de cada campo y el valor actual para el procesamiento posterior. Este patrón potencia los flujos de trabajo de admisión automatizados donde los usuarios completan un formulario PDF, lo cargan y la aplicación procesa los datos sin ingreso manual de datos.

using IronPdf;

// Load the completed, submitted PDF form
PdfDocument pdf = PdfDocument.FromFile("submitted-form.pdf");

// Iterate all fields to extract names, values, and types
Console.WriteLine("Form Data Extraction:");
Console.WriteLine("----------------------");
foreach (var field in pdf.Form)
{
    Console.WriteLine($"Field: {field.Name}");
    Console.WriteLine($"Value: {field.Value}");
    Console.WriteLine($"Type:  {field.GetType().Name}");
    Console.WriteLine();
}

// Or retrieve specific fields for targeted processing
var customerName  = pdf.Form.FindFormField("applicantName")?.Value ?? "Not provided";
var customerEmail = pdf.Form.FindFormField("email")?.Value ?? "Not provided";
Console.WriteLine($"Customer: {customerName} ({customerEmail})");
using IronPdf;

// Load the completed, submitted PDF form
PdfDocument pdf = PdfDocument.FromFile("submitted-form.pdf");

// Iterate all fields to extract names, values, and types
Console.WriteLine("Form Data Extraction:");
Console.WriteLine("----------------------");
foreach (var field in pdf.Form)
{
    Console.WriteLine($"Field: {field.Name}");
    Console.WriteLine($"Value: {field.Value}");
    Console.WriteLine($"Type:  {field.GetType().Name}");
    Console.WriteLine();
}

// Or retrieve specific fields for targeted processing
var customerName  = pdf.Form.FindFormField("applicantName")?.Value ?? "Not provided";
var customerEmail = pdf.Form.FindFormField("email")?.Value ?? "Not provided";
Console.WriteLine($"Customer: {customerName} ({customerEmail})");
$vbLabelText   $csharpLabel

La propiedad Form expone una colección enumerable de todos los campos del documento. Cada objeto de campo proporciona su Name, su Value actual y la información de tipo. Los procesadores de formularios genéricos utilizan este patrón para manejar cualquier estructura de formulario PDF sin nombres de campo codificados.

Resultado

PDF Forms .NET SDK: crear archivos PDF rellenables en C# con IronPDF: Imagen 9 - Salida de consola

El operador condicional nulo ?. en FindFormField maneja casos donde un campo esperado está ausente: es útil cuando se procesan formularios de múltiples fuentes que pueden tener estructuras de campo ligeramente diferentes. Proporcione siempre un valor de respaldo o una verificación nula en lugar de asumir que el campo existe.

Los datos extraídos se integran directamente con Entity Framework o ADO .NET para escrituras en bases de datos, serialización JSON para respuestas de API y generación de CSV para informes. Combine IronPDF con IronOCR cuando también necesite extraer datos de envíos de formularios escaneados o basados ​​en imágenes donde los campos no se completaron digitalmente.

¿Cómo generar formularios personalizados a escala?

El caso de uso más común para la automatización de formularios PDF es la generación por lotes: se generan cientos o miles de formularios precargados con datos de una base de datos, una API o un archivo CSV. Un simple bucle gestiona esto sin necesidad de infraestructura adicional.

using IronPdf;

// Retrieve customer records from your data source
var customers = GetCustomersFromDatabase();

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

foreach (var customer in customers)
{
    // Build an HTML template with static data pre-filled and interactive fields for user input
    string formHtml = $@"
    <html><body>
        <h2>Annual Review Form</h2>
        <p>Customer: {customer.Name}</p>
        <p>Account:  {customer.AccountNumber}</p>
        <label>Satisfaction Rating (1-5):</label><br/>
        <input type='text' name='rating' maxlength='1'><br/>
        <label>Feedback:</label><br/>
        <textarea name='feedback' rows='5' style='width:100%'></textarea>
    </body></html>";

    PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
    pdf.SaveAs($"review-form-{customer.AccountNumber}.pdf");
}
using IronPdf;

// Retrieve customer records from your data source
var customers = GetCustomersFromDatabase();

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

foreach (var customer in customers)
{
    // Build an HTML template with static data pre-filled and interactive fields for user input
    string formHtml = $@"
    <html><body>
        <h2>Annual Review Form</h2>
        <p>Customer: {customer.Name}</p>
        <p>Account:  {customer.AccountNumber}</p>
        <label>Satisfaction Rating (1-5):</label><br/>
        <input type='text' name='rating' maxlength='1'><br/>
        <label>Feedback:</label><br/>
        <textarea name='feedback' rows='5' style='width:100%'></textarea>
    </body></html>";

    PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
    pdf.SaveAs($"review-form-{customer.AccountNumber}.pdf");
}
$vbLabelText   $csharpLabel

La plantilla HTML integra directamente datos estáticos del cliente, de modo que el destinatario ve su nombre y número de cuenta preimpresos y proporciona campos interactivos para los datos que necesita proporcionar. El procesamiento por lotes de cientos de registros se completa en segundos en lugar de las horas que requeriría la preparación manual.

La estructura de bucle funciona con cualquier fuente de datos: consultas de Entity Framework , respuestas de API o importaciones CSV. Cada iteración produce un PDF completo, listo para distribuir y personalizado para ese registro. Para escenarios de alto rendimiento, utilice await con Task.WhenAll para renderizar formularios en paralelo: el método RenderHtmlAsPdfAsync de IronPDF admite la renderización completamente asincrónica.

Después de la generación del lote, los formularios generalmente se empaquetan en un archivo ZIP para su distribución mediante IronZIP , se envían mediante integración de correo electrónico, se cargan al almacenamiento en la nube o se enrutan a una plataforma de firma electrónica para su finalización vinculante.

¿Cómo aplanar o bloquear formularios PDF una vez completados?

Una vez que un formulario está completamente completado y validado, a menudo es necesario bloquearlo para que los valores ya no se puedan editar. El aplanamiento convierte todos los campos de formulario interactivos en contenido visual estático y no editable, conservando al mismo tiempo la apariencia exacta del formulario completo.

using IronPdf;

// Load a completed, signed form
PdfDocument pdf = PdfDocument.FromFile("completed-application.pdf");

// Flatten all form fields - converts interactive fields to static content
pdf.Form.Flatten();

// Save the locked, non-editable version
pdf.SaveAs("locked-application.pdf");
using IronPdf;

// Load a completed, signed form
PdfDocument pdf = PdfDocument.FromFile("completed-application.pdf");

// Flatten all form fields - converts interactive fields to static content
pdf.Form.Flatten();

// Save the locked, non-editable version
pdf.SaveAs("locked-application.pdf");
$vbLabelText   $csharpLabel

El aplanamiento es el enfoque correcto para archivar formularios completados, generar documentos compatibles con PDF/A para almacenamiento a largo plazo y producir copias finales para distribución. Después de aplanar, los datos del formulario aún son visibles pero no se pueden modificar. La guía de aplanamiento en PDF cubre opciones de aplanamiento adicionales, incluido el aplanamiento de campo selectivo.

Para escenarios que requieren una finalización legalmente vinculante, IronPDF también admite firmas digitales , que vinculan criptográficamente la identidad del firmante al documento. Las firmas digitales y el aplanamiento de formularios cumplen diferentes propósitos: las firmas prueban la autenticidad y el aplanamiento evita la modificación.

¿Cuales son tus próximos pasos?

Los formularios PDF en .NET cubren cuatro operaciones principales: crear formularios desde HTML o a través de la API, completar formularios existentes a partir de fuentes de datos, extraer datos enviados y generar por lotes copias personalizadas a escala. IronPDF maneja los cuatro a través de una API consistente, con el mismo código ejecutándose en Windows, Linux, macOS y dentro de contenedores.

La guía práctica para crear formularios PDF cubre todos los tipos de campos disponibles con ejemplos de código. La guía Completar y editar formularios profundiza en las actualizaciones de campos masivos, los grupos de botones de opción y el manejo de cuadros de lista. El centro de documentación de IronPDF proporciona la referencia completa de API y temas avanzados que incluyen formularios de varias páginas, validación de campos de formulario y ajuste del rendimiento para canalizaciones de gran volumen.

Comience una prueba gratuita para explorar las capacidades del formulario PDF en su propio proyecto o revise las opciones de licencia para la implementación de producción.

PDF Forms .NET SDK: Cree archivos PDF rellenables en C# con IronPDF: Imagen 10 - Licencias

Preguntas Frecuentes

¿Qué estándar de formulario PDF utiliza IronPDF?

IronPDF crea y lee AcroForms, el estándar de formularios interactivos definido en la especificación PDF desde 1998. AcroForms son soportados por Adobe Reader, visores PDF basados en navegador y aplicaciones móviles, a diferencia del formato XFA más antiguo que tiene compatibilidad limitada.

¿Cómo habilitas la creación de campos de formulario desde HTML en IronPDF?

Establece `renderer.RenderingOptions.CreatePdfFormsFromHtml = true` antes de llamar a `RenderHtmlAsPdf`. Sin este indicador, los elementos del formulario HTML se renderizan como contenido visual estático en lugar de campos interactivos AcroForm.

¿Cómo completas un campo específico en un formulario PDF existente?

Carga el PDF con `PdfDocument.FromFile`, llama a `pdf.Form.FindFormField("fieldName")` para recuperar el objeto del campo, luego asigna una cadena a su propiedad `Value`. La coincidencia de nombres de campo distingue entre mayúsculas y minúsculas. Ahorra el resultado con `pdf.SaveAs`.

¿Cómo extraes todos los valores de los campos de un PDF enviado?

Itera sobre `pdf.Form` con `foreach (var field in pdf.Form)` y lee las propiedades `Name` y `Value` de cada campo. Para extracción dirigida, usa `pdf.Form.FindFormField("name")?.Value` con el operador null-conditional para manejar campos faltantes de forma segura.

¿Puede IronPDF generar cientos de formularios de una base de datos en un bucle?

Sí. Crea un `ChromePdfRenderer` con `CreatePdfFormsFromHtml = true`, itera sobre tus registros de datos, construye una cadena HTML por registro, llama a `RenderHtmlAsPdf`, y guarda cada resultado. Para un alto rendimiento, usa `RenderHtmlAsPdfAsync` con `Task.WhenAll` para renderizado paralelo.

¿Qué hace aplanar un formulario PDF?

Aplanar convierte todos los campos de formulario interactivos en contenido visual estático no editable mientras preserva la apariencia exacta del formulario completado. Llama a `pdf.Form.Flatten()` luego guarda. El resultado es adecuado para archivo, conformidad con PDF/A, y distribución donde debe evitarse la edición de campos.

¿Funciona IronPDF en Linux y en contenedores Docker?

Sí. IronPDF se ejecuta en Windows, Linux, macOS, Docker, y Kubernetes. El mismo código C# produce la misma salida PDF en todas las plataformas. Consulta las guías de IronPDF Linux y Docker en la documentación para la configuración específica de la plataforma.

¿Qué plataformas y versiones de .NET soporta IronPDF para formularios PDF?

IronPDF soporta .NET Framework 4.6.2 y superiores, y todas las versiones modernas de .NET incluyendo .NET 6, .NET 7, .NET 8, .NET 9, y .NET 10. También soporta aplicaciones ASP.NET, ASP.NET Core, Blazor Server, Azure Functions, y MAUI.

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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me