Como Criar, Preencher e Extrair Formulários PDF em C# Usando um SDK .NET
Os formulários PDF interativos transformam documentos estáticos em ferramentas de coleta de dados que você pode gerar e processar inteiramente em código. Seja para criar portais de cadastro de pacientes, automatizar solicitações de empréstimo ou gerar milhares de formulários de conformidade pré-preenchidos a partir de um banco de dados, o IronPDF oferece aos desenvolvedores .NET uma API única e consistente para todas as tarefas de formulário: criação, preenchimento de campos, extração de dados e processamento em lote.
Este guia descreve cada uma dessas tarefas com exemplos de código C# funcionais que você pode inserir diretamente em um projeto .NET 10.
Como começar a usar o IronPDF?
O IronPDF está disponível no NuGet e leva cerca de um minuto para ser adicionado a qualquer projeto .NET . Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:
Install-Package IronPdfInstall-Package IronPdfVocê também pode pesquisar por IronPDF na GUI do Gerenciador de Pacotes NuGet ou adicioná-lo a partir da CLI do .NET com dotnet add package IronPdf. Não são necessárias dependências de tempo de execução ou arquivos de configuração adicionais - a biblioteca é fornecida com tudo o que precisa para renderizar PDFs no Windows, Linux, macOS, Docker e Kubernetes.
O pacote é compatível com o .NET Framework 4.6.2 ou superior e com todas as versões modernas do .NET , incluindo .NET 8, .NET 9 e .NET 10. Após a instalação, adicione using IronPdf; no início do seu arquivo e você estará pronto para gerar seu primeiro formulário em PDF.
A flexibilidade de implantação multiplataforma é importante em ambientes de produção. O IronPDF funciona de forma consistente, independentemente de sua aplicação ser direcionada ao Windows Server, a um contêiner Linux ou a um Aplicativo de Funções do Azure — o mesmo código produz a mesma saída em todos os ambientes.
O que faz os formulários em PDF funcionarem? Entendendo os AcroForms
Antes de escrever código, é útil entender o que você está construindo. A especificação AcroForm - parte do padrão PDF desde 1998 - define campos de formulário interativos que qualquer visualizador de PDF padrão pode exibir e preencher. Os AcroForms suportam campos de texto, caixas de seleção, botões de opção, listas suspensas, caixas de listagem e campos de assinatura.
Os AcroForms são o formato que o IronPDF cria e lê. Diferentemente dos formulários XFA (um formato proprietário mais antigo da Adobe), os AcroForms funcionam no Adobe Reader, em visualizadores de PDF baseados em navegador e em aplicativos móveis sem problemas de compatibilidade. Ao criar formulários PDF com o IronPDF, o resultado é um PDF AcroForm compatível com os padrões, que pode ser aberto em qualquer visualizador.
Cada campo do formulário possui um nome, um tipo e um valor. O nome é a chave que você usa ao ler ou gravar dados programaticamente. Os nomes dos campos devem ser únicos dentro de um documento - se você preencher um formulário por nome e o nome do campo não corresponder exatamente, a gravação silenciosa não terá efeito, o que é uma fonte comum de erros ao preencher formulários a partir de um esquema de banco de dados.
Os tipos de campo determinam quais valores são aceitos. Os campos de texto aceitam qualquer sequência de caracteres. As caixas de seleção aceitam "Sim" ou "Não". Os botões de opção aceitam o valor de texto da opção selecionada. As listas suspensas aceitam o valor de texto do item selecionado, que deve ser uma das opções definidas quando o campo foi criado.
Como criar um formulário em PDF a partir de HTML?
A maneira mais rápida de criar um formulário PDF preenchível é escrevê-lo em HTML padrão e convertê-lo. Cada elemento de formulário HTML corresponde diretamente ao seu equivalente em AcroForm: <input type="text"> torna-se um campo de texto, <input type="checkbox"> torna-se uma caixa de seleção, <select> torna-se uma lista suspensa e <textarea> torna-se um campo de texto multilinha.
Habilite a criação de formulários definindo CreatePdfFormsFromHtml = true no RenderingOptions do renderizador. Sem essa flag, os elementos de formulário HTML são renderizados como conteúdo visual estático — você pode vê-los no PDF, mas eles não são campos interativos.
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");IRON VB CONVERTER ERROR developers@ironsoftware.comO atributo name de cada campo de entrada HTML torna-se o nome do campo no PDF. Esse nome é o que você usará posteriormente ao ler ou gravar valores de campo programaticamente. Escolha nomes que correspondam ao seu modelo de dados - se você for preencher este formulário a partir de um objeto de banco de dados, nomeie os campos de acordo com as propriedades do objeto.
Saída
Os campos de entrada de texto e as áreas de texto são exibidos como campos de texto editáveis. Os botões de opção com atributos name correspondentes são agrupados de forma que apenas um possa ser selecionado. As caixas de seleção são renderizadas como campos alternáveis. O PDF resultante abre em qualquer visualizador padrão com todos os campos do formulário prontos para preenchimento.
Essa abordagem baseada em HTML funciona bem quando os designs de formulários já existem como páginas da web, quando sua equipe prefere manter os formulários em marcação ou quando você precisa gerar formulários que correspondam precisamente aos modelos HTML existentes do seu aplicativo. O renderizador lida com todos os detalhes das especificações do PDF.
Como adicionar campos de formulário a um PDF programaticamente?
Quando é necessário um controle preciso das coordenadas, ou quando você está adicionando campos de formulário a um documento PDF existente, a API programática de campos de formulário oferece controle direto sobre a posição, o tamanho e o valor padrão de cada campo.
Crie objetos de campo com coordenadas de página explícitas. A origem (0, 0) está no canto inferior esquerdo da página, com x aumentando para a direita e y aumentando para cima - o mesmo sistema de coordenadas usado em toda a especificação do 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");Imports IronPdf
Imports IronSoftware.Forms
' Generate a base PDF document to add fields to
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Application Form</h1><p>Please complete all fields below.</p>")
' Text field: name, default value, page index, x, y, width, height
Dim nameField As New TextFormField("applicantName", "", 0, 50, 700, 200, 20)
pdf.Form.Add(nameField)
' Checkbox field with default unchecked state
Dim termsCheckbox As New CheckboxFormField("agreeTerms", "no", 0, 50, 650, 15, 15)
pdf.Form.Add(termsCheckbox)
' Dropdown with a defined list of options
Dim departmentCombo As New ComboboxFormField("department", "", 0, 50, 600, 150, 20, New List(Of String) From {"Engineering", "Marketing", "Sales", "Support"})
pdf.Form.Add(departmentCombo)
' Save the output document
pdf.SaveAs("application-with-fields.pdf")TextFormField cria uma entrada de texto de linha única. CheckboxFormField coloca uma caixa de seleção alternável. ComboboxFormField cria um menu suspenso restrito à lista de opções fornecida. Cada classe expõe propriedades adicionais para definir a ordem de tabulação, o texto da dica de ferramenta, o estado somente leitura e os indicadores de campos obrigatórios.
Ambas as abordagens - conversão de HTML e criação programática de campos - podem ser combinadas. Gere o layout base a partir de HTML para um controle eficiente do modelo e, em seguida, adicione campos especializados com posicionamento preciso usando a API. O guia de preenchimento e edição de formulários abrange toda a gama de tipos de campos disponíveis.
Como preencher um formulário PDF existente?
Muitos fluxos de trabalho começam com um formulário PDF preexistente – um modelo governamental, um contrato com um fornecedor ou um aplicativo padronizado que sua organização recebe de parceiros. Preencher esses formulários programaticamente permite automatizar a geração de documentos sem recriar o design original.
Carregue o PDF existente com PdfDocument.FromFile, localize cada campo pelo seu nome usando FindFormField e atribua um valor à propriedade Value do 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");Imports IronPdf
' Load the existing PDF containing AcroForm fields
Dim pdf As PdfDocument = PdfDocument.FromFile("existing-application.pdf")
' Fill text fields by exact field name
Dim nameField = pdf.Form.FindFormField("applicantName")
nameField.Value = "Sarah Johnson"
Dim emailField = pdf.Form.FindFormField("email")
emailField.Value = "sarah.johnson@example.com"
' Set checkbox and radio button values
Dim termsField = pdf.Form.FindFormField("agreeTerms")
termsField.Value = "Yes"
Dim accountTypeField = pdf.Form.FindFormField("accountType")
accountTypeField.Value = "business"
' Set dropdown selection to one of its defined options
Dim departmentField = pdf.Form.FindFormField("department")
departmentField.Value = "Engineering"
' Save the completed form
pdf.SaveAs("completed-application.pdf")FindFormField localiza os campos pelo nome atribuído durante a criação do formulário. A correspondência de nomes de campos diferencia maiúsculas de minúsculas e é exata - "applicantName" e "ApplicantName" são campos diferentes. Se você estiver preenchendo um formulário de terceiros e não tiver certeza dos nomes dos campos, itere sobre pdf.Form para imprimir o nome de cada campo antes de tentar preenchê-lo pelo nome.
Entrada
Saída
Diferentes tipos de campos exigem formatos de valores apropriados. Os campos de texto aceitam qualquer sequência de caracteres. As caixas de seleção aceitam "Sim" ou "Não". Os botões de opção aceitam o valor de texto da opção desejada. As listas suspensas aceitam o valor de texto de uma das opções definidas; definir um valor que não esteja na lista de opções não terá efeito.
Ao processar formulários com muitos campos, itere sobre pdf.Form diretamente em vez de chamar FindFormField repetidamente. A iteração é mais eficiente para operações em massa e evita buscas lineares repetidas na coleção de campos.
Como ler e extrair dados de campos de formulário?
Extrair dados de formulários de PDFs enviados é a operação inversa: carregar um formulário preenchido e, em seguida, ler o nome e o valor atual de cada campo para processamento posterior. Esse padrão viabiliza fluxos de trabalho de entrada automatizados, nos quais os usuários preenchem um formulário em PDF, fazem o upload e o aplicativo processa os dados sem a necessidade de entrada manual.
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})");Imports IronPdf
' Load the completed, submitted PDF form
Dim pdf As PdfDocument = PdfDocument.FromFile("submitted-form.pdf")
' Iterate all fields to extract names, values, and types
Console.WriteLine("Form Data Extraction:")
Console.WriteLine("----------------------")
For Each field In pdf.Form
Console.WriteLine($"Field: {field.Name}")
Console.WriteLine($"Value: {field.Value}")
Console.WriteLine($"Type: {field.GetType().Name}")
Console.WriteLine()
Next
' Or retrieve specific fields for targeted processing
Dim customerName As String = If(pdf.Form.FindFormField("applicantName")?.Value, "Not provided")
Dim customerEmail As String = If(pdf.Form.FindFormField("email")?.Value, "Not provided")
Console.WriteLine($"Customer: {customerName} ({customerEmail})")A propriedade Form expõe uma coleção enumerável de todos os campos do documento. Cada objeto de campo fornece suas informações de Name, Value atual e tipo. Os processadores de formulários genéricos usam esse padrão para lidar com qualquer estrutura de formulário PDF sem nomes de campos codificados.
Saída
O operador condicional nulo ?. em FindFormField lida com casos em que um campo esperado está ausente - útil ao processar formulários de múltiplas fontes que podem ter estruturas de campo ligeiramente diferentes. Sempre forneça um valor alternativo ou verifique se o campo é nulo, em vez de presumir que ele existe.
Os dados extraídos integram-se diretamente com o Entity Framework ou .NET para gravações em banco de dados, serialização JSON para respostas de API e geração de CSV para relatórios. Combine o IronPDF com o IronOCR quando também precisar extrair dados de formulários digitalizados ou baseados em imagens, nos quais os campos não foram preenchidos digitalmente.
Como gerar formulários personalizados em grande escala?
O caso de uso mais comum para a automação de formulários PDF é a geração em lote — produzindo centenas ou milhares de formulários pré-preenchidos com dados de um banco de dados, API ou arquivo CSV. Um loop simples lida com isso sem qualquer infraestrutura 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");
}Imports IronPdf
' Retrieve customer records from your data source
Dim customers = GetCustomersFromDatabase()
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
For Each customer In customers
' Build an HTML template with static data pre-filled and interactive fields for user input
Dim formHtml As String = $"
<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>"
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)
pdf.SaveAs($"review-form-{customer.AccountNumber}.pdf")
NextO modelo HTML incorpora diretamente dados estáticos do cliente, de forma que o destinatário veja seu nome e número da conta pré-impressos, e fornece campos interativos para os dados que ele precisa fornecer. O processamento em lote de centenas de registros é concluído em segundos, em vez das horas que a preparação manual exigiria.
A estrutura de loop funciona com qualquer fonte de dados: consultas do Entity Framework , respostas de API ou importações de CSV. Cada iteração produz um PDF completo, pronto para distribuição e personalizado para aquele registro. Para cenários de alto rendimento, use await com Task.WhenAll para renderizar formulários em paralelo - o método RenderHtmlAsPdfAsync do IronPDF suporta renderização totalmente assíncrona.
Após a geração em lote, os formulários são geralmente compactados em um arquivo ZIP para distribuição usando o IronZIP , enviados por e-mail, carregados em armazenamento na nuvem ou encaminhados para uma plataforma de assinatura eletrônica para conclusão da vinculação.
Como compactar ou bloquear formulários PDF após o preenchimento?
Depois que um formulário é totalmente preenchido e validado, geralmente é necessário bloqueá-lo para que os valores não possam mais ser editados. O recurso de achatamento converte todos os campos interativos do formulário em conteúdo visual estático e não editável, preservando a aparência exata do formulário preenchido.
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");Imports IronPdf
' Load a completed, signed form
Dim pdf As PdfDocument = 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")O achatamento é a abordagem correta para arquivar formulários preenchidos, gerar documentos compatíveis com PDF/A para armazenamento de longo prazo e produzir cópias finais para distribuição. Após o achatamento, os dados do formulário ainda ficam visíveis, mas não podem ser modificados. O guia de nivelamento em PDF aborda opções adicionais de nivelamento, incluindo o nivelamento seletivo de campos.
Para cenários que exigem formalidades legais, o IronPDF também oferece suporte a assinaturas digitais , que vinculam criptograficamente a identidade do signatário ao documento. Assinaturas digitais e achatamento de formulários servem a propósitos diferentes: as assinaturas comprovam a autenticidade, enquanto o achatamento impede a modificação.
Quais são os seus próximos passos?
Os formulários PDF em .NET abrangem quatro operações principais: criação de formulários a partir de HTML ou por meio da API, preenchimento de formulários existentes a partir de fontes de dados, extração de dados enviados e geração em lote de cópias personalizadas em grande escala. O IronPDF lida com todos os quatro por meio de uma API consistente, com o mesmo código sendo executado no Windows, Linux, macOS e dentro de contêineres.
O guia prático "Criar Formulários PDF" aborda todos os tipos de campo disponíveis com exemplos de código. O guia Preencher e Editar Formulários aborda em detalhes as atualizações em massa de campos, os grupos de botões de opção e o manuseio de caixas de listagem. O centro de documentação do IronPDF fornece a referência completa da API e tópicos avançados, incluindo formulários com várias páginas, validação de campos de formulário e otimização de desempenho para fluxos de trabalho de alto volume.
Inicie um teste gratuito para explorar os recursos de formulários PDF em seu próprio projeto ou revise as opções de licenciamento para implantação em produção.
Perguntas frequentes
Qual padrão de formulário PDF o IronPDF usa?
IronPDF cria e lê AcroForms - o padrão de formulário interativo definido na especificação PDF desde 1998. AcroForms são suportados pelo Adobe Reader, visualizadores de PDF em navegadores e aplicativos móveis, ao contrário do formato XFA mais antigo que possui compatibilidade limitada.
Como você habilita a criação de campos de formulário a partir de HTML no IronPDF?
Defina `renderer.RenderingOptions.CreatePdfFormsFromHtml = true` antes de chamar `RenderHtmlAsPdf`. Sem esta flag, os elementos de formulário HTML são renderizados como conteúdo visual estático em vez de campos interativos de AcroForm.
Como você preenche um campo específico em um formulário PDF existente?
Carregue o PDF com `PdfDocument.FromFile`, chame `pdf.Form.FindFormField("fieldName")` para recuperar o objeto do campo, então atribua uma string à sua propriedade `Value`. A correspondência de nome de campo é sensível a maiúsculas e minúsculas. Salve o resultado com `pdf.SaveAs`.
Como você extrai todos os valores de campos de formulário de um PDF enviado?
Itere sobre `pdf.Form` com `foreach (var field em pdf.Form)` e leia as propriedades `Name` e `Value` de cada campo. Para extração direcionada, use `pdf.Form.FindFormField("name")?.Value` com o operador condicional nulo para lidar com campos ausentes com segurança.
O IronPDF pode gerar centenas de formulários a partir de um banco de dados em um loop?
Sim. Crie um `ChromePdfRenderer` com `CreatePdfFormsFromHtml = true`, itere sobre seus registros de dados, construa uma string HTML por registro, chame `RenderHtmlAsPdf` e salve cada resultado. Para alta taxa de transferência, use `RenderHtmlAsPdfAsync` com `Task.WhenAll` para renderização paralela.
O que faz a 'achatamento' de um formulário PDF?
O achatamento converte todos os campos de formulário interativos em conteúdo visual estático e não editável, preservando a aparência exata do formulário preenchido. Chame `pdf.Form.Flatten()` e então salve. O resultado é adequado para arquivamento, conformidade PDF/A e distribuição onde a edição de campos deve ser evitada.
O IronPDF funciona no Linux e em contêineres Docker?
Sim. O IronPDF funciona no Windows, Linux, macOS, Docker e Kubernetes. O mesmo código C# produz a mesma saída de PDF em todas as plataformas. Veja os guias de Linux e Docker do IronPDF na documentação para configuração específica da plataforma.
Quais plataformas e versões do .NET o IronPDF suporta para formulários PDF?
O IronPDF suporta .NET Framework 4.6.2 e acima, e todas as versões modernas do .NET incluindo .NET 6, .NET 7, .NET 8, .NET 9 e .NET 10. Também suporta aplicações ASP.NET, ASP.NET Core, Blazor Server, Azure Functions e MAUI.
Comece GRATUITAMENTE
Comece GRATUITAMENTE
Agende uma demonstração ao vivo gratuita
Não é necessário cartão de crédito nem criação de conta.
