# Formulários PDF em C#: Criar, Preencher e Processar Formulários Interativos
**Os AcroForms em PDF** em **C# .NET** com IronPDF oferecem aos desenvolvedores controle programático completo sobre **os campos de formulário interativos** , desde a leitura e preenchimento de formulários governamentais existentes até **a criação de novos formulários a partir de HTML** , extração de dados enviados e **processamento em lote** de milhares de documentos. O IronPDF lida com todos os tipos de campos padrão, incluindo entradas de texto, **caixas de seleção** , botões de opção, **listas suspensas** e campos de assinatura, permitindo automatizar todo o **ciclo de vida do formulário PDF** usando as mesmas habilidades de HTML e CSS que você já possui.
*as-heading:2(Resumo: Guia de Início Rápido)*
Este tutorial aborda a criação, o preenchimento e o processamento de formulários PDF interativos em C# .NET, desde a leitura de campos de formulário existentes até a geração em lote de documentos completos.
- **Para quem é indicado:** Desenvolvedores .NET que automatizam fluxos de trabalho com formulários PDF para processos governamentais, de saúde, financeiros ou de RH.
- **O que você vai desenvolver:** Ler e *preencher formulários PDF* (texto, caixas de seleção, botões de opção, listas suspensas), *criar formulários PDF* a partir de HTML, extrair dados enviados, validar entradas, consolidar formulários para bloquear valores, automatizar o processamento do formulário W-9 e gerar formulários preenchidos em lote.
- **Onde funciona:** .NET 10, .NET 8 LTS, .NET Framework 4.6.2+ e .NET Standard 2.0. A saída funciona no Adobe Acrobat, Preview e em todos os principais leitores de PDF.
- **Quando usar essa abordagem:** Quando seu aplicativo precisa preencher, criar ou processar formulários PDF em grande escala sem entrada manual de dados.
- **Por que isso é importante tecnicamente:** os campos do AcroForm são objetos estruturados que são previsíveis para leitura e gravação programática. O IronPDF também converte elementos de formulário HTML em seus equivalentes AcroForm, oferecendo total flexibilidade de design.
Preencha seu primeiro formulário em PDF com apenas algumas linhas de código:
```cs
:title=Fill a PDF Form with IronPDF
var pdf = IronPdf.PdfDocument.FromFile("form.pdf");
pdf.Form.FindFormField("name").Value = "John Smith";
pdf.SaveAs("filled-form.pdf");
```
Após adquirir ou se inscrever para um período de avaliação de 30 dias do IronPDF, adicione sua chave de licença no início do seu aplicativo.
```cs
IronPdf.License.LicenseKey = "KEY";
```
!!!--LIBRARY_NUGET_INSTALL_BLOCK--!!!
*as-heading:2(Índice)*
- **Resumindo: Guia de Início Rápido**
- [Visão geral rápida](#anchor-tldr-quickstart-guide)
- **Compreendendo formulários em PDF**
[Por que os formulários PDF interativos ainda são essenciais em 2025?](#anchor-why-are-interactive-pdf-forms-still-essential-in-2025)
[O que são AcroForms em PDF e como funcionam?](#anchor-what-are-pdf-acroforms-and-how-do-they-work)
- **Leitura e preenchimento de formulários existentes**
- [Abrir um PDF e Listar Todos os Campos do Formulário](#anchor-open-a-pdf-and-list-all-form-fields)
- [Preencher Campos de Texto, Caixas de Seleção e Listas Suspensas](#anchor-fill-text-fields-checkboxes-and-dropdowns)
- [Preenchendo Formulários a partir de Objetos de Dados e Dicionários](#anchor-filling-forms-from-data-objects-and-dictionaries)
- [Validar Dados do Formulário Antes de Preencher](#anchor-validate-form-data-before-filling)
- **Criando formulários do zero**
- [Criar Campos de Entrada de Texto em um Formulário PDF](#anchor-create-text-input-fields-in-a-pdf-form)
- [Adicionar Caixas de Seleção e Botões de Rádio a Formulários PDF](#anchor-add-checkboxes-and-radio-buttons-to-pdf-forms)
- [Criar Listas Suspensas em Formulários PDF](#anchor-creating-dropdown-lists-in-pdf-forms)
- [Adicionar Campos de Assinatura a Formulários PDF](#anchor-adding-signature-fields-to-pdf-forms)
- [Estilizar e Posicionar Elementos do Formulário](#anchor-style-and-position-form-elements)
- **Fluxos de trabalho de processamento de formulários**
- [Extrair Dados de Formulários PDF Preenchidos](#anchor-extract-data-from-filled-pdf-forms)
- [Achatar um Formulário PDF para Bloquear Valores de Campos](#anchor-flatten-a-pdf-form-to-lock-field-values)
- [Pré-preencher Formulários PDF para Usuários Finais](#anchor-pre-filling-pdf-forms-for-end-users)
- [Construir um Pipeline de Processamento de Dados de Formulários](#anchor-building-a-form-data-processing-pipeline)
- **Automação de Formulários Governamentais**
- [Automatizar Formulários Fiscais do IRS como o W-9](#anchor-automate-irs-tax-forms-like-the-w-9)
- [Processamento em Lote de Formulários com Dados Variáveis](#anchor-batch-processing-forms-with-variable-data)
- [Garantir Conformidade com Padrões de PDF Governamentais](#anchor-ensure-compliance-with-government-pdf-standards)
## Por que os formulários PDF interativos ainda são essenciais em 2025?
Apesar da proliferação de formulários online e soluções de documentos baseadas na nuvem, os formulários em PDF continuam a dominar os processos de negócios críticos. Agências governamentais, prestadores de serviços de saúde, instituições financeiras e escritórios de advocacia dependem muito de formulários em PDF para sua documentação oficial. Somente na área da saúde, 88% dos registros de pacientes são armazenados ou compartilhados em formato PDF. As autoridades fiscais em todo o mundo processam bilhões de formulários anualmente, sendo que a grande maioria chega em formato eletrônico, como documentos em PDF.
Por que esse formato persiste quando existem alternativas aparentemente mais modernas? A resposta reside em uma combinação de requisitos legais, compatibilidade universal e integridade do documento. Os formulários em PDF preservam a formatação exata, independentemente do dispositivo ou sistema operacional usado para visualizá-los. Um formulário preenchido em um computador com Windows aparece idêntico quando aberto em um laptop Mac ou impresso em um órgão público. Essa consistência é extremamente importante quando se trata de documentos legais, registros regulatórios e documentos oficiais, nos quais a formatação precisa pode afetar sua validade.
Os formulários online certamente têm sua utilidade, mas não podem substituir completamente os formulários em PDF por diversos motivos. Muitos órgãos reguladores exigem especificamente o envio de documentos em formato PDF. Os processos judiciais frequentemente exigem documentos em um formato que possa ser arquivado e verificado de forma confiável anos depois. O acesso offline continua sendo importante para trabalhadores de campo, locais remotos e situações em que a conectividade com a internet não pode ser garantida. Além disso, os formulários em PDF podem ser assinados digitalmente, criptografados e rastreados de maneiras que fornecem trilhas de auditoria essenciais para a conformidade.
O mercado de software PDF reflete essa demanda contínua, avaliado em US$ 4,8 bilhões em 2024, com crescimento projetado de 8% a 11% ao ano até 2030. Para os desenvolvedores .NET , isso representa tanto um desafio técnico quanto uma oportunidade significativa. Dominar a automação de formulários PDF significa ser capaz de otimizar fluxos de trabalho que envolvem milhões de documentos em todos os setores.
---
## O que são AcroForms em PDF e como funcionam?
Os AcroForms representam a tecnologia padrão de formulários interativos integrada à especificação PDF. Desenvolvido pela Adobe e agora mantido como um padrão ISO, o AcroForms permite que documentos PDF contenham campos preenchíveis que os usuários podem completar usando qualquer leitor de PDF compatível. Ao abrir um formulário fiscal no Adobe Acrobat ou no Preview e digitar nos campos, você está interagindo com elementos AcroForm incorporados nesse documento.
Cada campo de formulário em um AcroForm possui diversas propriedades importantes. O nome do campo serve como um identificador único que os programas usam para localizar e manipular o campo. O tipo de campo determina o tipo de entrada que o campo aceita, seja texto, caixas de seleção, botões de opção, seleções suspensas ou assinaturas. A propriedade `value` armazena o conteúdo atual do campo, que pode ser lido ou gravado programaticamente. Propriedades adicionais controlam a aparência, as regras de validação e os valores padrão.
O AcroForms suporta diversos tipos de campos distintos que abrangem a maioria das necessidades de coleta de dados. Os campos de texto aceitam entrada de texto livre e podem ser configurados para linhas únicas ou múltiplas. Os campos de caixa de seleção representam escolhas binárias e podem ser agrupados para permitir múltiplas seleções. Os campos de botões de opção funcionam em grupos, onde selecionar uma opção desmarca automaticamente as outras. As caixas de combinação e as caixas de listagem apresentam opções predefinidas para seleção. Os campos de assinatura fornecem áreas designadas para assinaturas digitais. Compreender esses tipos de campos e como eles se comportam é essencial para uma automação eficaz de formulários.
A estrutura dos AcroForms os torna muito adequados para manipulação programática. Como cada campo possui um nome e um valor, você pode percorrer todos os campos de um documento, ler seus valores atuais e definir novos valores usando um código simples. Essa estrutura previsível possibilita os fluxos de trabalho de automação abordados ao longo deste guia.
---
## Abrir um PDF e Listar Todos os Campos do Formulário
Antes de preencher um formulário PDF programaticamente, você precisa entender sua estrutura. Ao abrir um documento e enumerar seus campos, você verá os nomes dos campos que serão usados para definir valores, juntamente com os tipos de campo e qualquer conteúdo existente. Essa etapa de descoberta se mostra especialmente valiosa ao trabalhar com formulários de terceiros, nos quais você não possui documentação sobre a estrutura interna dos campos.
#### Entrada PDF
Para este exemplo, usaremos um formulário PDF existente chamado `application-form.pdf`. Pode ser qualquer PDF que contenha campos de formulário interativos: um formulário governamental, um modelo de inscrição da sua organização ou um documento de terceiros que você precise processar. O código abaixo carrega este arquivo e percorre todos os seus campos de formulário interativos.
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/application-form.pdf" width="100%" height="400px">
</iframe>
```csharp
using IronPdf;
// Load an existing PDF form document
PdfDocument pdfForm = PdfDocument.FromFile("application-form.pdf");
// Access the form object and iterate through all fields
foreach (var field in pdfForm.Form)
{
// Access field properties: field.Name, field.Type, field.Value, field.ReadOnly
}
```
O método `PdfDocument.FromFile()` carrega o PDF na memória, e a coleção `Form` fornece acesso a todos os campos interativos no documento. Cada campo expõe propriedades como `Name` (o identificador único usado para acesso programático), `Type` (campo de texto, caixa de seleção, botão de rádio, dropdown ou assinatura), `Value` (o conteúdo atual), e `ReadOnly` (se o campo pode ser modificado). Executar essa enumeração em um formulário desconhecido fornece o inventário completo de campos necessário para escrever um código que o preencha corretamente.
Para formulários com muitos campos, você pode filtrar por tipo ou pesquisar por nomes de campos específicos. O método `FindFormField` localiza um campo pelo nome exato, lançando uma exceção se não houver correspondência. Utilize blocos try-catch quando não tiver certeza se um campo existe.
```csharp
using IronPdf;
using System;
PdfDocument pdfForm = PdfDocument.FromFile("employee-onboarding.pdf");
// Find specific fields by name - use try-catch for fields that may not exist
try
{
var firstNameField = pdfForm.Form.FindFormField("firstName");
// Use firstNameField.Value to get or set the field value
}
catch (Exception)
{
// Field not found in this document
}
// For fields you know exist, you can access them directly
var lastNameField = pdfForm.Form.FindFormField("lastName");
var departmentField = pdfForm.Form.FindFormField("department");
```
Para obter mais detalhes sobre como ler os valores dos campos de formulário, consulte o guia [Extrair campos de formulário PDF em C#](https://ironpdf.com/blog/using-ironpdf/csharp-read-pdf-form-fields/) .
---
## Preencher Campos de Texto, Caixas de Seleção e Listas Suspensas
Depois de conhecer os nomes dos campos em um formulário PDF, preenchê-los requer apenas algumas linhas de código. Cada tipo de campo aceita valores em um formato específico. Os campos de texto aceitam valores de string diretamente. As caixas de seleção usam "Sim" para indicar que estão marcadas e "Não" para indicar que não estão. Os botões de opção aceitam o valor da opção selecionada. Os campos suspensos aceitam qualquer valor de sua lista de opções predefinidas.
#### Entrada PDF
Trabalharemos com um formulário de registro de cliente (`customer-registration.pdf`) que contém vários tipos de campo: campos de texto para nome, email, telefone e endereço; uma caixa de seleção para optar por receber a newsletter; e um menu suspenso para seleção do tipo de conta. Este exemplo carrega o formulário e preenche cada campo com dados de clientes de amostra.
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/customer-registration.pdf" width="100%" height="400px">
</iframe>
```csharp
using IronPdf;
// Load the form document
PdfDocument pdf = PdfDocument.FromFile("customer-registration.pdf");
// Fill text fields with customer information
pdf.Form.FindFormField("fullName").Value = "Sarah Johnson";
pdf.Form.FindFormField("email").Value = "sarah.johnson@example.com";
pdf.Form.FindFormField("phone").Value = "(555) 123-4567";
pdf.Form.FindFormField("address").Value = "742 Evergreen Terrace\r\nSpringfield, IL 62701";
// Check a checkbox field
pdf.Form.FindFormField("newsletterOptIn").Value = "Yes";
// Select an option from a dropdown
pdf.Form.FindFormField("accountType").Value = "Premium";
// Save the filled form
pdf.SaveAs("customer-registration-completed.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/customer-registration-filled.pdf" width="100%" height="400px">
</iframe>
O método `FindFormField()` localiza cada campo pelo nome exato, e definir a propriedade `Value` popula o conteúdo do campo. Observe o uso de `\r\n` para quebras de linha no campo de endereço. As áreas de texto com várias linhas interpretam essas sequências de escape corretamente, permitindo formatar endereços, comentários e outros conteúdos que se estendem por várias linhas. Para caixas de seleção, os valores "Sim" e "Não" alternam o estado selecionado, enquanto as listas suspensas aceitam qualquer valor que corresponda a uma de suas opções predefinidas.
Ao trabalhar com botões de opção, é necessário compreender que todos os botões em um grupo compartilham o mesmo nome de campo. Definir o valor seleciona a opção correspondente e desmarca todas as outras desse grupo.
```csharp
using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("survey-form.pdf");
// Get a radio button group and examine its options
var satisfactionField = pdf.Form.FindFormField("satisfactionLevel");
// Access available options from the radio button annotations
foreach (var annotation in satisfactionField.Annotations)
{
// annotation.OnAppearance contains the option value
}
// Select one option from the group
satisfactionField.Value = "Very Satisfied";
pdf.SaveAs("survey-completed.pdf");
```
Os campos suspensos funcionam de maneira semelhante. Você pode examinar as escolhas disponíveis através da propriedade `Choices` antes de definir um valor, garantindo que seu código apenas tente selecionar opções válidas.
```csharp
using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("order-form.pdf");
var shippingMethod = pdf.Form.FindFormField("shippingMethod");
// Access all available shipping options via shippingMethod.Choices
// Select express shipping
shippingMethod.Value = "Express (2-3 days)";
pdf.SaveAs("order-form-filled.pdf");
```
Para um guia completo sobre como preencher todos os tipos de campos de formulário, consulte [Preencher e editar formulários PDF em C#](https://ironpdf.com/how-to/edit-forms/) e [Preencher formulários PDF programaticamente](https://ironpdf.com/blog/using-ironpdf/programmatically-fill-pdf-form-csharp/) .
---
<a id="anchor-filling-forms-from-data-objects-and-dictionaries"></a>
## Preenchendo Formulários a partir de Objetos de Dados e Dicionários
Aplicações do mundo real raramente codificam valores de formulário diretamente no código. Em vez disso, os dados provêm de bancos de dados, respostas de API, entrada do usuário ou arquivos de configuração. Organizar esses dados em dicionários ou objetos personalizados torna o código de preenchimento de formulários mais fácil de manter e reutilizar.
#### Entrada PDF
Considere um formulário de solicitação de empréstimo (`loan-application.pdf`) contendo campos para informações do solicitante: nome, data de nascimento, SSN, campos de endereço, status de emprego, renda anual, e uma caixa de seleção de acordo com os termos. O código a seguir preenche o formulário usando dados armazenados em um `Dictionary<string, string>`, onde cada chave do dicionário corresponde a um nome de campo do formulário.
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/loan-application.pdf" width="100%" height="400px">
</iframe>
```csharp
using IronPdf;
using System.Collections.Generic;
// Form data stored in a dictionary
var formData = new Dictionary<string, string>
{
{ "applicantName", "Michael Chen" },
{ "dateOfBirth", "1985-03-15" },
{ "ssn", "XXX-XX-1234" },
{ "streetAddress", "456 Oak Avenue" },
{ "city", "Portland" },
{ "state", "OR" },
{ "zipCode", "97201" },
{ "employmentStatus", "Full-Time" },
{ "annualIncome", "75000" },
{ "agreeToTerms", "Yes" }
};
PdfDocument pdf = PdfDocument.FromFile("loan-application.pdf");
// Iterate through the dictionary and fill matching fields
foreach (var entry in formData)
{
var field = pdf.Form.FindFormField(entry.Key);
if (field != null)
{
field.Value = entry.Value;
}
}
pdf.SaveAs("loan-application-filled.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/loan-application-filled.pdf" width="100%" height="400px">
</iframe>
A abordagem baseada em dicionário separa claramente os dados da lógica. O loop `foreach` itera através de cada par chave-valor, usa `FindFormField()` para localizar o campo correspondente no PDF, e atribui o valor se o campo existir. A verificação de nulo (`if (field != null)`) impede exceções quando o dicionário contém chaves que não correspondem a nenhum campo no documento. Isso é particularmente útil ao trabalhar com fontes de dados que podem incluir campos extras não presentes no formulário.
Para cenários mais complexos, você pode definir uma classe que represente os dados do formulário e, em seguida, usar reflexão ou uma função de mapeamento para transferir os valores das propriedades para os campos do formulário.
```csharp
using IronPdf;
using System;
// Define a strongly-typed class for the form data
public class EmployeeRecord
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string EmployeeId { get; set; }
public string Department { get; set; }
public DateTime HireDate { get; set; }
public string JobTitle { get; set; }
public bool DirectDeposit { get; set; }
}
public class FormFiller
{
public void FillEmployeeForm(EmployeeRecord employee, string templatePath, string outputPath)
{
PdfDocument pdf = PdfDocument.FromFile(templatePath);
// Map object properties to form fields
pdf.Form.FindFormField("firstName").Value = employee.FirstName;
pdf.Form.FindFormField("lastName").Value = employee.LastName;
pdf.Form.FindFormField("employeeId").Value = employee.EmployeeId;
pdf.Form.FindFormField("department").Value = employee.Department;
pdf.Form.FindFormField("hireDate").Value = employee.HireDate.ToString("MM/dd/yyyy");
pdf.Form.FindFormField("jobTitle").Value = employee.JobTitle;
pdf.Form.FindFormField("directDeposit").Value = employee.DirectDeposit ? "Yes" : "No";
pdf.SaveAs(outputPath);
}
}
// Usage example
class Program
{
static void Main()
{
var employee = new EmployeeRecord
{
FirstName = "Jennifer",
LastName = "Martinez",
EmployeeId = "EMP-2024-0892",
Department = "Engineering",
HireDate = new DateTime(2024, 6, 15),
JobTitle = "Senior Developer",
DirectDeposit = true
};
var filler = new FormFiller();
filler.FillEmployeeForm(employee, "new-hire-form.pdf", "jennifer-martinez-onboarding.pdf");
}
}
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/employee-onboarding-filled.pdf" width="100%" height="400px">
</iframe>
---
## Validar Dados do Formulário Antes de Preencher
Antes de preencher um formulário em PDF, validar os dados ajuda a detectar erros precocemente e garante que o documento resultante atenda aos requisitos. Embora os formulários em PDF possam incluir suas próprias regras de validação, confiar exclusivamente nessas regras significa que os erros só aparecem no final do processamento. Implementar a validação no seu código C# oferece mais controle e mensagens de erro mais claras.
```csharp
using IronPdf;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class FormValidationResult
{
public bool IsValid { get; set; }
public List<string> Errors { get; set; } = new List<string>();
}
public class FormValidator
{
public FormValidationResult ValidateApplicationData(Dictionary<string, string> formData, PdfDocument pdf)
{
var result = new FormValidationResult { IsValid = true };
// Check that all required fields have values
var requiredFields = new[] { "applicantName", "email", "phone", "ssn" };
foreach (var fieldName in requiredFields)
{
if (!formData.ContainsKey(fieldName) || string.IsNullOrWhiteSpace(formData[fieldName]))
{
result.Errors.Add($"Required field '{fieldName}' is missing or empty");
result.IsValid = false;
}
}
// Validate email format
if (formData.ContainsKey("email"))
{
var emailPattern = @"^[^@\s]+@[^@\s]+\.[^@\s]+$";
if (!Regex.IsMatch(formData["email"], emailPattern))
{
result.Errors.Add("Email address format is invalid");
result.IsValid = false;
}
}
// Validate phone number format
if (formData.ContainsKey("phone"))
{
var phonePattern = @"^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$";
if (!Regex.IsMatch(formData["phone"], phonePattern))
{
result.Errors.Add("Phone number format is invalid");
result.IsValid = false;
}
}
// Verify that form fields exist in the PDF
foreach (var fieldName in formData.Keys)
{
try
{
var field = pdf.Form.FindFormField(fieldName);
// Field exists
}
catch
{
result.Errors.Add($"Field '{fieldName}' does not exist in the PDF form");
result.IsValid = false;
}
}
// Check dropdown values against available choices
if (formData.ContainsKey("state"))
{
try
{
var stateField = pdf.Form.FindFormField("state");
if (stateField.Choices != null)
{
bool validChoice = false;
foreach (var choice in stateField.Choices)
{
if (choice == formData["state"])
{
validChoice = true;
break;
}
}
if (!validChoice)
{
result.Errors.Add($"'{formData["state"]}' is not a valid option for the state field");
result.IsValid = false;
}
}
}
catch
{
// State field doesn't exist, skip validation
}
}
return result;
}
}
// Usage example
class Program
{
static void Main()
{
var formData = new Dictionary<string, string>
{
{ "applicantName", "John Doe" },
{ "email", "invalid-email" },
{ "phone", "555-1234" },
{ "state", "XX" }
};
PdfDocument pdf = PdfDocument.FromFile("application.pdf");
var validator = new FormValidator();
var validationResult = validator.ValidateApplicationData(formData, pdf);
if (validationResult.IsValid)
{
// Proceed with form fill
}
else
{
// Handle validation errors in validationResult.Errors
}
}
}
```
Essa camada de validação verifica se há campos obrigatórios ausentes, valida padrões de formatação para tipos de dados comuns, confirma se os valores especificados nas listas suspensas existem nas opções do formulário e verifica se todos os nomes de campo nos seus dados realmente existem no PDF. Identificar esses problemas antes de tentar preencher o formulário evita preenchimentos parciais e facilita muito a depuração.
---
## Criar Campos de Entrada de Texto em um Formulário PDF
Criar formulários em PDF do zero oferece controle total sobre a estrutura e a aparência do formulário. O mecanismo de renderização HTML-para-PDF do IronPDF interpreta elementos de formulário HTML padrão e os converte em campos AcroForm do PDF. Essa abordagem permite que você crie formulários usando tecnologias web familiares, incluindo CSS para estilização. Para obter o guia completo sobre como criar formulários, consulte [Criar formulários PDF em C#](https://ironpdf.com/how-to/create-forms/) .
O código a seguir cria um formulário de feedback do cliente com campos de entrada de texto e uma área de texto, usando HTML e CSS para definir a estrutura e o estilo do formulário. O PDF gerado contém campos de formulário preenchíveis que os usuários podem completar em qualquer leitor de PDF.
```csharp
using IronPdf;
// Define the form layout using HTML with form elements
string formHtml = @"
E html>
le>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 40px auto;
padding: 20px;
}
h1 {
color: #333;
border-bottom: 2px solid #4CAF50;
padding-bottom: 10px;
}
.form-group {
margin-bottom: 15px;
}
label {
display: block;
margin-bottom: 5px;
font-weight: bold;
color: #555;
}
input[type='text'], textarea {
width: 100%;
padding: 8px;
border: 1px solid #ddd;
border-radius: 4px;
box-sizing: border-box;
}
textarea {
height: 100px;
resize: none;
}
.required::after {
content: ' *';
color: red;
}
yle>
Customer Feedback Form</h1>
m>
<div class='form-group'>
<label class='required'>Full Name</label>
<input type='text' name='customerName' />
</div>
<div class='form-group'>
<label class='required'>Email Address</label>
<input type='text' name='customerEmail' />
</div>
<div class='form-group'>
<label>Phone Number</label>
<input type='text' name='customerPhone' />
</div>
<div class='form-group'>
<label>Order Number</label>
<input type='text' name='orderNumber' />
</div>
<div class='form-group'>
<label class='required'>Your Feedback</label>
<textarea name='feedbackText'></textarea>
</div>
rm>
;
// Create the renderer and enable form creation
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
// Render the HTML to a PDF with interactive form fields
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("customer-feedback-form.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/customer-feedback-form.pdf" width="100%" height="400px">
</iframe>
A configuração da chave é `CreatePdfFormsFromHtml = true` no `RenderingOptions`, que instrui o `ChromePdfRenderer` a converter elementos HTML `<input>` e `<textarea>` em seus equivalentes PDF AcroForm. Sem essa configuração, os campos de entrada seriam exibidos como elementos visuais estáticos, sem interatividade. O atributo `name` em cada elemento de entrada se torna o nome do campo no PDF resultante. Esses são os identificadores que você usará ao preencher o formulário programaticamente. Escolha nomes descritivos e consistentes que tornem o código de preenchimento de formulários legível e fácil de manter. Para mais informações sobre conversão de HTML para PDF, consulte o tutorial [Converter HTML para PDF em C#](https://ironpdf.com/tutorials/html-to-pdf/) .
---
## Adicionar Caixas de Seleção e Botões de Rádio a Formulários PDF
As caixas de seleção e os botões de opção capturam a entrada baseada em seleção. No HTML, caixas de seleção usam `type='checkbox'` enquanto botões de rádio usam `type='radio'`. Os botões de opção que compartilham o mesmo atributo de nome formam automaticamente um grupo mutuamente exclusivo.
Este trecho de código cria um formulário de inscrição para eventos com várias caixas de seleção para preferências alimentares e botões de opção para seleção do tipo de ingresso. A estrutura HTML define o layout do formulário, enquanto o CSS fornece o estilo.
```csharp
using IronPdf;
string formHtml = @"
E html>
le>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 40px auto;
padding: 20px;
}
h1 {
color: #2c3e50;
}
h2 {
color: #34495e;
font-size: 16px;
margin-top: 25px;
}
.option-group {
margin: 10px 0;
}
.option-group label {
margin-left: 8px;
cursor: pointer;
}
.checkbox-section {
background: #f9f9f9;
padding: 15px;
border-radius: 5px;
margin: 15px 0;
}
yle>
Event Registration</h1>
m>
<h2>Select Your Ticket Type</h2>
<div class='option-group'>
<input type='radio' name='ticketType' value='General' id='general' />
<label for='general'>General Admission ($50)</label>
</div>
<div class='option-group'>
<input type='radio' name='ticketType' value='VIP' id='vip' />
<label for='vip'>VIP Access ($150)</label>
</div>
<div class='option-group'>
<input type='radio' name='ticketType' value='Premium' id='premium' />
<label for='premium'>Premium Package ($300)</label>
</div>
<h2>Which Sessions Will You Attend?</h2>
<div class='checkbox-section'>
<div class='option-group'>
<input type='checkbox' name='sessionMorning' value='Yes' id='morning' />
<label for='morning'>Morning Keynote (9:00 AM)</label>
</div>
<div class='option-group'>
<input type='checkbox' name='sessionWorkshop' value='Yes' id='workshop' />
<label for='workshop'>Afternoon Workshop (2:00 PM)</label>
</div>
<div class='option-group'>
<input type='checkbox' name='sessionNetworking' value='Yes' id='networking' />
<label for='networking'>Evening Networking (6:00 PM)</label>
</div>
</div>
<h2>Dietary Requirements</h2>
<div class='option-group'>
<input type='checkbox' name='dietVegetarian' value='Yes' id='vegetarian' />
<label for='vegetarian'>Vegetarian</label>
</div>
<div class='option-group'>
<input type='checkbox' name='dietVegan' value='Yes' id='vegan' />
<label for='vegan'>Vegan</label>
</div>
<div class='option-group'>
<input type='checkbox' name='dietGlutenFree' value='Yes' id='glutenfree' />
<label for='glutenfree'>Gluten-Free</label>
</div>
rm>
;
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("event-registration-form.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/event-registration-form.pdf" width="100%" height="400px">
</iframe>
Observe que os três botões de rádio compartilham `name='ticketType'`, criando um grupo onde apenas uma opção pode ser selecionada. Cada caixa de seleção tem um nome único porque representa opções independentes que podem ser selecionadas em qualquer combinação.
---
## Criar Listas Suspensas em Formulários PDF
Listas suspensas economizam espaço e oferecem várias opções predefinidas. O elemento HTML `<select>` com filhos `<option>` cria um campo de combobox PDF. Os usuários clicam no campo para revelar a lista de opções e selecionam uma delas.
Aqui, criamos um formulário de candidatura a emprego com vários menus suspensos para seleção de departamento, nível de experiência, data de início preferencial e local de trabalho. Cada elemento `<select>` contém valores `<option>` predefinidos.
```csharp
using IronPdf;
string formHtml = @"
E html>
le>
body {
font-family: 'Segoe UI', Arial, sans-serif;
max-width: 650px;
margin: 30px auto;
padding: 25px;
background: #fff;
}
h1 {
color: #1a5f7a;
margin-bottom: 30px;
}
.form-row {
display: flex;
gap: 20px;
margin-bottom: 20px;
}
.form-group {
flex: 1;
}
label {
display: block;
margin-bottom: 6px;
font-weight: 600;
color: #333;
}
select, input[type='text'] {
width: 100%;
padding: 10px;
border: 1px solid #ccc;
border-radius: 4px;
font-size: 14px;
box-sizing: border-box;
}
yle>
Job Application Form</h1>
m>
<div class='form-row'>
<div class='form-group'>
<label>First Name</label>
<input type='text' name='firstName' />
</div>
<div class='form-group'>
<label>Last Name</label>
<input type='text' name='lastName' />
</div>
</div>
<div class='form-row'>
<div class='form-group'>
<label>Department</label>
<select name='department'>
<option value=''>Select Department</option>
<option value='Engineering'>Engineering</option>
<option value='Marketing'>Marketing</option>
<option value='Sales'>Sales</option>
<option value='Human Resources'>Human Resources</option>
<option value='Finance'>Finance</option>
<option value='Operations'>Operations</option>
</select>
</div>
<div class='form-group'>
<label>Experience Level</label>
<select name='experienceLevel'>
<option value=''>Select Level</option>
<option value='Entry'>Entry Level (0-2 years)</option>
<option value='Mid'>Mid Level (3-5 years)</option>
<option value='Senior'>Senior (6-10 years)</option>
<option value='Executive'>Executive (10+ years)</option>
</select>
</div>
</div>
<div class='form-row'>
<div class='form-group'>
<label>Preferred Start Date</label>
<select name='startDate'>
<option value='Immediate'>Immediately</option>
<option value='TwoWeeks'>In 2 weeks</option>
<option value='OneMonth'>In 1 month</option>
<option value='Flexible'>Flexible</option>
</select>
</div>
<div class='form-group'>
<label>Work Location Preference</label>
<select name='workLocation'>
<option value='OnSite'>On-Site</option>
<option value='Remote'>Fully Remote</option>
<option value='Hybrid'>Hybrid</option>
</select>
</div>
</div>
rm>
;
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("job-application-form.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/job-application-form.pdf" width="100%" height="400px">
</iframe>
O primeiro `<option>` em cada elemento select (com um valor vazio) serve como um prompt de espaço reservado como "Select Department". Quando o PDF é renderizado, esses campos se transformam em caixas de combinação nas quais os usuários podem clicar para revelar a lista completa de opções. Ao preencher este formulário programaticamente, defina o valor do campo para corresponder exatamente a um dos valores das opções, como "Engenharia" ou "Remoto".
---
## Adicionar Campos de Assinatura a Formulários PDF
Os campos de assinatura designam áreas onde os usuários podem aplicar assinaturas digitais. Embora o HTML não possua um tipo de entrada de assinatura nativo, o IronPDF permite adicionar campos de assinatura programaticamente a qualquer documento PDF.
O código abaixo primeiro cria um documento de Acordo de Confidencialidade a partir de HTML, depois adiciona programaticamente um `SignatureFormField` em uma posição específica na página. O campo de assinatura é posicionado usando coordenadas PDF (x, y, largura, altura em pontos).
```csharp
using IronPdf;
using IronSoftware.Forms;
// First create the base form using HTML
string formHtml = @"
E html>
le>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 40px auto;
padding: 30px;
}
h1 {
text-align: center;
color: #2c3e50;
}
.agreement-text {
background: #f5f5f5;
padding: 20px;
border-radius: 5px;
margin: 20px 0;
line-height: 1.6;
}
.signature-section {
margin-top: 40px;
padding-top: 20px;
border-top: 1px solid #ddd;
}
.signature-line {
margin-top: 60px;
border-bottom: 1px solid #333;
width: 300px;
}
.signature-label {
font-size: 12px;
color: #666;
margin-top: 5px;
}
.date-field {
margin-top: 20px;
}
.date-field label {
font-weight: bold;
}
.date-field input {
padding: 8px;
border: 1px solid #ccc;
border-radius: 4px;
width: 150px;
}
yle>
Non-Disclosure Agreement</h1>
class='agreement-text'>
<p>By signing this document, I acknowledge that I have read and understood
the terms of the Non-Disclosure Agreement dated as of the date signed below.
I agree to maintain the confidentiality of all proprietary information
disclosed to me during my engagement with the Company.</p>
<p>I understand that violation of this agreement may result in legal action
and that I am bound by these terms for a period of five (5) years from the
date of signature.</p>
v>
class='signature-section'>
<div class='date-field'>
<label>Date:</label>
<input type='text' name='signatureDate' />
</div>
<div class='signature-line'></div>
<div class='signature-label'>Authorized Signature</div>
v>
;
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
// Add a signature field programmatically
// Parameters: name, page index, x position, y position, width, height
SignatureFormField signatureField = new SignatureFormField(
"authorizedSignature", // Field name
0, // Page index (first page)
72, // X position in points from left
200, // Y position in points from bottom
250, // Width in points
60 // Height in points
);
pdf.Form.Add(signatureField);
pdf.SaveAs("nda-with-signature.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/nda-with-signature.pdf" width="100%" height="400px">
</iframe>
O construtor `SignatureFormField` leva seis parâmetros: o nome do campo ("authorizedSignature"), índice da página (0 para a primeira página), e a posição/tamanho em pontos (x=72, y=200, largura=250, altura=60). As coordenadas do PDF têm origem no canto inferior esquerdo da página, com 72 pontos por polegada. O campo de assinatura aparece como uma área interativa em leitores de PDF que suportam assinaturas digitais. Os usuários podem clicar neste campo para aplicar uma assinatura baseada em certificado.
Para mais informações sobre assinaturas digitais, incluindo assinatura baseada em certificado, consulte o [Guia de Assinatura Digital para PDFs em C#](https://ironpdf.com/how-to/signing/) e [os Exemplos de Assinaturas Digitais em PDF em C#](https://ironpdf.com/examples/digitally-sign-a-pdf/) .
---
## Estilizar e Posicionar Elementos do Formulário
O CSS oferece amplo controle sobre a aparência do formulário ao criar PDFs a partir de HTML. Você pode ajustar cores, fontes, bordas, espaçamento e layout para combinar com a identidade visual da sua organização ou atender a requisitos de design específicos.
Este trecho de código cria um formulário de solicitação de contato visualmente refinado usando recursos avançados de CSS, incluindo fontes do Google, fundos gradientes, CSS Grid para layouts de duas colunas e estilos personalizados para os campos do formulário, com cantos arredondados e estados de foco.
```csharp
using IronPdf;
string formHtml = @"
E html>
le>
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap');
body {
font-family: 'Inter', sans-serif;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
margin: 0;
padding: 40px;
box-sizing: border-box;
}
.form-container {
background: white;
max-width: 550px;
margin: 0 auto;
padding: 40px;
border-radius: 12px;
box-shadow: 0 20px 60px rgba(0,0,0,0.3);
}
h1 {
margin: 0 0 10px 0;
color: #1a1a2e;
font-weight: 600;
}
.subtitle {
color: #666;
margin-bottom: 30px;
font-size: 14px;
}
.form-group {
margin-bottom: 20px;
}
label {
display: block;
margin-bottom: 8px;
font-weight: 600;
color: #333;
font-size: 14px;
}
input[type='text'], select, textarea {
width: 100%;
padding: 12px 16px;
border: 2px solid #e1e1e1;
border-radius: 8px;
font-size: 14px;
transition: border-color 0.3s;
box-sizing: border-box;
font-family: 'Inter', sans-serif;
}
input[type='text']:focus, select:focus, textarea:focus {
border-color: #667eea;
outline: none;
}
textarea {
height: 120px;
resize: none;
}
.checkbox-group {
display: flex;
align-items: center;
gap: 10px;
padding: 12px;
background: #f8f9fa;
border-radius: 8px;
}
.checkbox-group input[type='checkbox'] {
width: 20px;
height: 20px;
accent-color: #667eea;
}
.two-column {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 15px;
}
.footer-note {
margin-top: 30px;
padding-top: 20px;
border-top: 1px solid #eee;
font-size: 12px;
color: #888;
text-align: center;
}
yle>
class='form-container'>
<h1>Contact Request</h1>
<p class='subtitle'>Fill out the form below and we will get back to you within 24 hours.</p>
<form>
<div class='two-column'>
<div class='form-group'>
<label>First Name</label>
<input type='text' name='firstName' />
</div>
<div class='form-group'>
<label>Last Name</label>
<input type='text' name='lastName' />
</div>
</div>
<div class='form-group'>
<label>Email Address</label>
<input type='text' name='email' />
</div>
<div class='form-group'>
<label>Subject</label>
<select name='subject'>
<option value=''>Choose a topic...</option>
<option value='General'>General Inquiry</option>
<option value='Support'>Technical Support</option>
<option value='Sales'>Sales Question</option>
<option value='Partnership'>Partnership Opportunity</option>
</select>
</div>
<div class='form-group'>
<label>Message</label>
<textarea name='message'></textarea>
</div>
<div class='form-group'>
<div class='checkbox-group'>
<input type='checkbox' name='newsletter' value='Yes' id='newsletter' />
<label for='newsletter' style='margin: 0; font-weight: normal;'>
Subscribe to our newsletter for updates
</label>
</div>
</div>
</form>
<p class='footer-note'>Your information is secure and will never be shared with third parties.</p>
v>
;
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
// Set page size and margins
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 0;
renderer.RenderingOptions.MarginBottom = 0;
renderer.RenderingOptions.MarginLeft = 0;
renderer.RenderingOptions.MarginRight = 0;
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("styled-contact-form.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/styled-contact-form.pdf" width="100%" height="400px">
</iframe>
O HTML usa a fonte Inter do Google Fonts (`@import url(...)`), aplica um fundo gradiente ao corpo, e estiliza o contêiner de formulário com cantos arredondados e uma sombra. O `RenderingOptions` define todas as margens para zero e usa tamanho de papel A4 para garantir que o gradiente preencha toda a página. Apesar do estilo sofisticado, todos os campos do formulário permanecem totalmente interativos no PDF resultante. Os usuários podem clicar e digitar em cada campo.
Para obter mais informações sobre opções de renderização CSS e layouts responsivos, consulte [Converter HTML em PDF com CSS responsivo](https://ironpdf.com/how-to/html-to-pdf-responsive-css/) e [Usar opções de renderização em PDF](https://ironpdf.com/how-to/rendering-options/) .
---
## Extrair Dados de Formulários PDF Preenchidos
Após os usuários preencherem um formulário em PDF, seu aplicativo precisa recuperar os valores inseridos para processamento, armazenamento ou transferência para outros sistemas. A extração de dados de formulários inverte o processo de preenchimento, lendo os valores dos campos em vez de escrevê-los.
#### Entrada PDF
Imagine que você recebeu um formulário de inscrição completo (`completed-application.pdf`) que um usuário já preencheu. Este é um cenário comum em que você recebe formulários enviados por e-mail, upload de arquivos ou sistema de gerenciamento de documentos e precisa extrair os dados para armazenamento em banco de dados ou processamento posterior. O código abaixo carrega o formulário preenchido e extrai todos os valores dos campos para um dicionário.
```csharp
using IronPdf;
using System.Collections.Generic;
// Load a filled PDF form
PdfDocument filledForm = PdfDocument.FromFile("completed-application.pdf");
// Extract all form data into a dictionary
var extractedData = new Dictionary<string, string>();
foreach (var field in filledForm.Form)
{
extractedData[field.Name] = field.Value ?? string.Empty;
}
// Access extracted data
// extractedData.GetValueOrDefault("firstName")
// extractedData.GetValueOrDefault("lastName")
// extractedData.GetValueOrDefault("email")
// extractedData.GetValueOrDefault("department")
```
O processo de extração itera através da coleção `Form`, lendo cada propriedade `Name` e `Value` do campo. O operador de coalescência nula (`?? `string.Empty` garante que campos vazios ou não definidos retornem uma string vazia em vez de nulo, evitando problemas de referência nula no processamento subsequente. Uma vez extraído, o dicionário proporciona fácil acesso a qualquer valor de campo usando seu nome como chave.
Para uma extração mais estruturada, você pode mapear os campos do formulário diretamente para um objeto fortemente tipado.
```csharp
using IronPdf;
using System;
public class ApplicationData
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string Email { get; set; }
public string Phone { get; set; }
public string Department { get; set; }
public string ExperienceLevel { get; set; }
public bool AcceptsTerms { get; set; }
}
public class FormDataExtractor
{
public ApplicationData ExtractApplicationData(string pdfPath)
{
PdfDocument pdf = PdfDocument.FromFile(pdfPath);
return new ApplicationData
{
FirstName = GetFieldValue(pdf, "firstName"),
LastName = GetFieldValue(pdf, "lastName"),
Email = GetFieldValue(pdf, "email"),
Phone = GetFieldValue(pdf, "phone"),
Department = GetFieldValue(pdf, "department"),
ExperienceLevel = GetFieldValue(pdf, "experienceLevel"),
AcceptsTerms = GetFieldValue(pdf, "acceptTerms") == "Yes"
};
}
private string GetFieldValue(PdfDocument pdf, string fieldName)
{
var field = pdf.Form.FindFormField(fieldName);
return field?.Value ?? string.Empty;
}
}
// Usage
class Program
{
static void Main()
{
var extractor = new FormDataExtractor();
var application = extractor.ExtractApplicationData("submitted-form.pdf");
// Access application.FirstName, application.LastName, application.Department, etc.
}
}
```
Para obter mais exemplos de leitura de dados de formulário, consulte [Exemplos de formulários PDF em C#](https://ironpdf.com/examples/form-data/) e [Guia de extração de campos de formulário PDF](https://ironpdf.com/blog/using-ironpdf/csharp-read-pdf-form-fields/) .
---
## Achatar um Formulário PDF para Bloquear Valores de Campos
Aplanar um formulário PDF converte campos interativos em conteúdo estático. A aparência visual permanece idêntica, mas os usuários não podem mais editar os valores. Essa técnica serve a vários propósitos: criar registros permanentes de formulários preenchidos, preparar documentos para arquivamento e evitar modificações acidentais ou intencionais após o envio.
#### Entrada PDF
Aqui usaremos um modelo de contrato (`contract-template.pdf`) contendo campos para nome do cliente, data do contrato, valor do contrato e termos de pagamento. Isso espelha um fluxo de trabalho típico, no qual você preenche um modelo com informações específicas da negociação e, em seguida, bloqueia os campos para criar um documento finalizado e inviolável. O código a seguir carrega o modelo, preenche os detalhes do contrato e define todos os campos como somente leitura.
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/contract-template.pdf" width="100%" height="400px">
</iframe>
```csharp
using IronPdf;
// Load and fill the form
PdfDocument pdf = PdfDocument.FromFile("contract-template.pdf");
pdf.Form.FindFormField("clientName").Value = "Acme Corporation";
pdf.Form.FindFormField("contractDate").Value = "January 15, 2025";
pdf.Form.FindFormField("contractValue").Value = "$50,000";
pdf.Form.FindFormField("paymentTerms").Value = "Net 30";
// Make all form fields read-only to prevent further editing
foreach (var field in pdf.Form)
{
field.ReadOnly = true;
}
// Save the document with locked fields
pdf.SaveAs("contract-acme-signed.pdf");
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/contract-readonly.pdf" width="100%" height="400px">
</iframe>
O código primeiro preenche campos como `clientName`, `contractDate`, `contractValue`, e `paymentTerms` com os detalhes do contrato. O loop `foreach` então itera através de cada campo no formulário e define `field.ReadOnly = true`, que bloqueia cada campo contra edições adicionais. Após salvar, os usuários ainda poderão visualizar os valores do formulário em qualquer leitor de PDF, mas clicar nos campos não permitirá a modificação. Essa técnica cria registros permanentes adequados para fins de arquivo ou documentação legal.
Para opções adicionais de segurança de PDF, incluindo proteção por senha, consulte o [Tutorial de Assinatura e Proteção de PDFs](https://ironpdf.com/tutorials/csharp-pdf-security-complete-tutorial/) e [o Guia de Proteção de PDF por Senha](https://ironpdf.com/how-to/pdf-permissions-passwords/) .
---
## Pré-preencher Formulários PDF para Usuários Finais
O preenchimento prévio de formulários com informações já conhecidas melhora a experiência do usuário, reduzindo a necessidade de entrada de dados. Quando você já possui informações do cliente em seu sistema, pode preencher os campos do formulário antes de enviar o documento, permitindo que os usuários revisem e completem apenas os campos restantes.
```csharp
using IronPdf;
using System;
public class CustomerPortalService
{
public byte[] GeneratePreFilledRenewalForm(int customerId)
{
// Simulate fetching customer data from database
var customer = GetCustomerById(customerId);
// Load the renewal form template
PdfDocument pdf = PdfDocument.FromFile("templates/subscription-renewal.pdf");
// Pre-fill known customer information
pdf.Form.FindFormField("customerId").Value = customer.Id.ToString();
pdf.Form.FindFormField("customerName").Value = customer.FullName;
pdf.Form.FindFormField("email").Value = customer.Email;
pdf.Form.FindFormField("phone").Value = customer.Phone;
pdf.Form.FindFormField("address").Value = customer.Address;
pdf.Form.FindFormField("currentPlan").Value = customer.SubscriptionPlan;
pdf.Form.FindFormField("renewalDate").Value = DateTime.Now.AddDays(30).ToString("MM/dd/yyyy");
// Leave editable fields empty for customer input:
// - newPlan (dropdown for plan selection)
// - paymentMethod (radio buttons)
// - additionalNotes (textarea)
// - signature (signature field)
// Return as byte array for web download or email attachment
return pdf.BinaryData;
}
// Simulated data access
private Customer GetCustomerById(int id)
{
return new Customer
{
Id = id,
FullName = "Robert Williams",
Email = "robert.williams@email.com",
Phone = "(555) 987-6543",
Address = "123 Business Park Drive\r\nSuite 400\r\nChicago, IL 60601",
SubscriptionPlan = "Professional"
};
}
}
public class Customer
{
public int Id { get; set; }
public string FullName { get; set; }
public string Email { get; set; }
public string Phone { get; set; }
public string Address { get; set; }
public string SubscriptionPlan { get; set; }
}
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/prefilled-renewal-form.pdf" width="100%" height="400px">
</iframe>
Esse modelo funciona bem para formulários de renovação, atualizações de aplicativos, revisões anuais e qualquer cenário em que já existam informações parciais em seu sistema. O usuário recebe um documento com seus dados já preenchidos, precisando apenas fornecer informações novas ou alterar as que já foram preenchidas.
---
## Construir um Pipeline de Processamento de Dados de Formulários
O processamento em larga escala de formulários submetidos exige uma abordagem estruturada que contemple a extração, validação, transformação e armazenamento dos dados. Um padrão de pipeline simples mantém esse processo organizado e de fácil manutenção.
```csharp
using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
public class FormSubmission
{
public string SubmissionId { get; set; }
public DateTime ReceivedAt { get; set; }
public string SourceFile { get; set; }
public Dictionary<string, string> FormData { get; set; }
public bool IsValid { get; set; }
public List<string> ValidationErrors { get; set; }
}
public class FormProcessingPipeline
{
public FormSubmission ProcessSubmission(string pdfPath)
{
var submission = new FormSubmission
{
SubmissionId = Guid.NewGuid().ToString("N").Substring(0, 8).ToUpper(),
ReceivedAt = DateTime.UtcNow,
SourceFile = Path.GetFileName(pdfPath),
FormData = new Dictionary<string, string>(),
ValidationErrors = new List<string>()
};
// Step 1: Extract form data
PdfDocument pdf = PdfDocument.FromFile(pdfPath);
foreach (var field in pdf.Form)
{
submission.FormData[field.Name] = field.Value ?? string.Empty;
}
// Step 2: Validate required fields
var requiredFields = new[] { "fullName", "email", "signatureDate" };
foreach (var fieldName in requiredFields)
{
if (!submission.FormData.ContainsKey(fieldName) ||
string.IsNullOrWhiteSpace(submission.FormData[fieldName]))
{
submission.ValidationErrors.Add($"Missing required field: {fieldName}");
}
}
submission.IsValid = submission.ValidationErrors.Count == 0;
// Step 3: Return the processed submission
return submission;
}
public void ProcessBatch(string folderPath)
{
var pdfFiles = Directory.GetFiles(folderPath, "*.pdf");
var results = new List<FormSubmission>();
foreach (var file in pdfFiles)
{
try
{
var submission = ProcessSubmission(file);
results.Add(submission);
}
catch (Exception ex)
{
// Handle error for file: ex.Message
}
}
// Summary
int validCount = 0;
int invalidCount = 0;
foreach (var r in results)
{
if (r.IsValid) validCount++;
else invalidCount++;
}
// Results summary: results.Count processed, validCount valid, invalidCount invalid
}
}
```
Essa estrutura de pipeline pode ser expandida para incluir armazenamento em banco de dados, notificações por e-mail, integração com APIs externas ou quaisquer outras etapas de processamento que seu fluxo de trabalho exija. A chave é manter a separação entre extração, validação e processamento subsequente.
Para processamento em lote de alto desempenho, consulte o [Guia de Geração Assíncrona de PDFs](https://ironpdf.com/how-to/async/) , que aborda padrões de multithreading e processamento paralelo.
---
## Automatizar Formulários Fiscais do IRS como o W-9
Os formulários governamentais representam alguns dos cenários de processamento de PDFs de maior volume. O formulário W-9 (Solicitação de Número de Identificação Fiscal) é preenchido milhões de vezes anualmente por empresas que cadastram fornecedores e contratados. Toda empresa que paga a trabalhadores autônomos precisa ter o formulário W-9 arquivado, e automatizar esse processo de coleta pode economizar um tempo administrativo significativo.
```csharp
using IronPdf;
using System;
public class W9FormData
{
public string Name { get; set; }
public string BusinessName { get; set; }
public string FederalTaxClassification { get; set; }
public string ExemptPayeeCode { get; set; }
public string FatcaExemptionCode { get; set; }
public string Address { get; set; }
public string CityStateZip { get; set; }
public string AccountNumbers { get; set; }
public string TaxpayerIdNumber { get; set; }
public DateTime SignatureDate { get; set; }
}
public class W9FormProcessor
{
public void FillW9Form(W9FormData data, string templatePath, string outputPath)
{
PdfDocument pdf = PdfDocument.FromFile(templatePath);
// The W-9 form has specific field names defined by the IRS
// These correspond to the official form structure
// Line 1: Name as shown on your income tax return
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_1[0]", data.Name);
// Line 2: Business name/disregarded entity name
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_2[0]", data.BusinessName);
// Line 3: Federal tax classification (checkbox selection)
// The W-9 uses checkbox fields for classification
switch (data.FederalTaxClassification)
{
case "Individual":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[0]", "1");
break;
case "CCorporation":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[1]", "2");
break;
case "SCorporation":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[2]", "3");
break;
case "Partnership":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[3]", "4");
break;
case "LLC":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[5]", "6");
break;
}
// Line 5: Address
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_7[0]", data.Address);
// Line 6: City, state, and ZIP code
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_8[0]", data.CityStateZip);
// Part I: Taxpayer Identification Number (SSN or EIN)
// For security, typically only last 4 digits are pre-filled or field is left for manual entry
if (!string.IsNullOrEmpty(data.TaxpayerIdNumber) && data.TaxpayerIdNumber.Length >= 4)
{
// TIN left blank for security - user must enter manually
}
// Signature date
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Date[0]",
data.SignatureDate.ToString("MM/dd/yyyy"));
pdf.SaveAs(outputPath);
}
private void SetFieldIfExists(PdfDocument pdf, string fieldName, string value)
{
var field = pdf.Form.FindFormField(fieldName);
if (field != null && !string.IsNullOrEmpty(value))
{
field.Value = value;
}
}
}
// Usage example
class Program
{
static void Main()
{
var vendorData = new W9FormData
{
Name = "Johnson Consulting LLC",
BusinessName = "",
FederalTaxClassification = "LLC",
Address = "456 Commerce Street",
CityStateZip = "Austin, TX 78701",
SignatureDate = DateTime.Today
};
var processor = new W9FormProcessor();
processor.FillW9Form(vendorData, "fw9.pdf", "w9-johnson-consulting.pdf");
}
}
```
Os formulários governamentais frequentemente utilizam convenções complexas de nomenclatura hierárquica para os campos. Os nomes dos campos do formulário W-9 mostrados acima seguem o padrão de nomenclatura derivado do XFA usado nos PDFs oficiais do IRS. Ao trabalhar com formulários governamentais, sempre baixe a versão mais recente do site oficial do órgão e examine a estrutura dos campos antes de escrever o código de automação.
---
## Processamento em Lote de Formulários com Dados Variáveis
O processamento em lote gera vários formulários preenchidos a partir de uma fonte de dados, como uma consulta de banco de dados, um arquivo CSV ou uma resposta de API. Essa funcionalidade se mostra essencial em cenários como a distribuição anual de documentos fiscais, pacotes de integração de funcionários ou geração de extratos para clientes.
```csharp
using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
public class VendorRecord
{
public string VendorId { get; set; }
public string CompanyName { get; set; }
public string ContactName { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string State { get; set; }
public string ZipCode { get; set; }
public string TaxClassification { get; set; }
}
public class BatchFormGenerator
{
private readonly string _templatePath;
private readonly string _outputDirectory;
public BatchFormGenerator(string templatePath, string outputDirectory)
{
_templatePath = templatePath;
_outputDirectory = outputDirectory;
if (!Directory.Exists(_outputDirectory))
{
Directory.CreateDirectory(_outputDirectory);
}
}
public void GenerateVendorForms(List<VendorRecord> vendors)
{
var startTime = DateTime.Now;
int successCount = 0;
int errorCount = 0;
foreach (var vendor in vendors)
{
try
{
GenerateSingleForm(vendor);
successCount++;
}
catch (Exception ex)
{
errorCount++;
// Handle error: ex.Message
}
}
var elapsed = DateTime.Now - startTime;
// Results: successCount successful, errorCount errors, elapsed time
}
private void GenerateSingleForm(VendorRecord vendor)
{
PdfDocument pdf = PdfDocument.FromFile(_templatePath);
// Fill vendor information fields
SetField(pdf, "vendorId", vendor.VendorId);
SetField(pdf, "companyName", vendor.CompanyName);
SetField(pdf, "contactName", vendor.ContactName);
SetField(pdf, "address", vendor.Address);
SetField(pdf, "city", vendor.City);
SetField(pdf, "state", vendor.State);
SetField(pdf, "zipCode", vendor.ZipCode);
SetField(pdf, "taxClassification", vendor.TaxClassification);
SetField(pdf, "generatedDate", DateTime.Today.ToString("MM/dd/yyyy"));
// Create a safe filename from company name
string safeFileName = string.Join("_", vendor.CompanyName.Split(Path.GetInvalidFileNameChars()));
string outputPath = Path.Combine(_outputDirectory, $"vendor-form-{vendor.VendorId}-{safeFileName}.pdf");
pdf.SaveAs(outputPath);
}
private void SetField(PdfDocument pdf, string fieldName, string value)
{
var field = pdf.Form.FindFormField(fieldName);
if (field != null)
{
field.Value = value ?? string.Empty;
}
}
}
// Usage example with sample data
class Program
{
static void Main()
{
var vendors = new List<VendorRecord>
{
new VendorRecord
{
VendorId = "V001",
CompanyName = "Alpha Supplies Inc",
ContactName = "Maria Garcia",
Address = "100 Industrial Way",
City = "Chicago",
State = "IL",
ZipCode = "60601",
TaxClassification = "Corporation"
},
new VendorRecord
{
VendorId = "V002",
CompanyName = "Beta Services LLC",
ContactName = "James Wilson",
Address = "200 Tech Park Drive",
City = "Austin",
State = "TX",
ZipCode = "78701",
TaxClassification = "LLC"
},
new VendorRecord
{
VendorId = "V003",
CompanyName = "Gamma Consulting",
ContactName = "Sarah Chen",
Address = "300 Business Center",
City = "Seattle",
State = "WA",
ZipCode = "98101",
TaxClassification = "Partnership"
}
};
var generator = new BatchFormGenerator("vendor-info-template.pdf", "output/vendor-forms");
generator.GenerateVendorForms(vendors);
}
}
```
Para lotes muito grandes, considere implementar processamento paralelo com concorrência controlada para maximizar a produtividade sem sobrecarregar os recursos do sistema.
---
## Garantir Conformidade com Padrões de PDF Governamentais
Órgãos governamentais frequentemente exigem que documentos atendam a padrões específicos de PDF para arquivamento e acessibilidade a longo prazo. O PDF/A é um subconjunto do PDF padronizado pela ISO, projetado para a preservação confiável de documentos eletrônicos a longo prazo. O IronPDF permite exportar documentos no formato PDF/A para atender a esses requisitos de conformidade.
O código a seguir cria um formulário oficial do governo a partir de HTML, preenche com os dados do candidato, e salva como um documento compatível com PDF/A-3b usando o método `SaveAsPdfA()`. Este formato garante que os documentos permaneçam legíveis por décadas e atende à maioria dos requisitos de envio governamentais.
```csharp
using IronPdf;
using System;
// Create or load a form document
string formHtml = @"
E html>
le>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #003366; }
.form-section { margin: 20px 0; }
label { display: block; margin: 10px 0 5px 0; font-weight: bold; }
input, select { padding: 8px; width: 300px; border: 1px solid #ccc; }
yle>
Official Government Form</h1>
his document complies with PDF/A-3b archival standards.</p>
m>
<div class='form-section'>
<label>Applicant Name</label>
<input type='text' name='applicantName' />
</div>
<div class='form-section'>
<label>Application Date</label>
<input type='text' name='applicationDate' />
</div>
<div class='form-section'>
<label>Department</label>
<select name='department'>
<option value=''>Select Department</option>
<option value='Revenue'>Department of Revenue</option>
<option value='Labor'>Department of Labor</option>
<option value='Commerce'>Department of Commerce</option>
</select>
</div>
rm>
;
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
// Fill form fields
pdf.Form.FindFormField("applicantName").Value = "Government Services Corp";
pdf.Form.FindFormField("applicationDate").Value = DateTime.Today.ToString("MM/dd/yyyy");
pdf.Form.FindFormField("department").Value = "Commerce";
// Convert to PDF/A-3b for archival compliance
pdf.SaveAsPdfA("government-form-archived.pdf", PdfAVersions.PdfA3b);
```
#### Exemplo de saída
<iframe loading="lazy" src="/static-assets/pdf/tutorials/pdf-forms-csharp/government-form-pdfa.pdf" width="100%" height="400px">
</iframe>
O método `SaveAsPdfA()` leva o nome do arquivo de saída e um valor enum `PdfAVersions` (como `PdfA3b`). Durante o processo de salvamento, o IronPDF incorpora automaticamente todas as fontes, padroniza os espaços de cores, remove qualquer criptografia e estrutura os metadados de acordo com os requisitos do PDF/A. Essas transformações garantem que o documento permaneça legível e visualmente idêntico por décadas, independentemente do software que tentar abri-lo.
Ao enviar formulários para órgãos governamentais, verifique os requisitos específicos de cada um. Algumas empresas podem exigir o formato PDF/A-1b para arquivamento básico, enquanto outras especificam o PDF/A-3b para permitir anexos incorporados, como arquivos de dados XML. O IRS, por exemplo, aceita versões específicas em PDF para vários tipos de envio, e os formulários de imigração geralmente têm suas próprias especificações técnicas.
Para obter a documentação completa sobre a conversão de PDF/A, consulte [Converter PDF para PDF/A-3b em C#](https://ironpdf.com/how-to/pdfa/) e o [Guia de Conformidade com PDF/A](https://ironpdf.com/blog/using-ironpdf/pdfa-compliance/) . Para obter informações sobre padrões de acessibilidade, consulte [Criar documentos PDF/UA](https://ironpdf.com/how-to/pdfua/) .
---
## Próximos passos
Agora você tem tudo o que precisa para automatizar aqueles fluxos de trabalho com formulários em PDF que consomem horas de entrada manual de dados. Seja para processar formulários W-9 para integração de fornecedores, preencher previamente formulários de admissão de pacientes a partir do seu sistema EHR ou importar dados de aplicativos enviados para o seu CRM, as técnicas deste guia se aplicam diretamente aos formulários que estão na sua caixa de entrada agora mesmo. Para obter um guia completo sobre os recursos de edição de PDF além de formulários, consulte o [tutorial de edição de PDF](/tutorials/csharp-edit-pdf-complete-tutorial/) .
Para prosseguir, comece [preenchendo e editando um formulário existente que](/how-to/edit-forms/) sua equipe já utiliza, como uma ficha de inscrição de cliente ou um pacote de integração de funcionários, e crie um fluxo de trabalho simples usando a abordagem de dicionário deste guia. A partir daí, [crie novos formulários em HTML](/how-to/create-forms/) para total flexibilidade de design ou adicione [campos de assinatura digital](/how-to/signing/) para formulários que exigem aprovação legal. Quando você precisa atender aos padrões governamentais de arquivamento, o [guia de conformidade com o PDF/A](/how-to/pdfa/) abrange a preservação a longo prazo, e o [guia de acessibilidade do PDF/UA](/how-to/pdfua/) garante que seus formulários sejam aprovados nas auditorias da Seção 508.
Pronto para começar a construir? [Baixe o IronPDF](download-modal) e experimente com um teste gratuito. A mesma biblioteca lida com tudo, desde o preenchimento de formulários individuais até [o processamento em lote de alto volume](/tutorials/batch-pdf-processing-csharp/) em ambientes .NET . Se você tiver dúvidas sobre automação ou integração de formulários, [entre em contato com nossa equipe de suporte técnico](/troubleshooting/engineering-request-pdf/) .
Os AcroForms em PDF em C# .NET com IronPDF oferecem aos desenvolvedores controle programático completo sobre os campos de formulário interativos , desde a leitura e preenchimento de formulários governamentais existentes até a criação de novos formulários a partir de HTML , extração de dados enviados e processamento em lote de milhares de documentos. O IronPDF lida com todos os tipos de campos padrão, incluindo entradas de texto, caixas de seleção , botões de opção, listas suspensas e campos de assinatura, permitindo automatizar todo o ciclo de vida do formulário PDF usando as mesmas habilidades de HTML e CSS que você já possui.
Resumo: Guia de Início Rápido
Este tutorial aborda a criação, o preenchimento e o processamento de formulários PDF interativos em C# .NET, desde a leitura de campos de formulário existentes até a geração em lote de documentos completos.
Para quem é indicado: Desenvolvedores .NET que automatizam fluxos de trabalho com formulários PDF para processos governamentais, de saúde, financeiros ou de RH.
O que você vai desenvolver: Ler e preencher formulários PDF (texto, caixas de seleção, botões de opção, listas suspensas), criar formulários PDF a partir de HTML, extrair dados enviados, validar entradas, consolidar formulários para bloquear valores, automatizar o processamento do formulário W-9 e gerar formulários preenchidos em lote.
Onde funciona: .NET 10, .NET 8 LTS, .NET Framework 4.6.2+ e .NET Standard 2.0. A saída funciona no Adobe Acrobat, Preview e em todos os principais leitores de PDF.
Quando usar essa abordagem: Quando seu aplicativo precisa preencher, criar ou processar formulários PDF em grande escala sem entrada manual de dados.
Por que isso é importante tecnicamente: os campos do AcroForm são objetos estruturados que são previsíveis para leitura e gravação programática. O IronPDF também converte elementos de formulário HTML em seus equivalentes AcroForm, oferecendo total flexibilidade de design.
Preencha seu primeiro formulário em PDF com apenas algumas linhas de código:
1Install IronPDF with NuGet Package Manager
PM > Install-Package IronPdf
Install-Package IronPdf
2Copie e execute este trecho de código.
var pdf = IronPdf.PdfDocument.FromFile("form.pdf");pdf.Form.FindFormField("name").Value = "John Smith";pdf.SaveAs("filled-form.pdf");
var pdf = IronPdf.PdfDocument.FromFile("form.pdf");
pdf.Form.FindFormField("name").Value = "John Smith";
pdf.SaveAs("filled-form.pdf");
Dim pdf = IronPdf.PdfDocument.FromFile("form.pdf")pdf.Form.FindFormField("name").Value = "John Smith"pdf.SaveAs("filled-form.pdf")
Dim pdf = IronPdf.PdfDocument.FromFile("form.pdf")
pdf.Form.FindFormField("name").Value = "John Smith"
pdf.SaveAs("filled-form.pdf")
3Implante para testar em seu ambiente de produção.
Por que os formulários PDF interativos ainda são essenciais em 2025?
Apesar da proliferação de formulários online e soluções de documentos baseadas na nuvem, os formulários em PDF continuam a dominar os processos de negócios críticos. Agências governamentais, prestadores de serviços de saúde, instituições financeiras e escritórios de advocacia dependem muito de formulários em PDF para sua documentação oficial. Somente na área da saúde, 88% dos registros de pacientes são armazenados ou compartilhados em formato PDF. As autoridades fiscais em todo o mundo processam bilhões de formulários anualmente, sendo que a grande maioria chega em formato eletrônico, como documentos em PDF.
Por que esse formato persiste quando existem alternativas aparentemente mais modernas? A resposta reside em uma combinação de requisitos legais, compatibilidade universal e integridade do documento. Os formulários em PDF preservam a formatação exata, independentemente do dispositivo ou sistema operacional usado para visualizá-los. Um formulário preenchido em um computador com Windows aparece idêntico quando aberto em um laptop Mac ou impresso em um órgão público. Essa consistência é extremamente importante quando se trata de documentos legais, registros regulatórios e documentos oficiais, nos quais a formatação precisa pode afetar sua validade.
Os formulários online certamente têm sua utilidade, mas não podem substituir completamente os formulários em PDF por diversos motivos. Muitos órgãos reguladores exigem especificamente o envio de documentos em formato PDF. Os processos judiciais frequentemente exigem documentos em um formato que possa ser arquivado e verificado de forma confiável anos depois. O acesso offline continua sendo importante para trabalhadores de campo, locais remotos e situações em que a conectividade com a internet não pode ser garantida. Além disso, os formulários em PDF podem ser assinados digitalmente, criptografados e rastreados de maneiras que fornecem trilhas de auditoria essenciais para a conformidade.
O mercado de software PDF reflete essa demanda contínua, avaliado em US$ 4,8 bilhões em 2024, com crescimento projetado de 8% a 11% ao ano até 2030. Para os desenvolvedores .NET , isso representa tanto um desafio técnico quanto uma oportunidade significativa. Dominar a automação de formulários PDF significa ser capaz de otimizar fluxos de trabalho que envolvem milhões de documentos em todos os setores.
O que são AcroForms em PDF e como funcionam?
Os AcroForms representam a tecnologia padrão de formulários interativos integrada à especificação PDF. Desenvolvido pela Adobe e agora mantido como um padrão ISO, o AcroForms permite que documentos PDF contenham campos preenchíveis que os usuários podem completar usando qualquer leitor de PDF compatível. Ao abrir um formulário fiscal no Adobe Acrobat ou no Preview e digitar nos campos, você está interagindo com elementos AcroForm incorporados nesse documento.
Cada campo de formulário em um AcroForm possui diversas propriedades importantes. O nome do campo serve como um identificador único que os programas usam para localizar e manipular o campo. O tipo de campo determina o tipo de entrada que o campo aceita, seja texto, caixas de seleção, botões de opção, seleções suspensas ou assinaturas. A propriedade value armazena o conteúdo atual do campo, que pode ser lido ou gravado programaticamente. Propriedades adicionais controlam a aparência, as regras de validação e os valores padrão.
O AcroForms suporta diversos tipos de campos distintos que abrangem a maioria das necessidades de coleta de dados. Os campos de texto aceitam entrada de texto livre e podem ser configurados para linhas únicas ou múltiplas. Os campos de caixa de seleção representam escolhas binárias e podem ser agrupados para permitir múltiplas seleções. Os campos de botões de opção funcionam em grupos, onde selecionar uma opção desmarca automaticamente as outras. As caixas de combinação e as caixas de listagem apresentam opções predefinidas para seleção. Os campos de assinatura fornecem áreas designadas para assinaturas digitais. Compreender esses tipos de campos e como eles se comportam é essencial para uma automação eficaz de formulários.
A estrutura dos AcroForms os torna muito adequados para manipulação programática. Como cada campo possui um nome e um valor, você pode percorrer todos os campos de um documento, ler seus valores atuais e definir novos valores usando um código simples. Essa estrutura previsível possibilita os fluxos de trabalho de automação abordados ao longo deste guia.
Abrir um PDF e Listar Todos os Campos do Formulário
Antes de preencher um formulário PDF programaticamente, você precisa entender sua estrutura. Ao abrir um documento e enumerar seus campos, você verá os nomes dos campos que serão usados para definir valores, juntamente com os tipos de campo e qualquer conteúdo existente. Essa etapa de descoberta se mostra especialmente valiosa ao trabalhar com formulários de terceiros, nos quais você não possui documentação sobre a estrutura interna dos campos.
Entrada PDF
Para este exemplo, usaremos um formulário PDF existente chamado application-form.pdf. Pode ser qualquer PDF que contenha campos de formulário interativos: um formulário governamental, um modelo de inscrição da sua organização ou um documento de terceiros que você precise processar. O código abaixo carrega este arquivo e percorre todos os seus campos de formulário interativos.
using IronPdf;// Load an existing PDF form documentPdfDocument pdfForm = PdfDocument.FromFile("application-form.pdf");// Access the form object and iterate through all fieldsforeach (var field in pdfForm.Form){ // Access field properties: field.Name, field.Type, field.Value, field.ReadOnly}
using IronPdf;
// Load an existing PDF form document
PdfDocument pdfForm = PdfDocument.FromFile("application-form.pdf");
// Access the form object and iterate through all fields
foreach (var field in pdfForm.Form)
{
// Access field properties: field.Name, field.Type, field.Value, field.ReadOnly
}
ImportsIronPdf' Load an existing PDF form documentDim pdfForm AsPdfDocument = PdfDocument.FromFile("application-form.pdf")' Access the form object and iterate through all fieldsFor Each field In pdfForm.Form ' Access field properties: field.Name, field.Type, field.Value, field.ReadOnlyNext
Imports IronPdf
' Load an existing PDF form document
Dim pdfForm As PdfDocument = PdfDocument.FromFile("application-form.pdf")
' Access the form object and iterate through all fields
For Each field In pdfForm.Form
' Access field properties: field.Name, field.Type, field.Value, field.ReadOnly
Next
O método PdfDocument.FromFile() carrega o PDF na memória, e a coleção Form fornece acesso a todos os campos interativos no documento. Cada campo expõe propriedades como Name (o identificador único usado para acesso programático), Type (campo de texto, caixa de seleção, botão de rádio, dropdown ou assinatura), Value (o conteúdo atual), e ReadOnly (se o campo pode ser modificado). Executar essa enumeração em um formulário desconhecido fornece o inventário completo de campos necessário para escrever um código que o preencha corretamente.
Para formulários com muitos campos, você pode filtrar por tipo ou pesquisar por nomes de campos específicos. O método FindFormField localiza um campo pelo nome exato, lançando uma exceção se não houver correspondência. Utilize blocos try-catch quando não tiver certeza se um campo existe.
using IronPdf;using System;PdfDocument pdfForm = PdfDocument.FromFile("employee-onboarding.pdf");// Find specific fields by name - use try-catch for fields that may not existtry{ var firstNameField = pdfForm.Form.FindFormField("firstName"); // Use firstNameField.Value to get or set the field value}catch (Exception){ // Field not found in this document}// For fields you know exist, you can access them directlyvar lastNameField = pdfForm.Form.FindFormField("lastName");var departmentField = pdfForm.Form.FindFormField("department");
using IronPdf;
using System;
PdfDocument pdfForm = PdfDocument.FromFile("employee-onboarding.pdf");
// Find specific fields by name - use try-catch for fields that may not exist
try
{
var firstNameField = pdfForm.Form.FindFormField("firstName");
// Use firstNameField.Value to get or set the field value
}
catch (Exception)
{
// Field not found in this document
}
// For fields you know exist, you can access them directly
var lastNameField = pdfForm.Form.FindFormField("lastName");
var departmentField = pdfForm.Form.FindFormField("department");
ImportsIronPdfImportsSystemDim pdfForm AsPdfDocument = PdfDocument.FromFile("employee-onboarding.pdf")' Find specific fields by name - use try-catch for fields that may not existTry Dim firstNameField = pdfForm.Form.FindFormField("firstName") ' Use firstNameField.Value to get or set the field valueCatch ex AsException ' Field not found in this documentEndTry' For fields you know exist, you can access them directlyDim lastNameField = pdfForm.Form.FindFormField("lastName")Dim departmentField = pdfForm.Form.FindFormField("department")
Imports IronPdf
Imports System
Dim pdfForm As PdfDocument = PdfDocument.FromFile("employee-onboarding.pdf")
' Find specific fields by name - use try-catch for fields that may not exist
Try
Dim firstNameField = pdfForm.Form.FindFormField("firstName")
' Use firstNameField.Value to get or set the field value
Catch ex As Exception
' Field not found in this document
End Try
' For fields you know exist, you can access them directly
Dim lastNameField = pdfForm.Form.FindFormField("lastName")
Dim departmentField = pdfForm.Form.FindFormField("department")
Preencher Campos de Texto, Caixas de Seleção e Listas Suspensas
Depois de conhecer os nomes dos campos em um formulário PDF, preenchê-los requer apenas algumas linhas de código. Cada tipo de campo aceita valores em um formato específico. Os campos de texto aceitam valores de string diretamente. As caixas de seleção usam "Sim" para indicar que estão marcadas e "Não" para indicar que não estão. Os botões de opção aceitam o valor da opção selecionada. Os campos suspensos aceitam qualquer valor de sua lista de opções predefinidas.
Entrada PDF
Trabalharemos com um formulário de registro de cliente (customer-registration.pdf) que contém vários tipos de campo: campos de texto para nome, email, telefone e endereço; uma caixa de seleção para optar por receber a newsletter; e um menu suspenso para seleção do tipo de conta. Este exemplo carrega o formulário e preenche cada campo com dados de clientes de amostra.
using IronPdf;// Load the form documentPdfDocument pdf = PdfDocument.FromFile("customer-registration.pdf");// Fill text fields with customer informationpdf.Form.FindFormField("fullName").Value = "Sarah Johnson";pdf.Form.FindFormField("email").Value = "sarah.johnson@example.com";pdf.Form.FindFormField("phone").Value = "(555) 123-4567";pdf.Form.FindFormField("address").Value = "742 Evergreen Terrace\r\nSpringfield, IL 62701";// Check a checkbox fieldpdf.Form.FindFormField("newsletterOptIn").Value = "Yes";// Select an option from a dropdownpdf.Form.FindFormField("accountType").Value = "Premium";// Save the filled formpdf.SaveAs("customer-registration-completed.pdf");
using IronPdf;
// Load the form document
PdfDocument pdf = PdfDocument.FromFile("customer-registration.pdf");
// Fill text fields with customer information
pdf.Form.FindFormField("fullName").Value = "Sarah Johnson";
pdf.Form.FindFormField("email").Value = "sarah.johnson@example.com";
pdf.Form.FindFormField("phone").Value = "(555) 123-4567";
pdf.Form.FindFormField("address").Value = "742 Evergreen Terrace\r\nSpringfield, IL 62701";
// Check a checkbox field
pdf.Form.FindFormField("newsletterOptIn").Value = "Yes";
// Select an option from a dropdown
pdf.Form.FindFormField("accountType").Value = "Premium";
// Save the filled form
pdf.SaveAs("customer-registration-completed.pdf");
ImportsIronPdf' Load the form documentDim pdf AsPdfDocument = PdfDocument.FromFile("customer-registration.pdf")' Fill text fields with customer informationpdf.Form.FindFormField("fullName").Value = "Sarah Johnson"pdf.Form.FindFormField("email").Value = "sarah.johnson@example.com"pdf.Form.FindFormField("phone").Value = "(555) 123-4567"pdf.Form.FindFormField("address").Value = "742 Evergreen Terrace" & vbCrLf & "Springfield, IL 62701"' Check a checkbox fieldpdf.Form.FindFormField("newsletterOptIn").Value = "Yes"' Select an option from a dropdownpdf.Form.FindFormField("accountType").Value = "Premium"' Save the filled formpdf.SaveAs("customer-registration-completed.pdf")
Imports IronPdf
' Load the form document
Dim pdf As PdfDocument = PdfDocument.FromFile("customer-registration.pdf")
' Fill text fields with customer information
pdf.Form.FindFormField("fullName").Value = "Sarah Johnson"
pdf.Form.FindFormField("email").Value = "sarah.johnson@example.com"
pdf.Form.FindFormField("phone").Value = "(555) 123-4567"
pdf.Form.FindFormField("address").Value = "742 Evergreen Terrace" & vbCrLf & "Springfield, IL 62701"
' Check a checkbox field
pdf.Form.FindFormField("newsletterOptIn").Value = "Yes"
' Select an option from a dropdown
pdf.Form.FindFormField("accountType").Value = "Premium"
' Save the filled form
pdf.SaveAs("customer-registration-completed.pdf")
Exemplo de saída
O método FindFormField() localiza cada campo pelo nome exato, e definir a propriedade Value popula o conteúdo do campo. Observe o uso de \r\n para quebras de linha no campo de endereço. As áreas de texto com várias linhas interpretam essas sequências de escape corretamente, permitindo formatar endereços, comentários e outros conteúdos que se estendem por várias linhas. Para caixas de seleção, os valores "Sim" e "Não" alternam o estado selecionado, enquanto as listas suspensas aceitam qualquer valor que corresponda a uma de suas opções predefinidas.
Ao trabalhar com botões de opção, é necessário compreender que todos os botões em um grupo compartilham o mesmo nome de campo. Definir o valor seleciona a opção correspondente e desmarca todas as outras desse grupo.
using IronPdf;PdfDocument pdf = PdfDocument.FromFile("survey-form.pdf");// Get a radio button group and examine its optionsvar satisfactionField = pdf.Form.FindFormField("satisfactionLevel");// Access available options from the radio button annotationsforeach (var annotation in satisfactionField.Annotations){ // annotation.OnAppearance contains the option value}// Select one option from the groupsatisfactionField.Value = "Very Satisfied";pdf.SaveAs("survey-completed.pdf");
using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("survey-form.pdf");
// Get a radio button group and examine its options
var satisfactionField = pdf.Form.FindFormField("satisfactionLevel");
// Access available options from the radio button annotations
foreach (var annotation in satisfactionField.Annotations)
{
// annotation.OnAppearance contains the option value
}
// Select one option from the group
satisfactionField.Value = "Very Satisfied";
pdf.SaveAs("survey-completed.pdf");
ImportsIronPdfDim pdf AsPdfDocument = PdfDocument.FromFile("survey-form.pdf")' Get a radio button group and examine its optionsDim satisfactionField = pdf.Form.FindFormField("satisfactionLevel")' Access available options from the radio button annotationsFor Each annotation In satisfactionField.Annotations ' annotation.OnAppearance contains the option valueNext' Select one option from the groupsatisfactionField.Value = "Very Satisfied"pdf.SaveAs("survey-completed.pdf")
Imports IronPdf
Dim pdf As PdfDocument = PdfDocument.FromFile("survey-form.pdf")
' Get a radio button group and examine its options
Dim satisfactionField = pdf.Form.FindFormField("satisfactionLevel")
' Access available options from the radio button annotations
For Each annotation In satisfactionField.Annotations
' annotation.OnAppearance contains the option value
Next
' Select one option from the group
satisfactionField.Value = "Very Satisfied"
pdf.SaveAs("survey-completed.pdf")
Os campos suspensos funcionam de maneira semelhante. Você pode examinar as escolhas disponíveis através da propriedade Choices antes de definir um valor, garantindo que seu código apenas tente selecionar opções válidas.
using IronPdf;PdfDocument pdf = PdfDocument.FromFile("order-form.pdf");var shippingMethod = pdf.Form.FindFormField("shippingMethod");// Access all available shipping options via shippingMethod.Choices// Select express shippingshippingMethod.Value = "Express (2-3 days)";pdf.SaveAs("order-form-filled.pdf");
using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("order-form.pdf");
var shippingMethod = pdf.Form.FindFormField("shippingMethod");
// Access all available shipping options via shippingMethod.Choices
// Select express shipping
shippingMethod.Value = "Express (2-3 days)";
pdf.SaveAs("order-form-filled.pdf");
ImportsIronPdfDim pdf AsPdfDocument = PdfDocument.FromFile("order-form.pdf")Dim shippingMethod = pdf.Form.FindFormField("shippingMethod")' Access all available shipping options via shippingMethod.Choices' Select express shippingshippingMethod.Value = "Express (2-3 days)"pdf.SaveAs("order-form-filled.pdf")
Imports IronPdf
Dim pdf As PdfDocument = PdfDocument.FromFile("order-form.pdf")
Dim shippingMethod = pdf.Form.FindFormField("shippingMethod")
' Access all available shipping options via shippingMethod.Choices
' Select express shipping
shippingMethod.Value = "Express (2-3 days)"
pdf.SaveAs("order-form-filled.pdf")
Preenchendo Formulários a partir de Objetos de Dados e Dicionários
Aplicações do mundo real raramente codificam valores de formulário diretamente no código. Em vez disso, os dados provêm de bancos de dados, respostas de API, entrada do usuário ou arquivos de configuração. Organizar esses dados em dicionários ou objetos personalizados torna o código de preenchimento de formulários mais fácil de manter e reutilizar.
Entrada PDF
Considere um formulário de solicitação de empréstimo (loan-application.pdf) contendo campos para informações do solicitante: nome, data de nascimento, SSN, campos de endereço, status de emprego, renda anual, e uma caixa de seleção de acordo com os termos. O código a seguir preenche o formulário usando dados armazenados em um Dictionary<string, string>, onde cada chave do dicionário corresponde a um nome de campo do formulário.
using IronPdf;using System.Collections.Generic;// Form data stored in a dictionaryvar formData = new Dictionary<string, string>{ { "applicantName", "Michael Chen" }, { "dateOfBirth", "1985-03-15" }, { "ssn", "XXX-XX-1234" }, { "streetAddress", "456 Oak Avenue" }, { "city", "Portland" }, { "state", "OR" }, { "zipCode", "97201" }, { "employmentStatus", "Full-Time" }, { "annualIncome", "75000" }, { "agreeToTerms", "Yes" }};PdfDocument pdf = PdfDocument.FromFile("loan-application.pdf");// Iterate through the dictionary and fill matching fieldsforeach (var entry in formData){ var field = pdf.Form.FindFormField(entry.Key); if (field != null) { field.Value = entry.Value; }}pdf.SaveAs("loan-application-filled.pdf");
using IronPdf;
using System.Collections.Generic;
// Form data stored in a dictionary
var formData = new Dictionary<string, string>
{
{ "applicantName", "Michael Chen" },
{ "dateOfBirth", "1985-03-15" },
{ "ssn", "XXX-XX-1234" },
{ "streetAddress", "456 Oak Avenue" },
{ "city", "Portland" },
{ "state", "OR" },
{ "zipCode", "97201" },
{ "employmentStatus", "Full-Time" },
{ "annualIncome", "75000" },
{ "agreeToTerms", "Yes" }
};
PdfDocument pdf = PdfDocument.FromFile("loan-application.pdf");
// Iterate through the dictionary and fill matching fields
foreach (var entry in formData)
{
var field = pdf.Form.FindFormField(entry.Key);
if (field != null)
{
field.Value = entry.Value;
}
}
pdf.SaveAs("loan-application-filled.pdf");
ImportsIronPdfImportsSystem.Collections.Generic' Form data stored in a dictionaryDim formData As New Dictionary(OfString, String) From { {"applicantName", "Michael Chen"}, {"dateOfBirth", "1985-03-15"}, {"ssn", "XXX-XX-1234"}, {"streetAddress", "456 Oak Avenue"}, {"city", "Portland"}, {"state", "OR"}, {"zipCode", "97201"}, {"employmentStatus", "Full-Time"}, {"annualIncome", "75000"}, {"agreeToTerms", "Yes"}}Dim pdf AsPdfDocument = PdfDocument.FromFile("loan-application.pdf")' Iterate through the dictionary and fill matching fieldsFor Each entry In formData Dim field = pdf.Form.FindFormField(entry.Key) If field IsNot Nothing Then field.Value = entry.Value End IfNextpdf.SaveAs("loan-application-filled.pdf")
Imports IronPdf
Imports System.Collections.Generic
' Form data stored in a dictionary
Dim formData As New Dictionary(Of String, String) From {
{"applicantName", "Michael Chen"},
{"dateOfBirth", "1985-03-15"},
{"ssn", "XXX-XX-1234"},
{"streetAddress", "456 Oak Avenue"},
{"city", "Portland"},
{"state", "OR"},
{"zipCode", "97201"},
{"employmentStatus", "Full-Time"},
{"annualIncome", "75000"},
{"agreeToTerms", "Yes"}
}
Dim pdf As PdfDocument = PdfDocument.FromFile("loan-application.pdf")
' Iterate through the dictionary and fill matching fields
For Each entry In formData
Dim field = pdf.Form.FindFormField(entry.Key)
If field IsNot Nothing Then
field.Value = entry.Value
End If
Next
pdf.SaveAs("loan-application-filled.pdf")
Exemplo de saída
A abordagem baseada em dicionário separa claramente os dados da lógica. O loop foreach itera através de cada par chave-valor, usa FindFormField() para localizar o campo correspondente no PDF, e atribui o valor se o campo existir. A verificação de nulo (if (field != null)) impede exceções quando o dicionário contém chaves que não correspondem a nenhum campo no documento. Isso é particularmente útil ao trabalhar com fontes de dados que podem incluir campos extras não presentes no formulário.
Para cenários mais complexos, você pode definir uma classe que represente os dados do formulário e, em seguida, usar reflexão ou uma função de mapeamento para transferir os valores das propriedades para os campos do formulário.
using IronPdf;using System;// Define a strongly-typed class for the form datapublic class EmployeeRecord{ public stringFirstName { get; set; } public stringLastName { get; set; } public stringEmployeeId { get; set; } public stringDepartment { get; set; } public DateTimeHireDate { get; set; } public stringJobTitle { get; set; } public boolDirectDeposit { get; set; }}public class FormFiller{ public voidFillEmployeeForm(EmployeeRecord employee, string templatePath, string outputPath) { PdfDocument pdf = PdfDocument.FromFile(templatePath); // Map object properties to form fields pdf.Form.FindFormField("firstName").Value = employee.FirstName; pdf.Form.FindFormField("lastName").Value = employee.LastName; pdf.Form.FindFormField("employeeId").Value = employee.EmployeeId; pdf.Form.FindFormField("department").Value = employee.Department; pdf.Form.FindFormField("hireDate").Value = employee.HireDate.ToString("MM/dd/yyyy"); pdf.Form.FindFormField("jobTitle").Value = employee.JobTitle; pdf.Form.FindFormField("directDeposit").Value = employee.DirectDeposit ? "Yes" : "No"; pdf.SaveAs(outputPath); }}// Usage exampleclass Program{ static voidMain() { var employee = new EmployeeRecord {FirstName = "Jennifer",LastName = "Martinez",EmployeeId = "EMP-2024-0892",Department = "Engineering",HireDate = new DateTime(2024, 6, 15),JobTitle = "Senior Developer",DirectDeposit = true }; var filler = new FormFiller(); filler.FillEmployeeForm(employee, "new-hire-form.pdf", "jennifer-martinez-onboarding.pdf"); }}
using IronPdf;
using System;
// Define a strongly-typed class for the form data
public class EmployeeRecord
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string EmployeeId { get; set; }
public string Department { get; set; }
public DateTime HireDate { get; set; }
public string JobTitle { get; set; }
public bool DirectDeposit { get; set; }
}
public class FormFiller
{
public void FillEmployeeForm(EmployeeRecord employee, string templatePath, string outputPath)
{
PdfDocument pdf = PdfDocument.FromFile(templatePath);
// Map object properties to form fields
pdf.Form.FindFormField("firstName").Value = employee.FirstName;
pdf.Form.FindFormField("lastName").Value = employee.LastName;
pdf.Form.FindFormField("employeeId").Value = employee.EmployeeId;
pdf.Form.FindFormField("department").Value = employee.Department;
pdf.Form.FindFormField("hireDate").Value = employee.HireDate.ToString("MM/dd/yyyy");
pdf.Form.FindFormField("jobTitle").Value = employee.JobTitle;
pdf.Form.FindFormField("directDeposit").Value = employee.DirectDeposit ? "Yes" : "No";
pdf.SaveAs(outputPath);
}
}
// Usage example
class Program
{
static void Main()
{
var employee = new EmployeeRecord
{
FirstName = "Jennifer",
LastName = "Martinez",
EmployeeId = "EMP-2024-0892",
Department = "Engineering",
HireDate = new DateTime(2024, 6, 15),
JobTitle = "Senior Developer",
DirectDeposit = true
};
var filler = new FormFiller();
filler.FillEmployeeForm(employee, "new-hire-form.pdf", "jennifer-martinez-onboarding.pdf");
}
}
ImportsIronPdfImportsSystem' Define a strongly-typed class for the form dataPublic Class EmployeeRecord Public Property FirstNameAsString Public Property LastNameAsString Public Property EmployeeIdAsString Public Property DepartmentAsString Public Property HireDateAsDateTime Public Property JobTitleAsString Public Property DirectDepositAsBooleanEnd ClassPublic Class FormFiller Public Sub FillEmployeeForm(employee AsEmployeeRecord, templatePath AsString, outputPath AsString) Dim pdf AsPdfDocument = PdfDocument.FromFile(templatePath) ' Map object properties to form fields pdf.Form.FindFormField("firstName").Value = employee.FirstName pdf.Form.FindFormField("lastName").Value = employee.LastName pdf.Form.FindFormField("employeeId").Value = employee.EmployeeId pdf.Form.FindFormField("department").Value = employee.Department pdf.Form.FindFormField("hireDate").Value = employee.HireDate.ToString("MM/dd/yyyy") pdf.Form.FindFormField("jobTitle").Value = employee.JobTitle pdf.Form.FindFormField("directDeposit").Value = If(employee.DirectDeposit, "Yes", "No") pdf.SaveAs(outputPath) End SubEnd Class' Usage exampleClass ProgramShared Sub Main() Dim employee As New EmployeeRecordWith { .FirstName = "Jennifer", .LastName = "Martinez", .EmployeeId = "EMP-2024-0892", .Department = "Engineering", .HireDate = New DateTime(2024, 6, 15), .JobTitle = "Senior Developer", .DirectDeposit = True } Dim filler As New FormFiller() filler.FillEmployeeForm(employee, "new-hire-form.pdf", "jennifer-martinez-onboarding.pdf") End SubEnd Class
Imports IronPdf
Imports System
' Define a strongly-typed class for the form data
Public Class EmployeeRecord
Public Property FirstName As String
Public Property LastName As String
Public Property EmployeeId As String
Public Property Department As String
Public Property HireDate As DateTime
Public Property JobTitle As String
Public Property DirectDeposit As Boolean
End Class
Public Class FormFiller
Public Sub FillEmployeeForm(employee As EmployeeRecord, templatePath As String, outputPath As String)
Dim pdf As PdfDocument = PdfDocument.FromFile(templatePath)
' Map object properties to form fields
pdf.Form.FindFormField("firstName").Value = employee.FirstName
pdf.Form.FindFormField("lastName").Value = employee.LastName
pdf.Form.FindFormField("employeeId").Value = employee.EmployeeId
pdf.Form.FindFormField("department").Value = employee.Department
pdf.Form.FindFormField("hireDate").Value = employee.HireDate.ToString("MM/dd/yyyy")
pdf.Form.FindFormField("jobTitle").Value = employee.JobTitle
pdf.Form.FindFormField("directDeposit").Value = If(employee.DirectDeposit, "Yes", "No")
pdf.SaveAs(outputPath)
End Sub
End Class
' Usage example
Class Program
Shared Sub Main()
Dim employee As New EmployeeRecord With {
.FirstName = "Jennifer",
.LastName = "Martinez",
.EmployeeId = "EMP-2024-0892",
.Department = "Engineering",
.HireDate = New DateTime(2024, 6, 15),
.JobTitle = "Senior Developer",
.DirectDeposit = True
}
Dim filler As New FormFiller()
filler.FillEmployeeForm(employee, "new-hire-form.pdf", "jennifer-martinez-onboarding.pdf")
End Sub
End Class
Exemplo de saída
Validar Dados do Formulário Antes de Preencher
Antes de preencher um formulário em PDF, validar os dados ajuda a detectar erros precocemente e garante que o documento resultante atenda aos requisitos. Embora os formulários em PDF possam incluir suas próprias regras de validação, confiar exclusivamente nessas regras significa que os erros só aparecem no final do processamento. Implementar a validação no seu código C# oferece mais controle e mensagens de erro mais claras.
using IronPdf;using System;using System.Collections.Generic;using System.Text.RegularExpressions;public class FormValidationResult{ public boolIsValid { get; set; } public List<string> Errors { get; set; } = new List<string>();}public class FormValidator{ public FormValidationResultValidateApplicationData(Dictionary<string, string> formData, PdfDocument pdf) { var result = new FormValidationResult { IsValid = true }; // Check that all required fields have values var requiredFields = new[] { "applicantName", "email", "phone", "ssn" }; foreach (var fieldName in requiredFields) { if (!formData.ContainsKey(fieldName) || string.IsNullOrWhiteSpace(formData[fieldName])) { result.Errors.Add($"Required field '{fieldName}' is missing or empty"); result.IsValid = false; } } // Validate email format if (formData.ContainsKey("email")) { var emailPattern = @"^[^@\s]+@[^@\s]+\.[^@\s]+$"; if (!Regex.IsMatch(formData["email"], emailPattern)) { result.Errors.Add("Email address format is invalid"); result.IsValid = false; } } // Validate phone number format if (formData.ContainsKey("phone")) { var phonePattern = @"^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$"; if (!Regex.IsMatch(formData["phone"], phonePattern)) { result.Errors.Add("Phone number format is invalid"); result.IsValid = false; } } // Verify that form fields exist in the PDF foreach (var fieldName in formData.Keys) { try { var field = pdf.Form.FindFormField(fieldName); // Field exists } catch { result.Errors.Add($"Field '{fieldName}' does not exist in the PDF form"); result.IsValid = false; } } // Check dropdown values against available choices if (formData.ContainsKey("state")) { try { var stateField = pdf.Form.FindFormField("state"); if (stateField.Choices != null) { bool validChoice = false; foreach (var choice in stateField.Choices) { if (choice == formData["state"]) { validChoice = true; break; } } if (!validChoice) { result.Errors.Add($"'{formData["state"]}' is not a valid option for the state field"); result.IsValid = false; } } } catch { // State field doesn't exist, skip validation } } return result; }}// Usage exampleclass Program{ static voidMain() { var formData = new Dictionary<string, string> { { "applicantName", "John Doe" }, { "email", "invalid-email" }, { "phone", "555-1234" }, { "state", "XX" } }; PdfDocument pdf = PdfDocument.FromFile("application.pdf"); var validator = new FormValidator(); var validationResult = validator.ValidateApplicationData(formData, pdf); if (validationResult.IsValid) { // Proceed with form fill } else { // Handle validation errors in validationResult.Errors } }}
using IronPdf;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
public class FormValidationResult
{
public bool IsValid { get; set; }
public List<string> Errors { get; set; } = new List<string>();
}
public class FormValidator
{
public FormValidationResult ValidateApplicationData(Dictionary<string, string> formData, PdfDocument pdf)
{
var result = new FormValidationResult { IsValid = true };
// Check that all required fields have values
var requiredFields = new[] { "applicantName", "email", "phone", "ssn" };
foreach (var fieldName in requiredFields)
{
if (!formData.ContainsKey(fieldName) || string.IsNullOrWhiteSpace(formData[fieldName]))
{
result.Errors.Add($"Required field '{fieldName}' is missing or empty");
result.IsValid = false;
}
}
// Validate email format
if (formData.ContainsKey("email"))
{
var emailPattern = @"^[^@\s]+@[^@\s]+\.[^@\s]+$";
if (!Regex.IsMatch(formData["email"], emailPattern))
{
result.Errors.Add("Email address format is invalid");
result.IsValid = false;
}
}
// Validate phone number format
if (formData.ContainsKey("phone"))
{
var phonePattern = @"^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$";
if (!Regex.IsMatch(formData["phone"], phonePattern))
{
result.Errors.Add("Phone number format is invalid");
result.IsValid = false;
}
}
// Verify that form fields exist in the PDF
foreach (var fieldName in formData.Keys)
{
try
{
var field = pdf.Form.FindFormField(fieldName);
// Field exists
}
catch
{
result.Errors.Add($"Field '{fieldName}' does not exist in the PDF form");
result.IsValid = false;
}
}
// Check dropdown values against available choices
if (formData.ContainsKey("state"))
{
try
{
var stateField = pdf.Form.FindFormField("state");
if (stateField.Choices != null)
{
bool validChoice = false;
foreach (var choice in stateField.Choices)
{
if (choice == formData["state"])
{
validChoice = true;
break;
}
}
if (!validChoice)
{
result.Errors.Add($"'{formData["state"]}' is not a valid option for the state field");
result.IsValid = false;
}
}
}
catch
{
// State field doesn't exist, skip validation
}
}
return result;
}
}
// Usage example
class Program
{
static void Main()
{
var formData = new Dictionary<string, string>
{
{ "applicantName", "John Doe" },
{ "email", "invalid-email" },
{ "phone", "555-1234" },
{ "state", "XX" }
};
PdfDocument pdf = PdfDocument.FromFile("application.pdf");
var validator = new FormValidator();
var validationResult = validator.ValidateApplicationData(formData, pdf);
if (validationResult.IsValid)
{
// Proceed with form fill
}
else
{
// Handle validation errors in validationResult.Errors
}
}
}
ImportsIronPdfImportsSystemImportsSystem.Collections.GenericImportsSystem.Text.RegularExpressionsPublic Class FormValidationResult Public Property IsValidAsBoolean Public Property ErrorsAsList(OfString) = New List(OfString)()End ClassPublic Class FormValidator Public Function ValidateApplicationData(formData AsDictionary(OfString, String), pdf AsPdfDocument) AsFormValidationResult Dim result = New FormValidationResultWith { .IsValid = True } ' Check that all required fields have values Dim requiredFields = New String() {"applicantName", "email", "phone", "ssn"} For Each fieldName In requiredFields IfNot formData.ContainsKey(fieldName) OrElseString.IsNullOrWhiteSpace(formData(fieldName)) Then result.Errors.Add($"Required field '{fieldName}' is missing or empty") result.IsValid = False End If Next ' Validate email format If formData.ContainsKey("email") Then Dim emailPattern = "^[^@\s]+@[^@\s]+\.[^@\s]+$" IfNotRegex.IsMatch(formData("email"), emailPattern) Then result.Errors.Add("Email address format is invalid") result.IsValid = False End If End If ' Validate phone number format If formData.ContainsKey("phone") Then Dim phonePattern = "^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$" IfNotRegex.IsMatch(formData("phone"), phonePattern) Then result.Errors.Add("Phone number format is invalid") result.IsValid = False End If End If ' Verify that form fields exist in the PDF For Each fieldName In formData.KeysTry Dim field = pdf.Form.FindFormField(fieldName) ' Field existsCatch result.Errors.Add($"Field '{fieldName}' does not exist in the PDF form") result.IsValid = FalseEndTry Next ' Check dropdown values against available choices If formData.ContainsKey("state") ThenTry Dim stateField = pdf.Form.FindFormField("state") If stateField.ChoicesIsNot Nothing Then Dim validChoice AsBoolean = False For Each choice In stateField.Choices If choice = formData("state") Then validChoice = True Exit For End If Next IfNot validChoice Then result.Errors.Add($"'{formData("state")}' is not a valid option for the state field") result.IsValid = False End If End IfCatch ' State field doesn't exist, skip validationEndTry End If Return result End FunctionEnd Class' Usage exampleClass ProgramShared Sub Main() Dim formData = New Dictionary(OfString, String) From { {"applicantName", "John Doe"}, {"email", "invalid-email"}, {"phone", "555-1234"}, {"state", "XX"} } Dim pdf AsPdfDocument = PdfDocument.FromFile("application.pdf") Dim validator = New FormValidator() Dim validationResult = validator.ValidateApplicationData(formData, pdf) If validationResult.IsValidThen ' Proceed with form fill Else ' Handle validation errors in validationResult.Errors End If End SubEnd Class
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Text.RegularExpressions
Public Class FormValidationResult
Public Property IsValid As Boolean
Public Property Errors As List(Of String) = New List(Of String)()
End Class
Public Class FormValidator
Public Function ValidateApplicationData(formData As Dictionary(Of String, String), pdf As PdfDocument) As FormValidationResult
Dim result = New FormValidationResult With {
.IsValid = True
}
' Check that all required fields have values
Dim requiredFields = New String() {"applicantName", "email", "phone", "ssn"}
For Each fieldName In requiredFields
If Not formData.ContainsKey(fieldName) OrElse String.IsNullOrWhiteSpace(formData(fieldName)) Then
result.Errors.Add($"Required field '{fieldName}' is missing or empty")
result.IsValid = False
End If
Next
' Validate email format
If formData.ContainsKey("email") Then
Dim emailPattern = "^[^@\s]+@[^@\s]+\.[^@\s]+$"
If Not Regex.IsMatch(formData("email"), emailPattern) Then
result.Errors.Add("Email address format is invalid")
result.IsValid = False
End If
End If
' Validate phone number format
If formData.ContainsKey("phone") Then
Dim phonePattern = "^\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$"
If Not Regex.IsMatch(formData("phone"), phonePattern) Then
result.Errors.Add("Phone number format is invalid")
result.IsValid = False
End If
End If
' Verify that form fields exist in the PDF
For Each fieldName In formData.Keys
Try
Dim field = pdf.Form.FindFormField(fieldName)
' Field exists
Catch
result.Errors.Add($"Field '{fieldName}' does not exist in the PDF form")
result.IsValid = False
End Try
Next
' Check dropdown values against available choices
If formData.ContainsKey("state") Then
Try
Dim stateField = pdf.Form.FindFormField("state")
If stateField.Choices IsNot Nothing Then
Dim validChoice As Boolean = False
For Each choice In stateField.Choices
If choice = formData("state") Then
validChoice = True
Exit For
End If
Next
If Not validChoice Then
result.Errors.Add($"'{formData("state")}' is not a valid option for the state field")
result.IsValid = False
End If
End If
Catch
' State field doesn't exist, skip validation
End Try
End If
Return result
End Function
End Class
' Usage example
Class Program
Shared Sub Main()
Dim formData = New Dictionary(Of String, String) From {
{"applicantName", "John Doe"},
{"email", "invalid-email"},
{"phone", "555-1234"},
{"state", "XX"}
}
Dim pdf As PdfDocument = PdfDocument.FromFile("application.pdf")
Dim validator = New FormValidator()
Dim validationResult = validator.ValidateApplicationData(formData, pdf)
If validationResult.IsValid Then
' Proceed with form fill
Else
' Handle validation errors in validationResult.Errors
End If
End Sub
End Class
Essa camada de validação verifica se há campos obrigatórios ausentes, valida padrões de formatação para tipos de dados comuns, confirma se os valores especificados nas listas suspensas existem nas opções do formulário e verifica se todos os nomes de campo nos seus dados realmente existem no PDF. Identificar esses problemas antes de tentar preencher o formulário evita preenchimentos parciais e facilita muito a depuração.
Criar Campos de Entrada de Texto em um Formulário PDF
Criar formulários em PDF do zero oferece controle total sobre a estrutura e a aparência do formulário. O mecanismo de renderização HTML-para-PDF do IronPDF interpreta elementos de formulário HTML padrão e os converte em campos AcroForm do PDF. Essa abordagem permite que você crie formulários usando tecnologias web familiares, incluindo CSS para estilização. Para obter o guia completo sobre como criar formulários, consulte Criar formulários PDF em C# .
O código a seguir cria um formulário de feedback do cliente com campos de entrada de texto e uma área de texto, usando HTML e CSS para definir a estrutura e o estilo do formulário. O PDF gerado contém campos de formulário preenchíveis que os usuários podem completar em qualquer leitor de PDF.
using IronPdf;// Define the form layout using HTML with form elementsstring formHtml = @"E html>le>body { font-family: Arial, sans-serif; max-width: 600px; margin: 40px auto; padding: 20px;}h1 { color: #333; border-bottom: 2px solid #4CAF50; padding-bottom: 10px;}.form-group { margin-bottom: 15px;}label { display: block; margin-bottom: 5px; font-weight: bold; color: #555;}input[type='text'], textarea { width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box;}textarea { height: 100px; resize: none;}.required::after { content: ' *'; color: red;}yle>Customer Feedback Form</h1>m><div class='form-group'> <label class='required'>Full Name</label> <input type='text' name='customerName' /></div><div class='form-group'> <label class='required'>Email Address</label> <input type='text' name='customerEmail' /></div><div class='form-group'> <label>Phone Number</label> <input type='text' name='customerPhone' /></div><div class='form-group'> <label>Order Number</label> <input type='text' name='orderNumber' /></div><div class='form-group'> <label class='required'>Your Feedback</label> <textarea name='feedbackText'></textarea></div>rm>;// Create the renderer and enable form creationChromePdfRenderer renderer = new ChromePdfRenderer();renderer.RenderingOptions.CreatePdfFormsFromHtml = true;// Render the HTML to a PDF with interactive form fieldsPdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);pdf.SaveAs("customer-feedback-form.pdf");
using IronPdf;
// Define the form layout using HTML with form elements
string formHtml = @"
E html>
le>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 40px auto;
padding: 20px;
}
h1 {
color: #333;
border-bottom: 2px solid #4CAF50;
padding-bottom: 10px;
}
.form-group {
margin-bottom: 15px;
}
label {
display: block;
margin-bottom: 5px;
font-weight: bold;
color: #555;
}
input[type='text'], textarea {
width: 100%;
padding: 8px;
border: 1px solid #ddd;
border-radius: 4px;
box-sizing: border-box;
}
textarea {
height: 100px;
resize: none;
}
.required::after {
content: ' *';
color: red;
}
yle>
Customer Feedback Form</h1>
m>
<div class='form-group'>
<label class='required'>Full Name</label>
<input type='text' name='customerName' />
</div>
<div class='form-group'>
<label class='required'>Email Address</label>
<input type='text' name='customerEmail' />
</div>
<div class='form-group'>
<label>Phone Number</label>
<input type='text' name='customerPhone' />
</div>
<div class='form-group'>
<label>Order Number</label>
<input type='text' name='orderNumber' />
</div>
<div class='form-group'>
<label class='required'>Your Feedback</label>
<textarea name='feedbackText'></textarea>
</div>
rm>
;
// Create the renderer and enable form creation
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
// Render the HTML to a PDF with interactive form fields
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("customer-feedback-form.pdf");
ImportsIronPdf' Define the form layout using HTML with form elementsDim formHtml AsString = "<!DOCTYPE html><html><head> <style> body { font-family: Arial, sans-serif; max-width: 600px; margin: 40px auto; padding: 20px; } h1 { color: #333; border-bottom: 2px solid #4CAF50; padding-bottom: 10px; } .form-group { margin-bottom: 15px; } label { display: block; margin-bottom: 5px; font-weight: bold; color: #555; } input[type='text'], textarea { width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box; } textarea { height: 100px; resize: none; } .required::after { content: ' *'; color: red; } </style></head><body> <h1>Customer Feedback Form</h1> <form> <div class='form-group'> <label class='required'>Full Name</label> <input type='text' name='customerName' /> </div> <div class='form-group'> <label class='required'>Email Address</label> <input type='text' name='customerEmail' /> </div> <div class='form-group'> <label>Phone Number</label> <input type='text' name='customerPhone' /> </div> <div class='form-group'> <label>Order Number</label> <input type='text' name='orderNumber' /> </div> <div class='form-group'> <label class='required'>Your Feedback</label> <textarea name='feedbackText'></textarea> </div> </form></body></html>"' Create the renderer and enable form creationDim renderer As New ChromePdfRenderer()renderer.RenderingOptions.CreatePdfFormsFromHtml = True' Render the HTML to a PDF with interactive form fieldsDim pdf AsPdfDocument = renderer.RenderHtmlAsPdf(formHtml)pdf.SaveAs("customer-feedback-form.pdf")
Imports IronPdf
' Define the form layout using HTML with form elements
Dim formHtml As String = "
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 40px auto;
padding: 20px;
}
h1 {
color: #333;
border-bottom: 2px solid #4CAF50;
padding-bottom: 10px;
}
.form-group {
margin-bottom: 15px;
}
label {
display: block;
margin-bottom: 5px;
font-weight: bold;
color: #555;
}
input[type='text'], textarea {
width: 100%;
padding: 8px;
border: 1px solid #ddd;
border-radius: 4px;
box-sizing: border-box;
}
textarea {
height: 100px;
resize: none;
}
.required::after {
content: ' *';
color: red;
}
</style>
</head>
<body>
<h1>Customer Feedback Form</h1>
<form>
<div class='form-group'>
<label class='required'>Full Name</label>
<input type='text' name='customerName' />
</div>
<div class='form-group'>
<label class='required'>Email Address</label>
<input type='text' name='customerEmail' />
</div>
<div class='form-group'>
<label>Phone Number</label>
<input type='text' name='customerPhone' />
</div>
<div class='form-group'>
<label>Order Number</label>
<input type='text' name='orderNumber' />
</div>
<div class='form-group'>
<label class='required'>Your Feedback</label>
<textarea name='feedbackText'></textarea>
</div>
</form>
</body>
</html>
"
' Create the renderer and enable form creation
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
' Render the HTML to a PDF with interactive form fields
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)
pdf.SaveAs("customer-feedback-form.pdf")
Exemplo de saída
A configuração da chave é CreatePdfFormsFromHtml = true no RenderingOptions, que instrui o ChromePdfRenderer a converter elementos HTML <input> e <textarea> em seus equivalentes PDF AcroForm. Sem essa configuração, os campos de entrada seriam exibidos como elementos visuais estáticos, sem interatividade. O atributo name em cada elemento de entrada se torna o nome do campo no PDF resultante. Esses são os identificadores que você usará ao preencher o formulário programaticamente. Escolha nomes descritivos e consistentes que tornem o código de preenchimento de formulários legível e fácil de manter. Para mais informações sobre conversão de HTML para PDF, consulte o tutorial Converter HTML para PDF em C# .
Adicionar Caixas de Seleção e Botões de Rádio a Formulários PDF
As caixas de seleção e os botões de opção capturam a entrada baseada em seleção. No HTML, caixas de seleção usam type='checkbox' enquanto botões de rádio usam type='radio'. Os botões de opção que compartilham o mesmo atributo de nome formam automaticamente um grupo mutuamente exclusivo.
Este trecho de código cria um formulário de inscrição para eventos com várias caixas de seleção para preferências alimentares e botões de opção para seleção do tipo de ingresso. A estrutura HTML define o layout do formulário, enquanto o CSS fornece o estilo.
Observe que os três botões de rádio compartilham name='ticketType', criando um grupo onde apenas uma opção pode ser selecionada. Cada caixa de seleção tem um nome único porque representa opções independentes que podem ser selecionadas em qualquer combinação.
Criar Listas Suspensas em Formulários PDF
Listas suspensas economizam espaço e oferecem várias opções predefinidas. O elemento HTML <select> com filhos <option> cria um campo de combobox PDF. Os usuários clicam no campo para revelar a lista de opções e selecionam uma delas.
Aqui, criamos um formulário de candidatura a emprego com vários menus suspensos para seleção de departamento, nível de experiência, data de início preferencial e local de trabalho. Cada elemento <select> contém valores <option> predefinidos.
O primeiro <option> em cada elemento select (com um valor vazio) serve como um prompt de espaço reservado como "Select Department". Quando o PDF é renderizado, esses campos se transformam em caixas de combinação nas quais os usuários podem clicar para revelar a lista completa de opções. Ao preencher este formulário programaticamente, defina o valor do campo para corresponder exatamente a um dos valores das opções, como "Engenharia" ou "Remoto".
Minha biblioteca favorita desse tipo é o IronPDF. Ele permite a manipulação rápida e eficiente de arquivos PDF. Além disso, possui muitos recursos valiosos, como a exportação para o formato PDF/A e a assinatura digital de documentos PDF.
Com o IronOCR, podemos economizar US$ 40.000 por ano em processamento manual, ao mesmo tempo que aumentamos a produtividade e liberamos recursos para tarefas de alto impacto. Eu o recomendo fortemente.
Os campos de assinatura designam áreas onde os usuários podem aplicar assinaturas digitais. Embora o HTML não possua um tipo de entrada de assinatura nativo, o IronPDF permite adicionar campos de assinatura programaticamente a qualquer documento PDF.
O código abaixo primeiro cria um documento de Acordo de Confidencialidade a partir de HTML, depois adiciona programaticamente um SignatureFormField em uma posição específica na página. O campo de assinatura é posicionado usando coordenadas PDF (x, y, largura, altura em pontos).
using IronPdf;using IronSoftware.Forms;// First create the base form using HTMLstring formHtml = @"E html>le>body { font-family: Arial, sans-serif; max-width: 600px; margin: 40px auto; padding: 30px;}h1 { text-align: center; color: #2c3e50;}.agreement-text { background: #f5f5f5; padding: 20px; border-radius: 5px; margin: 20px 0; line-height: 1.6;}.signature-section { margin-top: 40px; padding-top: 20px; border-top: 1px solid #ddd;}.signature-line { margin-top: 60px; border-bottom: 1px solid #333; width: 300px;}.signature-label { font-size: 12px; color: #666; margin-top: 5px;}.date-field { margin-top: 20px;}.date-field label { font-weight: bold;}.date-field input { padding: 8px; border: 1px solid #ccc; border-radius: 4px; width: 150px;}yle>Non-Disclosure Agreement</h1> class='agreement-text'><p>By signing this document, I acknowledge that I have read and understoodthe terms of the Non-Disclosure Agreement dated as of the date signed below.I agree to maintain the confidentiality of all proprietary informationdisclosed to me during my engagement with the Company.</p><p>I understand that violation of this agreement may result in legal actionand that I am bound by these terms for a period of five (5) years from thedate of signature.</p>v> class='signature-section'><div class='date-field'> <label>Date:</label> <input type='text' name='signatureDate' /></div><div class='signature-line'></div><div class='signature-label'>Authorized Signature</div>v>;ChromePdfRenderer renderer = new ChromePdfRenderer();renderer.RenderingOptions.CreatePdfFormsFromHtml = true;PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);// Add a signature field programmatically// Parameters: name, page index, x position, y position, width, heightSignatureFormField signatureField = new SignatureFormField( "authorizedSignature", // Field name 0, // Page index (first page) 72, // X position in points from left 200, // Y position in points from bottom 250, // Width in points 60 // Height in points);pdf.Form.Add(signatureField);pdf.SaveAs("nda-with-signature.pdf");
using IronPdf;
using IronSoftware.Forms;
// First create the base form using HTML
string formHtml = @"
E html>
le>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 40px auto;
padding: 30px;
}
h1 {
text-align: center;
color: #2c3e50;
}
.agreement-text {
background: #f5f5f5;
padding: 20px;
border-radius: 5px;
margin: 20px 0;
line-height: 1.6;
}
.signature-section {
margin-top: 40px;
padding-top: 20px;
border-top: 1px solid #ddd;
}
.signature-line {
margin-top: 60px;
border-bottom: 1px solid #333;
width: 300px;
}
.signature-label {
font-size: 12px;
color: #666;
margin-top: 5px;
}
.date-field {
margin-top: 20px;
}
.date-field label {
font-weight: bold;
}
.date-field input {
padding: 8px;
border: 1px solid #ccc;
border-radius: 4px;
width: 150px;
}
yle>
Non-Disclosure Agreement</h1>
class='agreement-text'>
<p>By signing this document, I acknowledge that I have read and understood
the terms of the Non-Disclosure Agreement dated as of the date signed below.
I agree to maintain the confidentiality of all proprietary information
disclosed to me during my engagement with the Company.</p>
<p>I understand that violation of this agreement may result in legal action
and that I am bound by these terms for a period of five (5) years from the
date of signature.</p>
v>
class='signature-section'>
<div class='date-field'>
<label>Date:</label>
<input type='text' name='signatureDate' />
</div>
<div class='signature-line'></div>
<div class='signature-label'>Authorized Signature</div>
v>
;
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
// Add a signature field programmatically
// Parameters: name, page index, x position, y position, width, height
SignatureFormField signatureField = new SignatureFormField(
"authorizedSignature", // Field name
0, // Page index (first page)
72, // X position in points from left
200, // Y position in points from bottom
250, // Width in points
60 // Height in points
);
pdf.Form.Add(signatureField);
pdf.SaveAs("nda-with-signature.pdf");
ImportsIronPdfImportsIronSoftware.Forms' First create the base form using HTMLDim formHtml AsString = "<!DOCTYPE html><html><head> <style> body { font-family: Arial, sans-serif; max-width: 600px; margin: 40px auto; padding: 30px; } h1 { text-align: center; color: #2c3e50; } .agreement-text { background: #f5f5f5; padding: 20px; border-radius: 5px; margin: 20px 0; line-height: 1.6; } .signature-section { margin-top: 40px; padding-top: 20px; border-top: 1px solid #ddd; } .signature-line { margin-top: 60px; border-bottom: 1px solid #333; width: 300px; } .signature-label { font-size: 12px; color: #666; margin-top: 5px; } .date-field { margin-top: 20px; } .date-field label { font-weight: bold; } .date-field input { padding: 8px; border: 1px solid #ccc; border-radius: 4px; width: 150px; } </style></head><body> <h1>Non-Disclosure Agreement</h1> <div class='agreement-text'> <p>By signing this document, I acknowledge that I have read and understood the terms of the Non-Disclosure Agreement dated as of the date signed below. I agree to maintain the confidentiality of all proprietary information disclosed to me during my engagement with the Company.</p> <p>I understand that violation of this agreement may result in legal action and that I am bound by these terms for a period of five (5) years from the date of signature.</p> </div> <div class='signature-section'> <div class='date-field'> <label>Date:</label> <input type='text' name='signatureDate' /> </div> <div class='signature-line'></div> <div class='signature-label'>Authorized Signature</div> </div></body></html>"Dim renderer As New ChromePdfRenderer()renderer.RenderingOptions.CreatePdfFormsFromHtml = TrueDim pdf AsPdfDocument = renderer.RenderHtmlAsPdf(formHtml)' Add a signature field programmatically' Parameters: name, page index, x position, y position, width, heightDim signatureField As New SignatureFormField( "authorizedSignature", ' Field name 0, ' Page index (first page) 72, ' X position in points from left 200, ' Y position in points from bottom 250, ' Width in points 60 ' Height in points)pdf.Form.Add(signatureField)pdf.SaveAs("nda-with-signature.pdf")
Imports IronPdf
Imports IronSoftware.Forms
' First create the base form using HTML
Dim formHtml As String = "
<!DOCTYPE html>
<html>
<head>
<style>
body {
font-family: Arial, sans-serif;
max-width: 600px;
margin: 40px auto;
padding: 30px;
}
h1 {
text-align: center;
color: #2c3e50;
}
.agreement-text {
background: #f5f5f5;
padding: 20px;
border-radius: 5px;
margin: 20px 0;
line-height: 1.6;
}
.signature-section {
margin-top: 40px;
padding-top: 20px;
border-top: 1px solid #ddd;
}
.signature-line {
margin-top: 60px;
border-bottom: 1px solid #333;
width: 300px;
}
.signature-label {
font-size: 12px;
color: #666;
margin-top: 5px;
}
.date-field {
margin-top: 20px;
}
.date-field label {
font-weight: bold;
}
.date-field input {
padding: 8px;
border: 1px solid #ccc;
border-radius: 4px;
width: 150px;
}
</style>
</head>
<body>
<h1>Non-Disclosure Agreement</h1>
<div class='agreement-text'>
<p>By signing this document, I acknowledge that I have read and understood the terms of the Non-Disclosure Agreement dated as of the date signed below. I agree to maintain the confidentiality of all proprietary information disclosed to me during my engagement with the Company.</p>
<p>I understand that violation of this agreement may result in legal action and that I am bound by these terms for a period of five (5) years from the date of signature.</p>
</div>
<div class='signature-section'>
<div class='date-field'>
<label>Date:</label>
<input type='text' name='signatureDate' />
</div>
<div class='signature-line'></div>
<div class='signature-label'>Authorized Signature</div>
</div>
</body>
</html>"
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)
' Add a signature field programmatically
' Parameters: name, page index, x position, y position, width, height
Dim signatureField As New SignatureFormField(
"authorizedSignature", ' Field name
0, ' Page index (first page)
72, ' X position in points from left
200, ' Y position in points from bottom
250, ' Width in points
60 ' Height in points
)
pdf.Form.Add(signatureField)
pdf.SaveAs("nda-with-signature.pdf")
Exemplo de saída
O construtor SignatureFormField leva seis parâmetros: o nome do campo ("authorizedSignature"), índice da página (0 para a primeira página), e a posição/tamanho em pontos (x=72, y=200, largura=250, altura=60). As coordenadas do PDF têm origem no canto inferior esquerdo da página, com 72 pontos por polegada. O campo de assinatura aparece como uma área interativa em leitores de PDF que suportam assinaturas digitais. Os usuários podem clicar neste campo para aplicar uma assinatura baseada em certificado.
O CSS oferece amplo controle sobre a aparência do formulário ao criar PDFs a partir de HTML. Você pode ajustar cores, fontes, bordas, espaçamento e layout para combinar com a identidade visual da sua organização ou atender a requisitos de design específicos.
Este trecho de código cria um formulário de solicitação de contato visualmente refinado usando recursos avançados de CSS, incluindo fontes do Google, fundos gradientes, CSS Grid para layouts de duas colunas e estilos personalizados para os campos do formulário, com cantos arredondados e estados de foco.
O HTML usa a fonte Inter do Google Fonts (@import url(...)), aplica um fundo gradiente ao corpo, e estiliza o contêiner de formulário com cantos arredondados e uma sombra. O RenderingOptions define todas as margens para zero e usa tamanho de papel A4 para garantir que o gradiente preencha toda a página. Apesar do estilo sofisticado, todos os campos do formulário permanecem totalmente interativos no PDF resultante. Os usuários podem clicar e digitar em cada campo.
Após os usuários preencherem um formulário em PDF, seu aplicativo precisa recuperar os valores inseridos para processamento, armazenamento ou transferência para outros sistemas. A extração de dados de formulários inverte o processo de preenchimento, lendo os valores dos campos em vez de escrevê-los.
Entrada PDF
Imagine que você recebeu um formulário de inscrição completo (completed-application.pdf) que um usuário já preencheu. Este é um cenário comum em que você recebe formulários enviados por e-mail, upload de arquivos ou sistema de gerenciamento de documentos e precisa extrair os dados para armazenamento em banco de dados ou processamento posterior. O código abaixo carrega o formulário preenchido e extrai todos os valores dos campos para um dicionário.
using IronPdf;using System.Collections.Generic;// Load a filled PDF formPdfDocument filledForm = PdfDocument.FromFile("completed-application.pdf");// Extract all form data into a dictionaryvar extractedData = new Dictionary<string, string>();foreach (var field in filledForm.Form){ extractedData[field.Name] = field.Value ?? string.Empty;}// Access extracted data// extractedData.GetValueOrDefault("firstName")// extractedData.GetValueOrDefault("lastName")// extractedData.GetValueOrDefault("email")// extractedData.GetValueOrDefault("department")
using IronPdf;
using System.Collections.Generic;
// Load a filled PDF form
PdfDocument filledForm = PdfDocument.FromFile("completed-application.pdf");
// Extract all form data into a dictionary
var extractedData = new Dictionary<string, string>();
foreach (var field in filledForm.Form)
{
extractedData[field.Name] = field.Value ?? string.Empty;
}
// Access extracted data
// extractedData.GetValueOrDefault("firstName")
// extractedData.GetValueOrDefault("lastName")
// extractedData.GetValueOrDefault("email")
// extractedData.GetValueOrDefault("department")
ImportsIronPdfImportsSystem.Collections.Generic' Load a filled PDF formDim filledForm AsPdfDocument = PdfDocument.FromFile("completed-application.pdf")' Extract all form data into a dictionaryDim extractedData As New Dictionary(OfString, String)()For Each field In filledForm.Form extractedData(field.Name) = If(field.Value, String.Empty)Next' Access extracted data' extractedData.GetValueOrDefault("firstName")' extractedData.GetValueOrDefault("lastName")' extractedData.GetValueOrDefault("email")' extractedData.GetValueOrDefault("department")
Imports IronPdf
Imports System.Collections.Generic
' Load a filled PDF form
Dim filledForm As PdfDocument = PdfDocument.FromFile("completed-application.pdf")
' Extract all form data into a dictionary
Dim extractedData As New Dictionary(Of String, String)()
For Each field In filledForm.Form
extractedData(field.Name) = If(field.Value, String.Empty)
Next
' Access extracted data
' extractedData.GetValueOrDefault("firstName")
' extractedData.GetValueOrDefault("lastName")
' extractedData.GetValueOrDefault("email")
' extractedData.GetValueOrDefault("department")
O processo de extração itera através da coleção Form, lendo cada propriedade Name e Value do campo. O operador de coalescência nula (?? string.Empty` garante que campos vazios ou não definidos retornem uma string vazia em vez de nulo, evitando problemas de referência nula no processamento subsequente. Uma vez extraído, o dicionário proporciona fácil acesso a qualquer valor de campo usando seu nome como chave.
Para uma extração mais estruturada, você pode mapear os campos do formulário diretamente para um objeto fortemente tipado.
using IronPdf;using System;public class ApplicationData{ public stringFirstName { get; set; } public stringLastName { get; set; } public stringEmail { get; set; } public stringPhone { get; set; } public stringDepartment { get; set; } public stringExperienceLevel { get; set; } public boolAcceptsTerms { get; set; }}public class FormDataExtractor{ public ApplicationDataExtractApplicationData(string pdfPath) { PdfDocument pdf = PdfDocument.FromFile(pdfPath); return new ApplicationData {FirstName = GetFieldValue(pdf, "firstName"),LastName = GetFieldValue(pdf, "lastName"),Email = GetFieldValue(pdf, "email"),Phone = GetFieldValue(pdf, "phone"),Department = GetFieldValue(pdf, "department"),ExperienceLevel = GetFieldValue(pdf, "experienceLevel"),AcceptsTerms = GetFieldValue(pdf, "acceptTerms") == "Yes" }; } private stringGetFieldValue(PdfDocument pdf, string fieldName) { var field = pdf.Form.FindFormField(fieldName); return field?.Value ?? string.Empty; }}// Usageclass Program{ static voidMain() { var extractor = new FormDataExtractor(); var application = extractor.ExtractApplicationData("submitted-form.pdf"); // Access application.FirstName, application.LastName, application.Department, etc. }}
using IronPdf;
using System;
public class ApplicationData
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string Email { get; set; }
public string Phone { get; set; }
public string Department { get; set; }
public string ExperienceLevel { get; set; }
public bool AcceptsTerms { get; set; }
}
public class FormDataExtractor
{
public ApplicationData ExtractApplicationData(string pdfPath)
{
PdfDocument pdf = PdfDocument.FromFile(pdfPath);
return new ApplicationData
{
FirstName = GetFieldValue(pdf, "firstName"),
LastName = GetFieldValue(pdf, "lastName"),
Email = GetFieldValue(pdf, "email"),
Phone = GetFieldValue(pdf, "phone"),
Department = GetFieldValue(pdf, "department"),
ExperienceLevel = GetFieldValue(pdf, "experienceLevel"),
AcceptsTerms = GetFieldValue(pdf, "acceptTerms") == "Yes"
};
}
private string GetFieldValue(PdfDocument pdf, string fieldName)
{
var field = pdf.Form.FindFormField(fieldName);
return field?.Value ?? string.Empty;
}
}
// Usage
class Program
{
static void Main()
{
var extractor = new FormDataExtractor();
var application = extractor.ExtractApplicationData("submitted-form.pdf");
// Access application.FirstName, application.LastName, application.Department, etc.
}
}
ImportsIronPdfImportsSystemPublic Class ApplicationData Public Property FirstNameAsString Public Property LastNameAsString Public Property EmailAsString Public Property PhoneAsString Public Property DepartmentAsString Public Property ExperienceLevelAsString Public Property AcceptsTermsAsBooleanEnd ClassPublic Class FormDataExtractor Public Function ExtractApplicationData(pdfPath AsString) AsApplicationData Dim pdf AsPdfDocument = PdfDocument.FromFile(pdfPath) Return New ApplicationDataWith { .FirstName = GetFieldValue(pdf, "firstName"), .LastName = GetFieldValue(pdf, "lastName"), .Email = GetFieldValue(pdf, "email"), .Phone = GetFieldValue(pdf, "phone"), .Department = GetFieldValue(pdf, "department"), .ExperienceLevel = GetFieldValue(pdf, "experienceLevel"), .AcceptsTerms = GetFieldValue(pdf, "acceptTerms") = "Yes" } End Function Private Function GetFieldValue(pdf AsPdfDocument, fieldName AsString) AsString Dim field = pdf.Form.FindFormField(fieldName) Return If(field?.Value, String.Empty) End FunctionEnd Class' UsageModuleProgram Sub Main() Dim extractor = New FormDataExtractor() Dim application = extractor.ExtractApplicationData("submitted-form.pdf") ' Access application.FirstName, application.LastName, application.Department, etc. End SubEndModule
Imports IronPdf
Imports System
Public Class ApplicationData
Public Property FirstName As String
Public Property LastName As String
Public Property Email As String
Public Property Phone As String
Public Property Department As String
Public Property ExperienceLevel As String
Public Property AcceptsTerms As Boolean
End Class
Public Class FormDataExtractor
Public Function ExtractApplicationData(pdfPath As String) As ApplicationData
Dim pdf As PdfDocument = PdfDocument.FromFile(pdfPath)
Return New ApplicationData With {
.FirstName = GetFieldValue(pdf, "firstName"),
.LastName = GetFieldValue(pdf, "lastName"),
.Email = GetFieldValue(pdf, "email"),
.Phone = GetFieldValue(pdf, "phone"),
.Department = GetFieldValue(pdf, "department"),
.ExperienceLevel = GetFieldValue(pdf, "experienceLevel"),
.AcceptsTerms = GetFieldValue(pdf, "acceptTerms") = "Yes"
}
End Function
Private Function GetFieldValue(pdf As PdfDocument, fieldName As String) As String
Dim field = pdf.Form.FindFormField(fieldName)
Return If(field?.Value, String.Empty)
End Function
End Class
' Usage
Module Program
Sub Main()
Dim extractor = New FormDataExtractor()
Dim application = extractor.ExtractApplicationData("submitted-form.pdf")
' Access application.FirstName, application.LastName, application.Department, etc.
End Sub
End Module
Achatar um Formulário PDF para Bloquear Valores de Campos
Aplanar um formulário PDF converte campos interativos em conteúdo estático. A aparência visual permanece idêntica, mas os usuários não podem mais editar os valores. Essa técnica serve a vários propósitos: criar registros permanentes de formulários preenchidos, preparar documentos para arquivamento e evitar modificações acidentais ou intencionais após o envio.
Entrada PDF
Aqui usaremos um modelo de contrato (contract-template.pdf) contendo campos para nome do cliente, data do contrato, valor do contrato e termos de pagamento. Isso espelha um fluxo de trabalho típico, no qual você preenche um modelo com informações específicas da negociação e, em seguida, bloqueia os campos para criar um documento finalizado e inviolável. O código a seguir carrega o modelo, preenche os detalhes do contrato e define todos os campos como somente leitura.
using IronPdf;// Load and fill the formPdfDocument pdf = PdfDocument.FromFile("contract-template.pdf");pdf.Form.FindFormField("clientName").Value = "Acme Corporation";pdf.Form.FindFormField("contractDate").Value = "January 15, 2025";pdf.Form.FindFormField("contractValue").Value = "$50,000";pdf.Form.FindFormField("paymentTerms").Value = "Net 30";// Make all form fields read-only to prevent further editingforeach (var field in pdf.Form){ field.ReadOnly = true;}// Save the document with locked fieldspdf.SaveAs("contract-acme-signed.pdf");
using IronPdf;
// Load and fill the form
PdfDocument pdf = PdfDocument.FromFile("contract-template.pdf");
pdf.Form.FindFormField("clientName").Value = "Acme Corporation";
pdf.Form.FindFormField("contractDate").Value = "January 15, 2025";
pdf.Form.FindFormField("contractValue").Value = "$50,000";
pdf.Form.FindFormField("paymentTerms").Value = "Net 30";
// Make all form fields read-only to prevent further editing
foreach (var field in pdf.Form)
{
field.ReadOnly = true;
}
// Save the document with locked fields
pdf.SaveAs("contract-acme-signed.pdf");
ImportsIronPdf' Load and fill the formDim pdf AsPdfDocument = PdfDocument.FromFile("contract-template.pdf")pdf.Form.FindFormField("clientName").Value = "Acme Corporation"pdf.Form.FindFormField("contractDate").Value = "January 15, 2025"pdf.Form.FindFormField("contractValue").Value = "$50,000"pdf.Form.FindFormField("paymentTerms").Value = "Net 30"' Make all form fields read-only to prevent further editingFor Each field In pdf.Form field.ReadOnly = TrueNext' Save the document with locked fieldspdf.SaveAs("contract-acme-signed.pdf")
Imports IronPdf
' Load and fill the form
Dim pdf As PdfDocument = PdfDocument.FromFile("contract-template.pdf")
pdf.Form.FindFormField("clientName").Value = "Acme Corporation"
pdf.Form.FindFormField("contractDate").Value = "January 15, 2025"
pdf.Form.FindFormField("contractValue").Value = "$50,000"
pdf.Form.FindFormField("paymentTerms").Value = "Net 30"
' Make all form fields read-only to prevent further editing
For Each field In pdf.Form
field.ReadOnly = True
Next
' Save the document with locked fields
pdf.SaveAs("contract-acme-signed.pdf")
Exemplo de saída
O código primeiro preenche campos como clientName, contractDate, contractValue, e paymentTerms com os detalhes do contrato. O loop foreach então itera através de cada campo no formulário e define field.ReadOnly = true, que bloqueia cada campo contra edições adicionais. Após salvar, os usuários ainda poderão visualizar os valores do formulário em qualquer leitor de PDF, mas clicar nos campos não permitirá a modificação. Essa técnica cria registros permanentes adequados para fins de arquivo ou documentação legal.
Pré-preencher Formulários PDF para Usuários Finais
O preenchimento prévio de formulários com informações já conhecidas melhora a experiência do usuário, reduzindo a necessidade de entrada de dados. Quando você já possui informações do cliente em seu sistema, pode preencher os campos do formulário antes de enviar o documento, permitindo que os usuários revisem e completem apenas os campos restantes.
using IronPdf;using System;public class CustomerPortalService{ public byte[] GeneratePreFilledRenewalForm(int customerId) { // Simulate fetching customer data from database var customer = GetCustomerById(customerId); // Load the renewal form template PdfDocument pdf = PdfDocument.FromFile("templates/subscription-renewal.pdf"); // Pre-fill known customer information pdf.Form.FindFormField("customerId").Value = customer.Id.ToString(); pdf.Form.FindFormField("customerName").Value = customer.FullName; pdf.Form.FindFormField("email").Value = customer.Email; pdf.Form.FindFormField("phone").Value = customer.Phone; pdf.Form.FindFormField("address").Value = customer.Address; pdf.Form.FindFormField("currentPlan").Value = customer.SubscriptionPlan; pdf.Form.FindFormField("renewalDate").Value = DateTime.Now.AddDays(30).ToString("MM/dd/yyyy"); // Leave editable fields empty for customer input: // - newPlan (dropdown for plan selection) // - paymentMethod (radio buttons) // - additionalNotes (textarea) // - signature (signature field) // Return as byte array for web download or email attachment return pdf.BinaryData; } // Simulated data access private CustomerGetCustomerById(int id) { return new Customer {Id = id,FullName = "Robert Williams",Email = "robert.williams@email.com",Phone = "(555) 987-6543",Address = "123 Business Park Drive\r\nSuite 400\r\nChicago, IL 60601",SubscriptionPlan = "Professional" }; }}public class Customer{ public intId { get; set; } public stringFullName { get; set; } public stringEmail { get; set; } public stringPhone { get; set; } public stringAddress { get; set; } public stringSubscriptionPlan { get; set; }}
using IronPdf;
using System;
public class CustomerPortalService
{
public byte[] GeneratePreFilledRenewalForm(int customerId)
{
// Simulate fetching customer data from database
var customer = GetCustomerById(customerId);
// Load the renewal form template
PdfDocument pdf = PdfDocument.FromFile("templates/subscription-renewal.pdf");
// Pre-fill known customer information
pdf.Form.FindFormField("customerId").Value = customer.Id.ToString();
pdf.Form.FindFormField("customerName").Value = customer.FullName;
pdf.Form.FindFormField("email").Value = customer.Email;
pdf.Form.FindFormField("phone").Value = customer.Phone;
pdf.Form.FindFormField("address").Value = customer.Address;
pdf.Form.FindFormField("currentPlan").Value = customer.SubscriptionPlan;
pdf.Form.FindFormField("renewalDate").Value = DateTime.Now.AddDays(30).ToString("MM/dd/yyyy");
// Leave editable fields empty for customer input:
// - newPlan (dropdown for plan selection)
// - paymentMethod (radio buttons)
// - additionalNotes (textarea)
// - signature (signature field)
// Return as byte array for web download or email attachment
return pdf.BinaryData;
}
// Simulated data access
private Customer GetCustomerById(int id)
{
return new Customer
{
Id = id,
FullName = "Robert Williams",
Email = "robert.williams@email.com",
Phone = "(555) 987-6543",
Address = "123 Business Park Drive\r\nSuite 400\r\nChicago, IL 60601",
SubscriptionPlan = "Professional"
};
}
}
public class Customer
{
public int Id { get; set; }
public string FullName { get; set; }
public string Email { get; set; }
public string Phone { get; set; }
public string Address { get; set; }
public string SubscriptionPlan { get; set; }
}
ImportsIronPdfImportsSystemPublic Class CustomerPortalService Public Function GeneratePreFilledRenewalForm(customerId AsInteger) AsByte() ' Simulate fetching customer data from database Dim customer = GetCustomerById(customerId) ' Load the renewal form template Dim pdf AsPdfDocument = PdfDocument.FromFile("templates/subscription-renewal.pdf") ' Pre-fill known customer information pdf.Form.FindFormField("customerId").Value = customer.Id.ToString() pdf.Form.FindFormField("customerName").Value = customer.FullName pdf.Form.FindFormField("email").Value = customer.Email pdf.Form.FindFormField("phone").Value = customer.Phone pdf.Form.FindFormField("address").Value = customer.Address pdf.Form.FindFormField("currentPlan").Value = customer.SubscriptionPlan pdf.Form.FindFormField("renewalDate").Value = DateTime.Now.AddDays(30).ToString("MM/dd/yyyy") ' Leave editable fields empty for customer input: ' - newPlan (dropdown for plan selection) ' - paymentMethod (radio buttons) ' - additionalNotes (textarea) ' - signature (signature field) ' Return as byte array for web download or email attachment Return pdf.BinaryData End Function ' Simulated data access Private Function GetCustomerById(id AsInteger) AsCustomer Return New CustomerWith { .Id = id, .FullName = "Robert Williams", .Email = "robert.williams@email.com", .Phone = "(555) 987-6543", .Address = "123 Business Park Drive" & vbCrLf & "Suite 400" & vbCrLf & "Chicago, IL 60601", .SubscriptionPlan = "Professional" } End FunctionEnd ClassPublic Class Customer Public Property IdAsInteger Public Property FullNameAsString Public Property EmailAsString Public Property PhoneAsString Public Property AddressAsString Public Property SubscriptionPlanAsStringEnd Class
Imports IronPdf
Imports System
Public Class CustomerPortalService
Public Function GeneratePreFilledRenewalForm(customerId As Integer) As Byte()
' Simulate fetching customer data from database
Dim customer = GetCustomerById(customerId)
' Load the renewal form template
Dim pdf As PdfDocument = PdfDocument.FromFile("templates/subscription-renewal.pdf")
' Pre-fill known customer information
pdf.Form.FindFormField("customerId").Value = customer.Id.ToString()
pdf.Form.FindFormField("customerName").Value = customer.FullName
pdf.Form.FindFormField("email").Value = customer.Email
pdf.Form.FindFormField("phone").Value = customer.Phone
pdf.Form.FindFormField("address").Value = customer.Address
pdf.Form.FindFormField("currentPlan").Value = customer.SubscriptionPlan
pdf.Form.FindFormField("renewalDate").Value = DateTime.Now.AddDays(30).ToString("MM/dd/yyyy")
' Leave editable fields empty for customer input:
' - newPlan (dropdown for plan selection)
' - paymentMethod (radio buttons)
' - additionalNotes (textarea)
' - signature (signature field)
' Return as byte array for web download or email attachment
Return pdf.BinaryData
End Function
' Simulated data access
Private Function GetCustomerById(id As Integer) As Customer
Return New Customer With {
.Id = id,
.FullName = "Robert Williams",
.Email = "robert.williams@email.com",
.Phone = "(555) 987-6543",
.Address = "123 Business Park Drive" & vbCrLf & "Suite 400" & vbCrLf & "Chicago, IL 60601",
.SubscriptionPlan = "Professional"
}
End Function
End Class
Public Class Customer
Public Property Id As Integer
Public Property FullName As String
Public Property Email As String
Public Property Phone As String
Public Property Address As String
Public Property SubscriptionPlan As String
End Class
Exemplo de saída
Esse modelo funciona bem para formulários de renovação, atualizações de aplicativos, revisões anuais e qualquer cenário em que já existam informações parciais em seu sistema. O usuário recebe um documento com seus dados já preenchidos, precisando apenas fornecer informações novas ou alterar as que já foram preenchidas.
Construir um Pipeline de Processamento de Dados de Formulários
O processamento em larga escala de formulários submetidos exige uma abordagem estruturada que contemple a extração, validação, transformação e armazenamento dos dados. Um padrão de pipeline simples mantém esse processo organizado e de fácil manutenção.
using IronPdf;using System;using System.Collections.Generic;using System.IO;public class FormSubmission{ public stringSubmissionId { get; set; } public DateTimeReceivedAt { get; set; } public stringSourceFile { get; set; } public Dictionary<string, string> FormData { get; set; } public boolIsValid { get; set; } public List<string> ValidationErrors { get; set; }}public class FormProcessingPipeline{ public FormSubmissionProcessSubmission(string pdfPath) { var submission = new FormSubmission {SubmissionId = Guid.NewGuid().ToString("N").Substring(0, 8).ToUpper(),ReceivedAt = DateTime.UtcNow,SourceFile = Path.GetFileName(pdfPath),FormData = new Dictionary<string, string>(),ValidationErrors = new List<string>() }; // Step 1: Extract form data PdfDocument pdf = PdfDocument.FromFile(pdfPath); foreach (var field in pdf.Form) { submission.FormData[field.Name] = field.Value ?? string.Empty; } // Step 2: Validate required fields var requiredFields = new[] { "fullName", "email", "signatureDate" }; foreach (var fieldName in requiredFields) { if (!submission.FormData.ContainsKey(fieldName) || string.IsNullOrWhiteSpace(submission.FormData[fieldName])) { submission.ValidationErrors.Add($"Missing required field: {fieldName}"); } } submission.IsValid = submission.ValidationErrors.Count == 0; // Step 3: Return the processed submission return submission; } public voidProcessBatch(string folderPath) { var pdfFiles = Directory.GetFiles(folderPath, "*.pdf"); var results = new List<FormSubmission>(); foreach (var file in pdfFiles) { try { var submission = ProcessSubmission(file); results.Add(submission); } catch (Exception ex) { // Handle error for file: ex.Message } } // Summary int validCount = 0; int invalidCount = 0; foreach (var r in results) { if (r.IsValid) validCount++; else invalidCount++; } // Results summary: results.Count processed, validCount valid, invalidCount invalid }}
using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
public class FormSubmission
{
public string SubmissionId { get; set; }
public DateTime ReceivedAt { get; set; }
public string SourceFile { get; set; }
public Dictionary<string, string> FormData { get; set; }
public bool IsValid { get; set; }
public List<string> ValidationErrors { get; set; }
}
public class FormProcessingPipeline
{
public FormSubmission ProcessSubmission(string pdfPath)
{
var submission = new FormSubmission
{
SubmissionId = Guid.NewGuid().ToString("N").Substring(0, 8).ToUpper(),
ReceivedAt = DateTime.UtcNow,
SourceFile = Path.GetFileName(pdfPath),
FormData = new Dictionary<string, string>(),
ValidationErrors = new List<string>()
};
// Step 1: Extract form data
PdfDocument pdf = PdfDocument.FromFile(pdfPath);
foreach (var field in pdf.Form)
{
submission.FormData[field.Name] = field.Value ?? string.Empty;
}
// Step 2: Validate required fields
var requiredFields = new[] { "fullName", "email", "signatureDate" };
foreach (var fieldName in requiredFields)
{
if (!submission.FormData.ContainsKey(fieldName) ||
string.IsNullOrWhiteSpace(submission.FormData[fieldName]))
{
submission.ValidationErrors.Add($"Missing required field: {fieldName}");
}
}
submission.IsValid = submission.ValidationErrors.Count == 0;
// Step 3: Return the processed submission
return submission;
}
public void ProcessBatch(string folderPath)
{
var pdfFiles = Directory.GetFiles(folderPath, "*.pdf");
var results = new List<FormSubmission>();
foreach (var file in pdfFiles)
{
try
{
var submission = ProcessSubmission(file);
results.Add(submission);
}
catch (Exception ex)
{
// Handle error for file: ex.Message
}
}
// Summary
int validCount = 0;
int invalidCount = 0;
foreach (var r in results)
{
if (r.IsValid) validCount++;
else invalidCount++;
}
// Results summary: results.Count processed, validCount valid, invalidCount invalid
}
}
ImportsIronPdfImportsSystemImportsSystem.Collections.GenericImportsSystem.IOPublic Class FormSubmission Public Property SubmissionIdAsString Public Property ReceivedAtAsDateTime Public Property SourceFileAsString Public Property FormDataAsDictionary(OfString, String) Public Property IsValidAsBoolean Public Property ValidationErrorsAsList(OfString)End ClassPublic Class FormProcessingPipeline Public Function ProcessSubmission(ByVal pdfPath AsString) AsFormSubmission Dim submission = New FormSubmissionWith { .SubmissionId = Guid.NewGuid().ToString("N").Substring(0, 8).ToUpper(), .ReceivedAt = DateTime.UtcNow, .SourceFile = Path.GetFileName(pdfPath), .FormData = New Dictionary(OfString, String)(), .ValidationErrors = New List(OfString)() } ' Step 1: Extract form data Dim pdf AsPdfDocument = PdfDocument.FromFile(pdfPath) For Each field In pdf.Form submission.FormData(field.Name) = If(field.Value, String.Empty) Next ' Step 2: Validate required fields Dim requiredFields = New String() {"fullName", "email", "signatureDate"} For Each fieldName In requiredFields IfNot submission.FormData.ContainsKey(fieldName) OrElseString.IsNullOrWhiteSpace(submission.FormData(fieldName)) Then submission.ValidationErrors.Add($"Missing required field: {fieldName}") End If Next submission.IsValid = submission.ValidationErrors.Count = 0 ' Step 3: Return the processed submission Return submission End Function Public Sub ProcessBatch(ByVal folderPath AsString) Dim pdfFiles = Directory.GetFiles(folderPath, "*.pdf") Dim results = New List(OfFormSubmission)() For Each file In pdfFilesTry Dim submission = ProcessSubmission(file) results.Add(submission)Catch ex AsException ' Handle error for file: ex.MessageEndTry Next ' Summary Dim validCount AsInteger = 0 Dim invalidCount AsInteger = 0 For Each r In results If r.IsValidThen validCount += 1 Else invalidCount += 1 End If Next ' Results summary: results.Count processed, validCount valid, invalidCount invalid End SubEnd Class
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.IO
Public Class FormSubmission
Public Property SubmissionId As String
Public Property ReceivedAt As DateTime
Public Property SourceFile As String
Public Property FormData As Dictionary(Of String, String)
Public Property IsValid As Boolean
Public Property ValidationErrors As List(Of String)
End Class
Public Class FormProcessingPipeline
Public Function ProcessSubmission(ByVal pdfPath As String) As FormSubmission
Dim submission = New FormSubmission With {
.SubmissionId = Guid.NewGuid().ToString("N").Substring(0, 8).ToUpper(),
.ReceivedAt = DateTime.UtcNow,
.SourceFile = Path.GetFileName(pdfPath),
.FormData = New Dictionary(Of String, String)(),
.ValidationErrors = New List(Of String)()
}
' Step 1: Extract form data
Dim pdf As PdfDocument = PdfDocument.FromFile(pdfPath)
For Each field In pdf.Form
submission.FormData(field.Name) = If(field.Value, String.Empty)
Next
' Step 2: Validate required fields
Dim requiredFields = New String() {"fullName", "email", "signatureDate"}
For Each fieldName In requiredFields
If Not submission.FormData.ContainsKey(fieldName) OrElse String.IsNullOrWhiteSpace(submission.FormData(fieldName)) Then
submission.ValidationErrors.Add($"Missing required field: {fieldName}")
End If
Next
submission.IsValid = submission.ValidationErrors.Count = 0
' Step 3: Return the processed submission
Return submission
End Function
Public Sub ProcessBatch(ByVal folderPath As String)
Dim pdfFiles = Directory.GetFiles(folderPath, "*.pdf")
Dim results = New List(Of FormSubmission)()
For Each file In pdfFiles
Try
Dim submission = ProcessSubmission(file)
results.Add(submission)
Catch ex As Exception
' Handle error for file: ex.Message
End Try
Next
' Summary
Dim validCount As Integer = 0
Dim invalidCount As Integer = 0
For Each r In results
If r.IsValid Then
validCount += 1
Else
invalidCount += 1
End If
Next
' Results summary: results.Count processed, validCount valid, invalidCount invalid
End Sub
End Class
Essa estrutura de pipeline pode ser expandida para incluir armazenamento em banco de dados, notificações por e-mail, integração com APIs externas ou quaisquer outras etapas de processamento que seu fluxo de trabalho exija. A chave é manter a separação entre extração, validação e processamento subsequente.
Para processamento em lote de alto desempenho, consulte o Guia de Geração Assíncrona de PDFs , que aborda padrões de multithreading e processamento paralelo.
Automatizar Formulários Fiscais do IRS como o W-9
Os formulários governamentais representam alguns dos cenários de processamento de PDFs de maior volume. O formulário W-9 (Solicitação de Número de Identificação Fiscal) é preenchido milhões de vezes anualmente por empresas que cadastram fornecedores e contratados. Toda empresa que paga a trabalhadores autônomos precisa ter o formulário W-9 arquivado, e automatizar esse processo de coleta pode economizar um tempo administrativo significativo.
using IronPdf;using System;public class W9FormData{ public stringName { get; set; } public stringBusinessName { get; set; } public stringFederalTaxClassification { get; set; } public stringExemptPayeeCode { get; set; } public stringFatcaExemptionCode { get; set; } public stringAddress { get; set; } public stringCityStateZip { get; set; } public stringAccountNumbers { get; set; } public stringTaxpayerIdNumber { get; set; } public DateTimeSignatureDate { get; set; }}public class W9FormProcessor{ public voidFillW9Form(W9FormData data, string templatePath, string outputPath) { PdfDocument pdf = PdfDocument.FromFile(templatePath); // The W-9 form has specific field names defined by the IRS // These correspond to the official form structure // Line 1: Name as shown on your income tax returnSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_1[0]", data.Name); // Line 2: Business name/disregarded entity nameSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_2[0]", data.BusinessName); // Line 3: Federal tax classification (checkbox selection) // The W-9 uses checkbox fields for classification switch (data.FederalTaxClassification) { case "Individual":SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[0]", "1"); break; case "CCorporation":SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[1]", "2"); break; case "SCorporation":SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[2]", "3"); break; case "Partnership":SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[3]", "4"); break; case "LLC":SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[5]", "6"); break; } // Line 5: AddressSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_7[0]", data.Address); // Line 6: City, state, and ZIP codeSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_8[0]", data.CityStateZip); // Part I: Taxpayer Identification Number (SSN or EIN) // For security, typically only last 4 digits are pre-filled or field is left for manual entry if (!string.IsNullOrEmpty(data.TaxpayerIdNumber) && data.TaxpayerIdNumber.Length >= 4) { // TIN left blank for security - user must enter manually } // Signature dateSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Date[0]", data.SignatureDate.ToString("MM/dd/yyyy")); pdf.SaveAs(outputPath); } private voidSetFieldIfExists(PdfDocument pdf, string fieldName, string value) { var field = pdf.Form.FindFormField(fieldName); if (field != null && !string.IsNullOrEmpty(value)) { field.Value = value; } }}// Usage exampleclass Program{ static voidMain() { var vendorData = new W9FormData {Name = "Johnson Consulting LLC",BusinessName = "",FederalTaxClassification = "LLC",Address = "456 Commerce Street",CityStateZip = "Austin, TX 78701",SignatureDate = DateTime.Today }; var processor = new W9FormProcessor(); processor.FillW9Form(vendorData, "fw9.pdf", "w9-johnson-consulting.pdf"); }}
using IronPdf;
using System;
public class W9FormData
{
public string Name { get; set; }
public string BusinessName { get; set; }
public string FederalTaxClassification { get; set; }
public string ExemptPayeeCode { get; set; }
public string FatcaExemptionCode { get; set; }
public string Address { get; set; }
public string CityStateZip { get; set; }
public string AccountNumbers { get; set; }
public string TaxpayerIdNumber { get; set; }
public DateTime SignatureDate { get; set; }
}
public class W9FormProcessor
{
public void FillW9Form(W9FormData data, string templatePath, string outputPath)
{
PdfDocument pdf = PdfDocument.FromFile(templatePath);
// The W-9 form has specific field names defined by the IRS
// These correspond to the official form structure
// Line 1: Name as shown on your income tax return
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_1[0]", data.Name);
// Line 2: Business name/disregarded entity name
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_2[0]", data.BusinessName);
// Line 3: Federal tax classification (checkbox selection)
// The W-9 uses checkbox fields for classification
switch (data.FederalTaxClassification)
{
case "Individual":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[0]", "1");
break;
case "CCorporation":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[1]", "2");
break;
case "SCorporation":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[2]", "3");
break;
case "Partnership":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[3]", "4");
break;
case "LLC":
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[5]", "6");
break;
}
// Line 5: Address
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_7[0]", data.Address);
// Line 6: City, state, and ZIP code
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_8[0]", data.CityStateZip);
// Part I: Taxpayer Identification Number (SSN or EIN)
// For security, typically only last 4 digits are pre-filled or field is left for manual entry
if (!string.IsNullOrEmpty(data.TaxpayerIdNumber) && data.TaxpayerIdNumber.Length >= 4)
{
// TIN left blank for security - user must enter manually
}
// Signature date
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Date[0]",
data.SignatureDate.ToString("MM/dd/yyyy"));
pdf.SaveAs(outputPath);
}
private void SetFieldIfExists(PdfDocument pdf, string fieldName, string value)
{
var field = pdf.Form.FindFormField(fieldName);
if (field != null && !string.IsNullOrEmpty(value))
{
field.Value = value;
}
}
}
// Usage example
class Program
{
static void Main()
{
var vendorData = new W9FormData
{
Name = "Johnson Consulting LLC",
BusinessName = "",
FederalTaxClassification = "LLC",
Address = "456 Commerce Street",
CityStateZip = "Austin, TX 78701",
SignatureDate = DateTime.Today
};
var processor = new W9FormProcessor();
processor.FillW9Form(vendorData, "fw9.pdf", "w9-johnson-consulting.pdf");
}
}
ImportsIronPdfImportsSystemPublic Class W9FormData Public Property NameAsString Public Property BusinessNameAsString Public Property FederalTaxClassificationAsString Public Property ExemptPayeeCodeAsString Public Property FatcaExemptionCodeAsString Public Property AddressAsString Public Property CityStateZipAsString Public Property AccountNumbersAsString Public Property TaxpayerIdNumberAsString Public Property SignatureDateAsDateTimeEnd ClassPublic Class W9FormProcessor Public Sub FillW9Form(ByVal data AsW9FormData, ByVal templatePath AsString, ByVal outputPath AsString) Dim pdf AsPdfDocument = PdfDocument.FromFile(templatePath) ' The W-9 form has specific field names defined by the IRS ' These correspond to the official form structure ' Line 1: Name as shown on your income tax returnSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_1[0]", data.Name) ' Line 2: Business name/disregarded entity nameSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_2[0]", data.BusinessName) ' Line 3: Federal tax classification (checkbox selection) ' The W-9 uses checkbox fields for classification Select Case data.FederalTaxClassification Case "Individual"SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[0]", "1") Case "CCorporation"SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[1]", "2") Case "SCorporation"SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[2]", "3") Case "Partnership"SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[3]", "4") Case "LLC"SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[5]", "6") End Select ' Line 5: AddressSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_7[0]", data.Address) ' Line 6: City, state, and ZIP codeSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_8[0]", data.CityStateZip) ' Part I: Taxpayer Identification Number (SSN or EIN) ' For security, typically only last 4 digits are pre-filled or field is left for manual entry IfNotString.IsNullOrEmpty(data.TaxpayerIdNumber) AndAlso data.TaxpayerIdNumber.Length >= 4 Then ' TIN left blank for security - user must enter manually End If ' Signature dateSetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Date[0]", data.SignatureDate.ToString("MM/dd/yyyy")) pdf.SaveAs(outputPath) End Sub Private Sub SetFieldIfExists(ByVal pdf AsPdfDocument, ByVal fieldName AsString, ByVal value AsString) Dim field = pdf.Form.FindFormField(fieldName) If field IsNot NothingAndAlsoNotString.IsNullOrEmpty(value) Then field.Value = value End If End SubEnd Class' Usage exampleClass ProgramShared Sub Main() Dim vendorData = New W9FormDataWith { .Name = "Johnson Consulting LLC", .BusinessName = "", .FederalTaxClassification = "LLC", .Address = "456 Commerce Street", .CityStateZip = "Austin, TX 78701", .SignatureDate = DateTime.Today } Dim processor = New W9FormProcessor() processor.FillW9Form(vendorData, "fw9.pdf", "w9-johnson-consulting.pdf") End SubEnd Class
Imports IronPdf
Imports System
Public Class W9FormData
Public Property Name As String
Public Property BusinessName As String
Public Property FederalTaxClassification As String
Public Property ExemptPayeeCode As String
Public Property FatcaExemptionCode As String
Public Property Address As String
Public Property CityStateZip As String
Public Property AccountNumbers As String
Public Property TaxpayerIdNumber As String
Public Property SignatureDate As DateTime
End Class
Public Class W9FormProcessor
Public Sub FillW9Form(ByVal data As W9FormData, ByVal templatePath As String, ByVal outputPath As String)
Dim pdf As PdfDocument = PdfDocument.FromFile(templatePath)
' The W-9 form has specific field names defined by the IRS
' These correspond to the official form structure
' Line 1: Name as shown on your income tax return
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_1[0]", data.Name)
' Line 2: Business name/disregarded entity name
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].f1_2[0]", data.BusinessName)
' Line 3: Federal tax classification (checkbox selection)
' The W-9 uses checkbox fields for classification
Select Case data.FederalTaxClassification
Case "Individual"
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[0]", "1")
Case "CCorporation"
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[1]", "2")
Case "SCorporation"
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[2]", "3")
Case "Partnership"
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[3]", "4")
Case "LLC"
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].FederalClassification[0].c1_1[5]", "6")
End Select
' Line 5: Address
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_7[0]", data.Address)
' Line 6: City, state, and ZIP code
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Address[0].f1_8[0]", data.CityStateZip)
' Part I: Taxpayer Identification Number (SSN or EIN)
' For security, typically only last 4 digits are pre-filled or field is left for manual entry
If Not String.IsNullOrEmpty(data.TaxpayerIdNumber) AndAlso data.TaxpayerIdNumber.Length >= 4 Then
' TIN left blank for security - user must enter manually
End If
' Signature date
SetFieldIfExists(pdf, "topmostSubform[0].Page1[0].Date[0]", data.SignatureDate.ToString("MM/dd/yyyy"))
pdf.SaveAs(outputPath)
End Sub
Private Sub SetFieldIfExists(ByVal pdf As PdfDocument, ByVal fieldName As String, ByVal value As String)
Dim field = pdf.Form.FindFormField(fieldName)
If field IsNot Nothing AndAlso Not String.IsNullOrEmpty(value) Then
field.Value = value
End If
End Sub
End Class
' Usage example
Class Program
Shared Sub Main()
Dim vendorData = New W9FormData With {
.Name = "Johnson Consulting LLC",
.BusinessName = "",
.FederalTaxClassification = "LLC",
.Address = "456 Commerce Street",
.CityStateZip = "Austin, TX 78701",
.SignatureDate = DateTime.Today
}
Dim processor = New W9FormProcessor()
processor.FillW9Form(vendorData, "fw9.pdf", "w9-johnson-consulting.pdf")
End Sub
End Class
Os formulários governamentais frequentemente utilizam convenções complexas de nomenclatura hierárquica para os campos. Os nomes dos campos do formulário W-9 mostrados acima seguem o padrão de nomenclatura derivado do XFA usado nos PDFs oficiais do IRS. Ao trabalhar com formulários governamentais, sempre baixe a versão mais recente do site oficial do órgão e examine a estrutura dos campos antes de escrever o código de automação.
Processamento em Lote de Formulários com Dados Variáveis
O processamento em lote gera vários formulários preenchidos a partir de uma fonte de dados, como uma consulta de banco de dados, um arquivo CSV ou uma resposta de API. Essa funcionalidade se mostra essencial em cenários como a distribuição anual de documentos fiscais, pacotes de integração de funcionários ou geração de extratos para clientes.
using IronPdf;using System;using System.Collections.Generic;using System.IO;using System.Threading.Tasks;public class VendorRecord{ public stringVendorId { get; set; } public stringCompanyName { get; set; } public stringContactName { get; set; } public stringAddress { get; set; } public stringCity { get; set; } public stringState { get; set; } public stringZipCode { get; set; } public stringTaxClassification { get; set; }}public class BatchFormGenerator{ private readonly string _templatePath; private readonly string _outputDirectory; publicBatchFormGenerator(string templatePath, string outputDirectory) { _templatePath = templatePath; _outputDirectory = outputDirectory; if (!Directory.Exists(_outputDirectory)) {Directory.CreateDirectory(_outputDirectory); } } public voidGenerateVendorForms(List<VendorRecord> vendors) { var startTime = DateTime.Now; int successCount = 0; int errorCount = 0; foreach (var vendor in vendors) { try {GenerateSingleForm(vendor); successCount++; } catch (Exception ex) { errorCount++; // Handle error: ex.Message } } var elapsed = DateTime.Now - startTime; // Results: successCount successful, errorCount errors, elapsed time } private voidGenerateSingleForm(VendorRecord vendor) { PdfDocument pdf = PdfDocument.FromFile(_templatePath); // Fill vendor information fieldsSetField(pdf, "vendorId", vendor.VendorId);SetField(pdf, "companyName", vendor.CompanyName);SetField(pdf, "contactName", vendor.ContactName);SetField(pdf, "address", vendor.Address);SetField(pdf, "city", vendor.City);SetField(pdf, "state", vendor.State);SetField(pdf, "zipCode", vendor.ZipCode);SetField(pdf, "taxClassification", vendor.TaxClassification);SetField(pdf, "generatedDate", DateTime.Today.ToString("MM/dd/yyyy")); // Create a safe filename from company name string safeFileName = string.Join("_", vendor.CompanyName.Split(Path.GetInvalidFileNameChars())); string outputPath = Path.Combine(_outputDirectory, $"vendor-form-{vendor.VendorId}-{safeFileName}.pdf"); pdf.SaveAs(outputPath); } private voidSetField(PdfDocument pdf, string fieldName, string value) { var field = pdf.Form.FindFormField(fieldName); if (field != null) { field.Value = value ?? string.Empty; } }}// Usage example with sample dataclass Program{ static voidMain() { var vendors = new List<VendorRecord> { new VendorRecord {VendorId = "V001",CompanyName = "Alpha Supplies Inc",ContactName = "Maria Garcia",Address = "100 Industrial Way",City = "Chicago",State = "IL",ZipCode = "60601",TaxClassification = "Corporation" }, new VendorRecord {VendorId = "V002",CompanyName = "Beta Services LLC",ContactName = "James Wilson",Address = "200 Tech Park Drive",City = "Austin",State = "TX",ZipCode = "78701",TaxClassification = "LLC" }, new VendorRecord {VendorId = "V003",CompanyName = "Gamma Consulting",ContactName = "Sarah Chen",Address = "300 Business Center",City = "Seattle",State = "WA",ZipCode = "98101",TaxClassification = "Partnership" } }; var generator = new BatchFormGenerator("vendor-info-template.pdf", "output/vendor-forms"); generator.GenerateVendorForms(vendors); }}
using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
public class VendorRecord
{
public string VendorId { get; set; }
public string CompanyName { get; set; }
public string ContactName { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string State { get; set; }
public string ZipCode { get; set; }
public string TaxClassification { get; set; }
}
public class BatchFormGenerator
{
private readonly string _templatePath;
private readonly string _outputDirectory;
public BatchFormGenerator(string templatePath, string outputDirectory)
{
_templatePath = templatePath;
_outputDirectory = outputDirectory;
if (!Directory.Exists(_outputDirectory))
{
Directory.CreateDirectory(_outputDirectory);
}
}
public void GenerateVendorForms(List<VendorRecord> vendors)
{
var startTime = DateTime.Now;
int successCount = 0;
int errorCount = 0;
foreach (var vendor in vendors)
{
try
{
GenerateSingleForm(vendor);
successCount++;
}
catch (Exception ex)
{
errorCount++;
// Handle error: ex.Message
}
}
var elapsed = DateTime.Now - startTime;
// Results: successCount successful, errorCount errors, elapsed time
}
private void GenerateSingleForm(VendorRecord vendor)
{
PdfDocument pdf = PdfDocument.FromFile(_templatePath);
// Fill vendor information fields
SetField(pdf, "vendorId", vendor.VendorId);
SetField(pdf, "companyName", vendor.CompanyName);
SetField(pdf, "contactName", vendor.ContactName);
SetField(pdf, "address", vendor.Address);
SetField(pdf, "city", vendor.City);
SetField(pdf, "state", vendor.State);
SetField(pdf, "zipCode", vendor.ZipCode);
SetField(pdf, "taxClassification", vendor.TaxClassification);
SetField(pdf, "generatedDate", DateTime.Today.ToString("MM/dd/yyyy"));
// Create a safe filename from company name
string safeFileName = string.Join("_", vendor.CompanyName.Split(Path.GetInvalidFileNameChars()));
string outputPath = Path.Combine(_outputDirectory, $"vendor-form-{vendor.VendorId}-{safeFileName}.pdf");
pdf.SaveAs(outputPath);
}
private void SetField(PdfDocument pdf, string fieldName, string value)
{
var field = pdf.Form.FindFormField(fieldName);
if (field != null)
{
field.Value = value ?? string.Empty;
}
}
}
// Usage example with sample data
class Program
{
static void Main()
{
var vendors = new List<VendorRecord>
{
new VendorRecord
{
VendorId = "V001",
CompanyName = "Alpha Supplies Inc",
ContactName = "Maria Garcia",
Address = "100 Industrial Way",
City = "Chicago",
State = "IL",
ZipCode = "60601",
TaxClassification = "Corporation"
},
new VendorRecord
{
VendorId = "V002",
CompanyName = "Beta Services LLC",
ContactName = "James Wilson",
Address = "200 Tech Park Drive",
City = "Austin",
State = "TX",
ZipCode = "78701",
TaxClassification = "LLC"
},
new VendorRecord
{
VendorId = "V003",
CompanyName = "Gamma Consulting",
ContactName = "Sarah Chen",
Address = "300 Business Center",
City = "Seattle",
State = "WA",
ZipCode = "98101",
TaxClassification = "Partnership"
}
};
var generator = new BatchFormGenerator("vendor-info-template.pdf", "output/vendor-forms");
generator.GenerateVendorForms(vendors);
}
}
ImportsIronPdfImportsSystemImportsSystem.Collections.GenericImportsSystem.IOImportsSystem.Threading.TasksPublic Class VendorRecord Public Property VendorIdAsString Public Property CompanyNameAsString Public Property ContactNameAsString Public Property AddressAsString Public Property CityAsString Public Property StateAsString Public Property ZipCodeAsString Public Property TaxClassificationAsStringEnd ClassPublic Class BatchFormGenerator PrivateReadOnly _templatePath AsString PrivateReadOnly _outputDirectory AsString Public Sub New(templatePath AsString, outputDirectory AsString) _templatePath = templatePath _outputDirectory = outputDirectory IfNotDirectory.Exists(_outputDirectory) ThenDirectory.CreateDirectory(_outputDirectory) End If End Sub Public Sub GenerateVendorForms(vendors AsList(OfVendorRecord)) Dim startTime = DateTime.Now Dim successCount AsInteger = 0 Dim errorCount AsInteger = 0 For Each vendor In vendorsTryGenerateSingleForm(vendor) successCount += 1Catch ex AsException errorCount += 1 ' Handle error: ex.MessageEndTry Next Dim elapsed = DateTime.Now - startTime ' Results: successCount successful, errorCount errors, elapsed time End Sub Private Sub GenerateSingleForm(vendor AsVendorRecord) Dim pdf AsPdfDocument = PdfDocument.FromFile(_templatePath) ' Fill vendor information fieldsSetField(pdf, "vendorId", vendor.VendorId)SetField(pdf, "companyName", vendor.CompanyName)SetField(pdf, "contactName", vendor.ContactName)SetField(pdf, "address", vendor.Address)SetField(pdf, "city", vendor.City)SetField(pdf, "state", vendor.State)SetField(pdf, "zipCode", vendor.ZipCode)SetField(pdf, "taxClassification", vendor.TaxClassification)SetField(pdf, "generatedDate", DateTime.Today.ToString("MM/dd/yyyy")) ' Create a safe filename from company name Dim safeFileName AsString = String.Join("_", vendor.CompanyName.Split(Path.GetInvalidFileNameChars())) Dim outputPath AsString = Path.Combine(_outputDirectory, $"vendor-form-{vendor.VendorId}-{safeFileName}.pdf") pdf.SaveAs(outputPath) End Sub Private Sub SetField(pdf AsPdfDocument, fieldName AsString, value AsString) Dim field = pdf.Form.FindFormField(fieldName) If field IsNot Nothing Then field.Value = If(value, String.Empty) End If End SubEnd Class' Usage example with sample dataClass ProgramShared Sub Main() Dim vendors = New List(OfVendorRecord) From { New VendorRecordWith { .VendorId = "V001", .CompanyName = "Alpha Supplies Inc", .ContactName = "Maria Garcia", .Address = "100 Industrial Way", .City = "Chicago", .State = "IL", .ZipCode = "60601", .TaxClassification = "Corporation" }, New VendorRecordWith { .VendorId = "V002", .CompanyName = "Beta Services LLC", .ContactName = "James Wilson", .Address = "200 Tech Park Drive", .City = "Austin", .State = "TX", .ZipCode = "78701", .TaxClassification = "LLC" }, New VendorRecordWith { .VendorId = "V003", .CompanyName = "Gamma Consulting", .ContactName = "Sarah Chen", .Address = "300 Business Center", .City = "Seattle", .State = "WA", .ZipCode = "98101", .TaxClassification = "Partnership" } } Dim generator = New BatchFormGenerator("vendor-info-template.pdf", "output/vendor-forms") generator.GenerateVendorForms(vendors) End SubEnd Class
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks
Public Class VendorRecord
Public Property VendorId As String
Public Property CompanyName As String
Public Property ContactName As String
Public Property Address As String
Public Property City As String
Public Property State As String
Public Property ZipCode As String
Public Property TaxClassification As String
End Class
Public Class BatchFormGenerator
Private ReadOnly _templatePath As String
Private ReadOnly _outputDirectory As String
Public Sub New(templatePath As String, outputDirectory As String)
_templatePath = templatePath
_outputDirectory = outputDirectory
If Not Directory.Exists(_outputDirectory) Then
Directory.CreateDirectory(_outputDirectory)
End If
End Sub
Public Sub GenerateVendorForms(vendors As List(Of VendorRecord))
Dim startTime = DateTime.Now
Dim successCount As Integer = 0
Dim errorCount As Integer = 0
For Each vendor In vendors
Try
GenerateSingleForm(vendor)
successCount += 1
Catch ex As Exception
errorCount += 1
' Handle error: ex.Message
End Try
Next
Dim elapsed = DateTime.Now - startTime
' Results: successCount successful, errorCount errors, elapsed time
End Sub
Private Sub GenerateSingleForm(vendor As VendorRecord)
Dim pdf As PdfDocument = PdfDocument.FromFile(_templatePath)
' Fill vendor information fields
SetField(pdf, "vendorId", vendor.VendorId)
SetField(pdf, "companyName", vendor.CompanyName)
SetField(pdf, "contactName", vendor.ContactName)
SetField(pdf, "address", vendor.Address)
SetField(pdf, "city", vendor.City)
SetField(pdf, "state", vendor.State)
SetField(pdf, "zipCode", vendor.ZipCode)
SetField(pdf, "taxClassification", vendor.TaxClassification)
SetField(pdf, "generatedDate", DateTime.Today.ToString("MM/dd/yyyy"))
' Create a safe filename from company name
Dim safeFileName As String = String.Join("_", vendor.CompanyName.Split(Path.GetInvalidFileNameChars()))
Dim outputPath As String = Path.Combine(_outputDirectory, $"vendor-form-{vendor.VendorId}-{safeFileName}.pdf")
pdf.SaveAs(outputPath)
End Sub
Private Sub SetField(pdf As PdfDocument, fieldName As String, value As String)
Dim field = pdf.Form.FindFormField(fieldName)
If field IsNot Nothing Then
field.Value = If(value, String.Empty)
End If
End Sub
End Class
' Usage example with sample data
Class Program
Shared Sub Main()
Dim vendors = New List(Of VendorRecord) From {
New VendorRecord With {
.VendorId = "V001",
.CompanyName = "Alpha Supplies Inc",
.ContactName = "Maria Garcia",
.Address = "100 Industrial Way",
.City = "Chicago",
.State = "IL",
.ZipCode = "60601",
.TaxClassification = "Corporation"
},
New VendorRecord With {
.VendorId = "V002",
.CompanyName = "Beta Services LLC",
.ContactName = "James Wilson",
.Address = "200 Tech Park Drive",
.City = "Austin",
.State = "TX",
.ZipCode = "78701",
.TaxClassification = "LLC"
},
New VendorRecord With {
.VendorId = "V003",
.CompanyName = "Gamma Consulting",
.ContactName = "Sarah Chen",
.Address = "300 Business Center",
.City = "Seattle",
.State = "WA",
.ZipCode = "98101",
.TaxClassification = "Partnership"
}
}
Dim generator = New BatchFormGenerator("vendor-info-template.pdf", "output/vendor-forms")
generator.GenerateVendorForms(vendors)
End Sub
End Class
Para lotes muito grandes, considere implementar processamento paralelo com concorrência controlada para maximizar a produtividade sem sobrecarregar os recursos do sistema.
Garantir Conformidade com Padrões de PDF Governamentais
Órgãos governamentais frequentemente exigem que documentos atendam a padrões específicos de PDF para arquivamento e acessibilidade a longo prazo. O PDF/A é um subconjunto do PDF padronizado pela ISO, projetado para a preservação confiável de documentos eletrônicos a longo prazo. O IronPDF permite exportar documentos no formato PDF/A para atender a esses requisitos de conformidade.
O código a seguir cria um formulário oficial do governo a partir de HTML, preenche com os dados do candidato, e salva como um documento compatível com PDF/A-3b usando o método SaveAsPdfA(). Este formato garante que os documentos permaneçam legíveis por décadas e atende à maioria dos requisitos de envio governamentais.
using IronPdf;using System;// Create or load a form documentstring formHtml = @"E html>le>body { font-family: Arial, sans-serif; margin: 40px; }h1 { color: #003366; }.form-section { margin: 20px 0; }label { display: block; margin: 10px 0 5px 0; font-weight: bold; }input, select { padding: 8px; width: 300px; border: 1px solid #ccc; }yle>Official Government Form</h1>his document complies with PDF/A-3b archival standards.</p>m><div class='form-section'> <label>Applicant Name</label> <input type='text' name='applicantName' /></div><div class='form-section'> <label>Application Date</label> <input type='text' name='applicationDate' /></div><div class='form-section'> <label>Department</label> <select name='department'> <option value=''>Select Department</option> <option value='Revenue'>Department of Revenue</option> <option value='Labor'>Department of Labor</option> <option value='Commerce'>Department of Commerce</option> </select></div>rm>;ChromePdfRenderer renderer = new ChromePdfRenderer();renderer.RenderingOptions.CreatePdfFormsFromHtml = true;PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);// Fill form fieldspdf.Form.FindFormField("applicantName").Value = "GovernmentServicesCorp";pdf.Form.FindFormField("applicationDate").Value = DateTime.Today.ToString("MM/dd/yyyy");pdf.Form.FindFormField("department").Value = "Commerce";// Convert to PDF/A-3b for archival compliancepdf.SaveAsPdfA("government-form-archived.pdf", PdfAVersions.PdfA3b);
using IronPdf;
using System;
// Create or load a form document
string formHtml = @"
E html>
le>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #003366; }
.form-section { margin: 20px 0; }
label { display: block; margin: 10px 0 5px 0; font-weight: bold; }
input, select { padding: 8px; width: 300px; border: 1px solid #ccc; }
yle>
Official Government Form</h1>
his document complies with PDF/A-3b archival standards.</p>
m>
<div class='form-section'>
<label>Applicant Name</label>
<input type='text' name='applicantName' />
</div>
<div class='form-section'>
<label>Application Date</label>
<input type='text' name='applicationDate' />
</div>
<div class='form-section'>
<label>Department</label>
<select name='department'>
<option value=''>Select Department</option>
<option value='Revenue'>Department of Revenue</option>
<option value='Labor'>Department of Labor</option>
<option value='Commerce'>Department of Commerce</option>
</select>
</div>
rm>
;
ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
// Fill form fields
pdf.Form.FindFormField("applicantName").Value = "Government Services Corp";
pdf.Form.FindFormField("applicationDate").Value = DateTime.Today.ToString("MM/dd/yyyy");
pdf.Form.FindFormField("department").Value = "Commerce";
// Convert to PDF/A-3b for archival compliance
pdf.SaveAsPdfA("government-form-archived.pdf", PdfAVersions.PdfA3b);
ImportsIronPdfImportsSystem' Create or load a form documentDim formHtml AsString = "<html><head><style>body { font-family: Arial, sans-serif; margin: 40px; }h1 { color: #003366; }.form-section { margin: 20px 0; }label { display: block; margin: 10px 0 5px 0; font-weight: bold; }input, select { padding: 8px; width: 300px; border: 1px solid #ccc; }</style></head><body><h1>Official Government Form</h1><p>This document complies with PDF/A-3b archival standards.</p><form><div class='form-section'> <label>Applicant Name</label> <input type='text' name='applicantName' /></div><div class='form-section'> <label>Application Date</label> <input type='text' name='applicationDate' /></div><div class='form-section'> <label>Department</label> <select name='department'> <option value=''>Select Department</option> <option value='Revenue'>Department of Revenue</option> <option value='Labor'>Department of Labor</option> <option value='Commerce'>Department of Commerce</option> </select></div></form></body></html>"Dim renderer As New ChromePdfRenderer()renderer.RenderingOptions.CreatePdfFormsFromHtml = TrueDim pdf AsPdfDocument = renderer.RenderHtmlAsPdf(formHtml)' Fill form fieldspdf.Form.FindFormField("applicantName").Value = "Government Services Corp"pdf.Form.FindFormField("applicationDate").Value = DateTime.Today.ToString("MM/dd/yyyy")pdf.Form.FindFormField("department").Value = "Commerce"' Convert to PDF/A-3b for archival compliancepdf.SaveAsPdfA("government-form-archived.pdf", PdfAVersions.PdfA3b)
Imports IronPdf
Imports System
' Create or load a form document
Dim formHtml As String = "
<html>
<head>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #003366; }
.form-section { margin: 20px 0; }
label { display: block; margin: 10px 0 5px 0; font-weight: bold; }
input, select { padding: 8px; width: 300px; border: 1px solid #ccc; }
</style>
</head>
<body>
<h1>Official Government Form</h1>
<p>This document complies with PDF/A-3b archival standards.</p>
<form>
<div class='form-section'>
<label>Applicant Name</label>
<input type='text' name='applicantName' />
</div>
<div class='form-section'>
<label>Application Date</label>
<input type='text' name='applicationDate' />
</div>
<div class='form-section'>
<label>Department</label>
<select name='department'>
<option value=''>Select Department</option>
<option value='Revenue'>Department of Revenue</option>
<option value='Labor'>Department of Labor</option>
<option value='Commerce'>Department of Commerce</option>
</select>
</div>
</form>
</body>
</html>"
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)
' Fill form fields
pdf.Form.FindFormField("applicantName").Value = "Government Services Corp"
pdf.Form.FindFormField("applicationDate").Value = DateTime.Today.ToString("MM/dd/yyyy")
pdf.Form.FindFormField("department").Value = "Commerce"
' Convert to PDF/A-3b for archival compliance
pdf.SaveAsPdfA("government-form-archived.pdf", PdfAVersions.PdfA3b)
Exemplo de saída
O método SaveAsPdfA() leva o nome do arquivo de saída e um valor enum PdfAVersions (como PdfA3b). Durante o processo de salvamento, o IronPDF incorpora automaticamente todas as fontes, padroniza os espaços de cores, remove qualquer criptografia e estrutura os metadados de acordo com os requisitos do PDF/A. Essas transformações garantem que o documento permaneça legível e visualmente idêntico por décadas, independentemente do software que tentar abri-lo.
Ao enviar formulários para órgãos governamentais, verifique os requisitos específicos de cada um. Algumas empresas podem exigir o formato PDF/A-1b para arquivamento básico, enquanto outras especificam o PDF/A-3b para permitir anexos incorporados, como arquivos de dados XML. O IRS, por exemplo, aceita versões específicas em PDF para vários tipos de envio, e os formulários de imigração geralmente têm suas próprias especificações técnicas.
Agora você tem tudo o que precisa para automatizar aqueles fluxos de trabalho com formulários em PDF que consomem horas de entrada manual de dados. Seja para processar formulários W-9 para integração de fornecedores, preencher previamente formulários de admissão de pacientes a partir do seu sistema EHR ou importar dados de aplicativos enviados para o seu CRM, as técnicas deste guia se aplicam diretamente aos formulários que estão na sua caixa de entrada agora mesmo. Para obter um guia completo sobre os recursos de edição de PDF além de formulários, consulte o tutorial de edição de PDF .
Você pode criar formulários PDF em C# usando o IronPDF para converter formulários HTML em documentos PDF. Isso permite fácil personalização e design de formulários interativos.
É possível preencher formulários PDF existentes programaticamente em C#?
Sim, o IronPDF permite preencher formulários PDF existentes programaticamente em C#, acessando e modificando os campos do formulário usando código C#.
Posso extrair dados de formulários PDF usando o IronPDF?
O IronPDF oferece funcionalidades para extrair dados de formulários de documentos PDF, facilitando a recuperação e o processamento de informações inseridas em formulários PDF.
O que significa achatar formulários PDF?
O processo de achatamento de formulários PDF consiste em converter os campos do formulário em conteúdo estático, o que impede edições posteriores. O IronPDF pode achatar formulários para garantir a integridade dos dados e evitar alterações após o envio do formulário.
Como posso automatizar o processamento de formulários governamentais como o W-9?
O IronPDF pode automatizar o processamento de formulários governamentais, como o W-9, permitindo que você preencha, extraia e gerencie dados de formulários de forma programática, otimizando seu fluxo de trabalho.
Quais são as vantagens de usar HTML para criar formulários em PDF?
Utilizar HTML para criar formulários PDF com o IronPDF oferece flexibilidade de design e facilidade de integração com tecnologias web existentes, permitindo a criação de formulários dinâmicos e responsivos.
O IronPDF consegue lidar com elementos de formulário interativos?
Sim, o IronPDF suporta elementos de formulário interativos, como campos de texto, caixas de seleção e botões, permitindo a criação e manipulação de formulários PDF dinâmicos em C#.
É possível personalizar a aparência de formulários em PDF?
O IronPDF permite a personalização completa da aparência dos formulários PDF, possibilitando a aplicação de estilos CSS aos elementos do formulário para um visual profissional e consistente.
How does IronPDF facilitate extracting data from filled PDF forms?
IronPDF enables you to extract data from filled PDF forms by iterating over form fields and collecting their values into a data structure like a dictionary.
What platforms and frameworks does IronPDF support?
IronPDF supports .NET 10, .NET 8 LTS, .NET Framework 4.6.2+, and .NET Standard 2.0, ensuring flexibility across various development environments.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.