C# Leer campos de formulario PDF: Extraer datos de formularios mediante programación

using IronPdf;
using System.Collections.Generic;
using System.Linq;

PdfDocument pdf = PdfDocument.FromFile("complex_form.pdf");
// Text fields - standard input boxes
var nameField = pdf.Form.FindFormField("fullName");
string userName = nameField.Value;
// Checkboxes - binary selections
var agreeCheckbox = pdf.Form.FindFormField("termsAccepted");
bool isChecked = agreeCheckbox.Value == "Yes";
// Radio buttons - single choice from group
var genderRadio = pdf.Form.FindFormField("gender");
string selectedGender = genderRadio.Value;
// Dropdown lists (ComboBox) - predefined options
var countryDropdown = pdf.Form.FindFormField("country");
string selectedCountry = countryDropdown.Value;
// Access all available options
var availableCountries = countryDropdown.Choices;
// Multi-line text areas
var commentsField = pdf.Form.FindFormField("comments_part1_513");
string userComments = commentsField.Value;
// Grab all fields that start with "interests_"
var interestFields = pdf.Form
    .Where(f => f.Name.StartsWith("interests_"));
// Collect checked interests
List<string> selectedInterests = new List<string>();
foreach (var field in interestFields)
{
    if (field.Value == "Yes")  // checkboxes are "Yes" if checked
    {
        // Extract the interest name from the field name
        string interestName = field.Name.Replace("interests_", "");
        selectedInterests.Add(interestName);
    }
}

Imports IronPdf
Imports System.Collections.Generic
Imports System.Linq

Dim pdf As PdfDocument = PdfDocument.FromFile("complex_form.pdf")
' Text fields - standard input boxes
Dim nameField = pdf.Form.FindFormField("fullName")
Dim userName As String = nameField.Value
' Checkboxes - binary selections
Dim agreeCheckbox = pdf.Form.FindFormField("termsAccepted")
Dim isChecked As Boolean = agreeCheckbox.Value = "Yes"
' Radio buttons - single choice from group
Dim genderRadio = pdf.Form.FindFormField("gender")
Dim selectedGender As String = genderRadio.Value
' Dropdown lists (ComboBox) - predefined options
Dim countryDropdown = pdf.Form.FindFormField("country")
Dim selectedCountry As String = countryDropdown.Value
' Access all available options
Dim availableCountries = countryDropdown.Choices
' Multi-line text areas
Dim commentsField = pdf.Form.FindFormField("comments_part1_513")
Dim userComments As String = commentsField.Value
' Grab all fields that start with "interests_"
Dim interestFields = pdf.Form.Where(Function(f) f.Name.StartsWith("interests_"))
' Collect checked interests
Dim selectedInterests As New List(Of String)()
For Each field In interestFields
    If field.Value = "Yes" Then ' checkboxes are "Yes" if checked
        ' Extract the interest name from the field name
        Dim interestName As String = field.Name.Replace("interests_", "")
        selectedInterests.Add(interestName)
    End If
Next

using IronPdf;
using System;
using System.Text;
using System.IO;
using System.Collections.Generic;

public class SurveyProcessor
{
    static void Main(string[] args)
    {
        ProcessSurveyBatch(@"C:\Surveys");
    }

    public static void ProcessSurveyBatch(string folderPath)
    {
        StringBuilder csvData = new StringBuilder();
        csvData.AppendLine("Date,Name,Email,Rating,Feedback");
        foreach (string pdfFile in Directory.GetFiles(folderPath, "*.pdf"))
        {
            try
            {
                PdfDocument survey = PdfDocument.FromFile(pdfFile);
                string date = survey.Form.FindFormField("surveyDate")?.Value ?? "";
                string name = survey.Form.FindFormField("customerName")?.Value ?? "";
                string email = survey.Form.FindFormField("email")?.Value ?? "";
                string rating = survey.Form.FindFormField("satisfaction")?.Value ?? "";
                string feedback = survey.Form.FindFormField("comments")?.Value ?? "";
                feedback = feedback.Replace("\n", " ").Replace("\"", "\"\"");
                csvData.AppendLine($"{date},{name},{email},{rating},\"{feedback}\"");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error processing {pdfFile}: {ex.Message}");
            }
        }
        File.WriteAllText("survey_results.csv", csvData.ToString());
        Console.WriteLine("Survey processing complete!");
    }
}

Imports IronPdf
Imports System
Imports System.Text
Imports System.IO
Imports System.Collections.Generic

Public Class SurveyProcessor
    Shared Sub Main(args As String())
        ProcessSurveyBatch("C:\Surveys")
    End Sub

    Public Shared Sub ProcessSurveyBatch(folderPath As String)
        Dim csvData As New StringBuilder()
        csvData.AppendLine("Date,Name,Email,Rating,Feedback")
        For Each pdfFile As String In Directory.GetFiles(folderPath, "*.pdf")
            Try
                Dim survey As PdfDocument = PdfDocument.FromFile(pdfFile)
                Dim [date] As String = If(survey.Form.FindFormField("surveyDate")?.Value, "")
                Dim name As String = If(survey.Form.FindFormField("customerName")?.Value, "")
                Dim email As String = If(survey.Form.FindFormField("email")?.Value, "")
                Dim rating As String = If(survey.Form.FindFormField("satisfaction")?.Value, "")
                Dim feedback As String = If(survey.Form.FindFormField("comments")?.Value, "")
                feedback = feedback.Replace(vbLf, " ").Replace("""", """""")
                csvData.AppendLine($"{[date]},{name},{email},{rating},""{feedback}""")
            Catch ex As Exception
                Console.WriteLine($"Error processing {pdfFile}: {ex.Message}")
            End Try
        Next
        File.WriteAllText("survey_results.csv", csvData.ToString())
        Console.WriteLine("Survey processing complete!")
    End Sub
End Class

using Microsoft.AspNetCore.Mvc;
using IronPdf;
using System.Collections.Concurrent;

[ApiController]
[Route("api/[controller]")]
public class FormProcessorController : ControllerBase
{
    private static readonly ConcurrentDictionary<string, ProcessingStatus> _processingJobs = new();

    [HttpPost("extract")]
    public async Task<IActionResult> ExtractFormData(IFormFile pdfFile)
    {
        if (pdfFile == null || pdfFile.Length == 0)
            return BadRequest("No file uploaded");

        var jobId = Guid.NewGuid().ToString();
        _processingJobs[jobId] = new ProcessingStatus { Status = "Processing" };

        // Process asynchronously to avoid blocking
        _ = Task.Run(async () =>
        {
            try
            {
                using var stream = new MemoryStream();
                await pdfFile.CopyToAsync(stream);
                var pdf = PdfDocument.FromStream(stream);

                var extractedData = new Dictionary<string, string>();
                foreach (var field in pdf.Form)
                {
                    extractedData[field.Name] = field.Value;
                }

                _processingJobs[jobId] = new ProcessingStatus 
                { 
                    Status = "Complete",
                    Data = extractedData
                };
            }
            catch (Exception ex)
            {
                _processingJobs[jobId] = new ProcessingStatus 
                { 
                    Status = "Error",
                    Error = ex.Message
                };
            }
        });

        return Accepted(new { jobId });
    }

    [HttpGet("status/{jobId}")]
    public IActionResult GetStatus(string jobId)
    {
        if (_processingJobs.TryGetValue(jobId, out var status))
            return Ok(status);
        return NotFound();
    }

    [HttpGet("health")]
    public IActionResult HealthCheck()
    {
        return Ok(new 
        { 
            status = "healthy",
            activeJobs = _processingJobs.Count(j => j.Value.Status == "Processing"),
            completedJobs = _processingJobs.Count(j => j.Value.Status == "Complete")
        });
    }
}

public class ProcessingStatus
{
    public string Status { get; set; }
    public Dictionary<string, string> Data { get; set; }
    public string Error { get; set; }
}

Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System.Collections.Concurrent
Imports System.IO
Imports System.Threading.Tasks

<ApiController>
<Route("api/[controller]")>
Public Class FormProcessorController
    Inherits ControllerBase

    Private Shared ReadOnly _processingJobs As New ConcurrentDictionary(Of String, ProcessingStatus)()

    <HttpPost("extract")>
    Public Async Function ExtractFormData(pdfFile As IFormFile) As Task(Of IActionResult)
        If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
            Return BadRequest("No file uploaded")
        End If

        Dim jobId = Guid.NewGuid().ToString()
        _processingJobs(jobId) = New ProcessingStatus With {.Status = "Processing"}

        ' Process asynchronously to avoid blocking
        _ = Task.Run(Async Function()
                         Try
                             Using stream As New MemoryStream()
                                 Await pdfFile.CopyToAsync(stream)
                                 Dim pdf = PdfDocument.FromStream(stream)

                                 Dim extractedData As New Dictionary(Of String, String)()
                                 For Each field In pdf.Form
                                     extractedData(field.Name) = field.Value
                                 Next

                                 _processingJobs(jobId) = New ProcessingStatus With {
                                     .Status = "Complete",
                                     .Data = extractedData
                                 }
                             End Using
                         Catch ex As Exception
                             _processingJobs(jobId) = New ProcessingStatus With {
                                 .Status = "Error",
                                 .Error = ex.Message
                             }
                         End Try
                     End Function)

        Return Accepted(New With {Key .jobId = jobId})
    End Function

    <HttpGet("status/{jobId}")>
    Public Function GetStatus(jobId As String) As IActionResult
        Dim status As ProcessingStatus = Nothing
        If _processingJobs.TryGetValue(jobId, status) Then
            Return Ok(status)
        End If
        Return NotFound()
    End Function

    <HttpGet("health")>
    Public Function HealthCheck() As IActionResult
        Return Ok(New With {
            Key .status = "healthy",
            Key .activeJobs = _processingJobs.Count(Function(j) j.Value.Status = "Processing"),
            Key .completedJobs = _processingJobs.Count(Function(j) j.Value.Status = "Complete")
        })
    End Function
End Class

Public Class ProcessingStatus
    Public Property Status As String
    Public Property Data As Dictionary(Of String, String)
    Public Property Error As String
End Class

version: '3.8'
services:
  form-processor:
    build: .
    ports:
      - "8080:80"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - IRONPDF_LICENSE_KEY=${IRONPDF_LICENSE_KEY}
    healthcheck:
      test: ["CMD", "curl", "-f", "___PROTECTED_URL_7___"]
      interval: 30s
      timeout: 10s
      retries: 3
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 2G
        reservations:
          cpus: '1'
          memory: 1G

using IronPdf;
using System.Threading.Tasks.Dataflow;

public class HighPerformanceFormProcessor
{
    public static async Task ProcessFormsInParallel(string[] pdfPaths)
    {
        // Configure parallelism based on available CPU cores
        var processorCount = Environment.ProcessorCount;
        var actionBlock = new ActionBlock<string>(
            async pdfPath => await ProcessSingleForm(pdfPath),
            new ExecutionDataflowBlockOptions
            {
                MaxDegreeOfParallelism = processorCount,
                BoundedCapacity = processorCount * 2 // Prevent memory overflow
            });

        // Feed PDFs to the processing pipeline
        foreach (var path in pdfPaths)
        {
            await actionBlock.SendAsync(path);
        }

        actionBlock.Complete();
        await actionBlock.Completion;
    }

    private static async Task ProcessSingleForm(string pdfPath)
    {
        try
        {
            // Use async file reading to avoid blocking I/O
            using var fileStream = new FileStream(pdfPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true);
            var pdf = PdfDocument.FromStream(fileStream);

            // Process form fields
            var results = new Dictionary<string, string>();
            foreach (var field in pdf.Form)
            {
                results[field.Name] = field.Value;
            }

            // Store results (implement your storage logic)
            await StoreResults(Path.GetFileName(pdfPath), results);
        }
        catch (Exception ex)
        {
            // Log error (implement your logging)
            Console.WriteLine($"Error processing {pdfPath}: {ex.Message}");
        }
    }

    private static async Task StoreResults(string fileName, Dictionary<string, string> data)
    {
        // Implement your storage logic (database, file system, cloud storage)
        await Task.CompletedTask; // Placeholder
    }
}

Imports IronPdf
Imports System.Threading.Tasks.Dataflow
Imports System.IO

Public Class HighPerformanceFormProcessor
    Public Shared Async Function ProcessFormsInParallel(pdfPaths As String()) As Task
        ' Configure parallelism based on available CPU cores
        Dim processorCount = Environment.ProcessorCount
        Dim actionBlock = New ActionBlock(Of String)(
            Async Function(pdfPath) Await ProcessSingleForm(pdfPath),
            New ExecutionDataflowBlockOptions With {
                .MaxDegreeOfParallelism = processorCount,
                .BoundedCapacity = processorCount * 2 ' Prevent memory overflow
            })

        ' Feed PDFs to the processing pipeline
        For Each path In pdfPaths
            Await actionBlock.SendAsync(path)
        Next

        actionBlock.Complete()
        Await actionBlock.Completion
    End Function

    Private Shared Async Function ProcessSingleForm(pdfPath As String) As Task
        Try
            ' Use async file reading to avoid blocking I/O
            Using fileStream As New FileStream(pdfPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, True)
                Dim pdf = PdfDocument.FromStream(fileStream)

                ' Process form fields
                Dim results = New Dictionary(Of String, String)()
                For Each field In pdf.Form
                    results(field.Name) = field.Value
                Next

                ' Store results (implement your storage logic)
                Await StoreResults(Path.GetFileName(pdfPath), results)
            End Using
        Catch ex As Exception
            ' Log error (implement your logging)
            Console.WriteLine($"Error processing {pdfPath}: {ex.Message}")
        End Try
    End Function

    Private Shared Async Function StoreResults(fileName As String, data As Dictionary(Of String, String)) As Task
        ' Implement your storage logic (database, file system, cloud storage)
        Await Task.CompletedTask ' Placeholder
    End Function
End Class

using Prometheus;
using System.Diagnostics;

public class MonitoredFormProcessor
{
    private static readonly Counter ProcessedFormsCounter = Metrics
        .CreateCounter("pdf_forms_processed_total", "Total number of processed PDF forms");

    private static readonly Histogram ProcessingDuration = Metrics
        .CreateHistogram("pdf_form_processing_duration_seconds", "Processing duration in seconds");

    private static readonly Gauge ActiveProcessingGauge = Metrics
        .CreateGauge("pdf_forms_active_processing", "Number of forms currently being processed");

    public async Task<FormExtractionResult> ProcessFormWithMetrics(string pdfPath)
    {
        using (ProcessingDuration.NewTimer())
        {
            ActiveProcessingGauge.Inc();
            try
            {
                var pdf = PdfDocument.FromFile(pdfPath);
                var result = new FormExtractionResult
                {
                    FieldCount = pdf.Form.Count(),
                    Fields = new Dictionary<string, string>()
                };

                foreach (var field in pdf.Form)
                {
                    result.Fields[field.Name] = field.Value;
                }

                ProcessedFormsCounter.Inc();
                return result;
            }
            finally
            {
                ActiveProcessingGauge.Dec();
            }
        }
    }
}

public class FormExtractionResult
{
    public int FieldCount { get; set; }
    public Dictionary<string, string> Fields { get; set; }
}

Imports Prometheus
Imports System.Diagnostics

Public Class MonitoredFormProcessor
    Private Shared ReadOnly ProcessedFormsCounter As Counter = Metrics.CreateCounter("pdf_forms_processed_total", "Total number of processed PDF forms")

    Private Shared ReadOnly ProcessingDuration As Histogram = Metrics.CreateHistogram("pdf_form_processing_duration_seconds", "Processing duration in seconds")

    Private Shared ReadOnly ActiveProcessingGauge As Gauge = Metrics.CreateGauge("pdf_forms_active_processing", "Number of forms currently being processed")

    Public Async Function ProcessFormWithMetrics(pdfPath As String) As Task(Of FormExtractionResult)
        Using ProcessingDuration.NewTimer()
            ActiveProcessingGauge.Inc()
            Try
                Dim pdf = PdfDocument.FromFile(pdfPath)
                Dim result As New FormExtractionResult With {
                    .FieldCount = pdf.Form.Count(),
                    .Fields = New Dictionary(Of String, String)()
                }

                For Each field In pdf.Form
                    result.Fields(field.Name) = field.Value
                Next

                ProcessedFormsCounter.Inc()
                Return result
            Finally
                ActiveProcessingGauge.Dec()
            End Try
        End Using
    End Function
End Class

Public Class FormExtractionResult
    Public Property FieldCount As Integer
    Public Property Fields As Dictionary(Of String, String)
End Class