Wie man Daten aus PDF-Dateien in ASP.NET Core liest

Wie richtet man IronPDF in einem ASP.NET Core -Projekt ein?

Der Einstieg ist unkompliziert. Installieren Sie das NuGet-Paket von IronPDF über die NuGet Package Manager Console oder die .NET CLI mit einem der folgenden Befehle:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Sobald das Paket installiert ist, fügen Sie den IronPDF Namespace am Anfang jeder Datei hinzu, die mit PDF-Dokumenten arbeitet:

using IronPdf;

using IronPdf;

Imports IronPdf

Das ist die gesamte Vorbereitung, die für die meisten Projekte erforderlich ist. IronPDF benötigt keine externen Rendering-Prozesse oder zusätzliche native Abhängigkeiten unter Windows. Für Linux- oder Docker-Umgebungen konsultieren Sie bitte die IronPDF Dokumentation für plattformspezifische Anleitungen.

Mit einer kostenlosen Testlizenz können Sie den vollen Funktionsumfang testen, bevor Sie sich für den Produktiveinsatz entscheiden. Sie können eine Testlizenz direkt von der IronPDF Website erhalten und diese vor Ihrer ersten PDF-Operation in einer einzigen Codezeile anwenden.

Wie extrahiert man Text aus einer PDF-Datei?

Die Textextraktion ist die häufigste Aufgabe beim Lesen von PDFs. IronPDF bietet ExtractAllText, um den gesamten lesbaren Text aus einem Dokument zu ziehen und ExtractTextFromPage für den Zugriff auf Seitenebene. Beide Methoden erhalten die Lesereihenfolge und verarbeiten gängige Textkodierungen.

// Load a PDF document from disk
var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text from every page
string allText = pdf.ExtractAllText();

// Extract text from a specific page (zero-based index)
string pageOneText = pdf.ExtractTextFromPage(0);

Console.WriteLine(allText);

// Load a PDF document from disk
var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text from every page
string allText = pdf.ExtractAllText();

// Extract text from a specific page (zero-based index)
string pageOneText = pdf.ExtractTextFromPage(0);

Console.WriteLine(allText);

Imports System

' Load a PDF document from disk
Dim pdf = PdfDocument.FromFile("document.pdf")

' Extract all text from every page
Dim allText As String = pdf.ExtractAllText()

' Extract text from a specific page (zero-based index)
Dim pageOneText As String = pdf.ExtractTextFromPage(0)

Console.WriteLine(allText)

ExtractAllText gibt den gesamten Textinhalt als eine einzige Zeichenkette zurück, wobei Zeilenumbrüche erhalten bleiben. ExtractTextFromPage zielt auf eine einzelne Seite mit einem nullbasierten Index ab, was nützlich ist, wenn Sie nur den Inhalt eines bestimmten Abschnitts eines mehrseitigen Dokuments benötigen.

Für einen detaillierten Überblick über die Optionen zur Text- und Bildextraktion behandelt der Leitfaden "Text aus PDF extrahieren" fortgeschrittene Szenarien, einschließlich regionenbasierter Extraktion.

using IronPdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    [HttpPost("extract-text")]
    public IActionResult ExtractText(IFormFile pdfFile)
    {
        if (pdfFile == null || pdfFile.Length == 0)
            return BadRequest("No PDF file uploaded.");

        using var stream = new MemoryStream();
        pdfFile.CopyTo(stream);

        var pdf = new PdfDocument(stream.ToArray());
        string extractedText = pdf.ExtractAllText();

        return Ok(new { text = extractedText });
    }
}

using IronPdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    [HttpPost("extract-text")]
    public IActionResult ExtractText(IFormFile pdfFile)
    {
        if (pdfFile == null || pdfFile.Length == 0)
            return BadRequest("No PDF file uploaded.");

        using var stream = new MemoryStream();
        pdfFile.CopyTo(stream);

        var pdf = new PdfDocument(stream.ToArray());
        string extractedText = pdf.ExtractAllText();

        return Ok(new { text = extractedText });
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
Imports System.IO

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

    <HttpPost("extract-text")>
    Public Function ExtractText(pdfFile As IFormFile) As IActionResult
        If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
            Return BadRequest("No PDF file uploaded.")
        End If

        Using stream As New MemoryStream()
            pdfFile.CopyTo(stream)

            Dim pdf As New PdfDocument(stream.ToArray())
            Dim extractedText As String = pdf.ExtractAllText()

            Return Ok(New With {.text = extractedText})
        End Using
    End Function
End Class

Wie liest man PDF-Formulardaten in ASP.NET Core?

PDF-Formulare – auch AcroForms genannt – enthalten interaktive Felder, die von den Benutzern ausgefüllt werden. IronPDF macht Formularfelder über die Form-Eigenschaft von PdfDocument sichtbar und gibt Ihnen den Namen und den Wert jedes Feldes im Dokument.

Der folgende Endpunkt liest ein hochgeladenes Formular-PDF und gibt alle Feldwerte als JSON-Wörterbuch zurück:

[HttpPost("extract-form")]
public IActionResult ExtractForm([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var stream = new MemoryStream();
    pdfFile.CopyTo(stream);

    var pdf = new PdfDocument(stream.ToArray());
    var formData = new Dictionary<string, string>();

    if (pdf.Form != null)
    {
        foreach (var field in pdf.Form)
        {
            formData[field.Name] = field.Value;
        }
    }

    return Ok(new { formFields = formData });
}

[HttpPost("extract-form")]
public IActionResult ExtractForm([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var stream = new MemoryStream();
    pdfFile.CopyTo(stream);

    var pdf = new PdfDocument(stream.ToArray());
    var formData = new Dictionary<string, string>();

    if (pdf.Form != null)
    {
        foreach (var field in pdf.Form)
        {
            formData[field.Name] = field.Value;
        }
    }

    return Ok(new { formFields = formData });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO

<HttpPost("extract-form")>
Public Function ExtractForm(<FromForm> pdfFile As IFormFile) As IActionResult
    If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using stream As New MemoryStream()
        pdfFile.CopyTo(stream)

        Dim pdf = New PdfDocument(stream.ToArray())
        Dim formData As New Dictionary(Of String, String)()

        If pdf.Form IsNot Nothing Then
            For Each field In pdf.Form
                formData(field.Name) = field.Value
            Next
        End If

        Return Ok(New With {.formFields = formData})
    End Using
End Function

Jedes Feld in pdf.Form hat eine Name-Eigenschaft (der im PDF-Authoring-Tool eingestellte Feldbezeichner) und eine Value-Eigenschaft (der vom Benutzer eingegebene Text oder die Auswahl). In dieser Sammlung sind Textfelder, Kontrollkästchen, Optionsfelder und Dropdown-Menüs enthalten.

Die JSON-Antwort ermöglicht es, Formularübermittlungen ohne zusätzliche Verarbeitung an eine Datenbank, eine Drittanbieter-API oder eine Message Queue weiterzuleiten. Für Arbeitsabläufe, die das programmgesteuerte Erstellen oder Bearbeiten von PDF-Formularen beinhalten, zeigt der Leitfaden zu PDF-Formularen, wie Felder hinzugefügt und Werte vorausgefüllt werden.

Wie extrahiert man Tabellendaten aus einer PDF-Datei?

Tabellen in PDF-Dateien werden als positionierter Text gespeichert – im PDF-Format gibt es keine native Tabellendatenstruktur. Das Extrahieren tabellarischer Daten bedeutet daher, den Rohtext zu extrahieren und anschließend eine Parsing-Logik anzuwenden, um Zeilen und Spalten wiederherzustellen.

IronPDF's ExtractAllText bewahrt Leerzeichen und Tabulatorzeichen, wodurch es möglich ist, Zeilen programmatisch in Spalten aufzuteilen. Die folgende Controller-Aktion veranschaulicht diesen Ansatz:

[HttpPost("extract-table")]
public IActionResult ExtractTable([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var memoryStream = new MemoryStream();
    pdfFile.CopyTo(memoryStream);

    var pdf = new PdfDocument(memoryStream.ToArray());
    string text = pdf.ExtractAllText();

    // Split into lines, then split each line into columns
    string[] lines = text.Split(
        new[] { '\r', '\n' },
        StringSplitOptions.RemoveEmptyEntries
    );

    var tableData = new List<string[]>();
    foreach (string line in lines)
    {
        string[] columns = line
            .Split('\t')
            .Where(c => !string.IsNullOrWhiteSpace(c))
            .ToArray();

        if (columns.Length > 0)
            tableData.Add(columns);
    }

    var table = tableData.Select(r => string.Join(" | ", r)).ToList();
    return Ok(new { Table = table });
}

[HttpPost("extract-table")]
public IActionResult ExtractTable([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var memoryStream = new MemoryStream();
    pdfFile.CopyTo(memoryStream);

    var pdf = new PdfDocument(memoryStream.ToArray());
    string text = pdf.ExtractAllText();

    // Split into lines, then split each line into columns
    string[] lines = text.Split(
        new[] { '\r', '\n' },
        StringSplitOptions.RemoveEmptyEntries
    );

    var tableData = new List<string[]>();
    foreach (string line in lines)
    {
        string[] columns = line
            .Split('\t')
            .Where(c => !string.IsNullOrWhiteSpace(c))
            .ToArray();

        if (columns.Length > 0)
            tableData.Add(columns);
    }

    var table = tableData.Select(r => string.Join(" | ", r)).ToList();
    return Ok(new { Table = table });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Linq

<HttpPost("extract-table")>
Public Function ExtractTable(<FromForm> pdfFile As IFormFile) As IActionResult
    If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using memoryStream As New MemoryStream()
        pdfFile.CopyTo(memoryStream)

        Dim pdf As New PdfDocument(memoryStream.ToArray())
        Dim text As String = pdf.ExtractAllText()

        ' Split into lines, then split each line into columns
        Dim lines As String() = text.Split(New Char() {ControlChars.Cr, ControlChars.Lf}, StringSplitOptions.RemoveEmptyEntries)

        Dim tableData As New List(Of String())()
        For Each line As String In lines
            Dim columns As String() = line.Split(ControlChars.Tab).Where(Function(c) Not String.IsNullOrWhiteSpace(c)).ToArray()

            If columns.Length > 0 Then
                tableData.Add(columns)
            End If
        Next

        Dim table = tableData.Select(Function(r) String.Join(" | ", r)).ToList()
        Return Ok(New With {.Table = table})
    End Using
End Function

Diese Vorgehensweise eignet sich gut für PDFs, deren Tabellen durchgängig tabulatorgetrennte Spalten verwenden. Bei Dokumenten, in denen Spalten durch variable Leerzeichen getrennt sind, müssen Sie möglicherweise eine Heuristik für minimale Abstände anwenden oder die Zeichenpositionen überprüfen. Die Anleitung zum Zusammenführen oder Aufteilen von PDFs ist hilfreich, wenn Sie vor der Extraktion bestimmte Seiten isolieren müssen, die Tabellen enthalten.

Wie geht man mit asynchronen PDF-Datei-Uploads um?

In produktiven ASP.NET Core -Anwendungen sollten Datei-Uploads asynchron verarbeitet werden, um eine Blockierung des Thread-Pools zu vermeiden. Die IFormFile.CopyToAsync Methode kombiniert mit async/await hält den Controller nicht blockierend:

[HttpPost("process-upload")]
public async Task<IActionResult> ProcessPdf([FromForm] IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var ms = new MemoryStream();
    await file.CopyToAsync(ms);

    var pdf = new PdfDocument(ms.ToArray());
    string text = pdf.ExtractAllText();
    int pageCount = pdf.PageCount;

    return Ok(new
    {
        text,
        pages = pageCount
    });
}

[HttpPost("process-upload")]
public async Task<IActionResult> ProcessPdf([FromForm] IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var ms = new MemoryStream();
    await file.CopyToAsync(ms);

    var pdf = new PdfDocument(ms.ToArray());
    string text = pdf.ExtractAllText();
    int pageCount = pdf.PageCount;

    return Ok(new
    {
        text,
        pages = pageCount
    });
}

Imports System.IO
Imports Microsoft.AspNetCore.Mvc

<HttpPost("process-upload")>
Public Async Function ProcessPdf(<FromForm> file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using ms As New MemoryStream()
        Await file.CopyToAsync(ms)

        Dim pdf As New PdfDocument(ms.ToArray())
        Dim text As String = pdf.ExtractAllText()
        Dim pageCount As Integer = pdf.PageCount

        Return Ok(New With {
            .text = text,
            .pages = pageCount
        })
    End Using
End Function

Der PdfDocument Konstruktor ist synchron, aber der Upload-Schritt - oft der langsamste Teil der Pipeline - läuft asynchron. Dieses Muster skaliert gut unter gleichzeitiger Last und ist kompatibel mit minimalen API-Endpunkten, Razor Pages-Handlern und gRPC-Diensten.

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024; // 100 MB
});

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024; // 100 MB
});

Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.AspNetCore.Http

builder.Services.Configure(Of FormOptions)(Sub(options)
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024 ' 100 MB
End Sub)

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024;
});

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024;
});

builder.WebHost.ConfigureKestrel(Sub(options)
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024
End Sub)

Wie konvertiert man extrahierte PDF-Inhalte in andere Formate?

Sobald Sie über Text- oder Formulardaten verfügen, können Sie diese in jeden nachgelagerten Prozess einspeisen, den Ihre Anwendung benötigt – Datenbankzugriffe, Suchindizierung, Berichtserstellung oder API-Aufrufe. IronPDF unterstützt auch die Konvertierung in die andere Richtung: das Rendern von HTML zu PDF.

Für Fälle, in denen Sie extrahierte Inhalte visuell darstellen möchten, können Sie die ursprüngliche PDF-Datei mithilfe der Anleitung zur PDF-zu-Bild-Konvertierung als Bilder rendern. Dies ist nützlich für Dokumentvorschaufunktionen, bei denen Sie Seitenminiaturen anzeigen möchten, ohne die vollständige PDF-Datei im Browser zu laden.

Falls Sie die Ausgabedokumente vor der Auslieferung an die Benutzer schützen müssen, unterstützt IronPDF digitale Signaturen und Wasserzeichen als Nachbearbeitungsschritte. Das Hinzufügen von Kopf- und Fußzeilen – wie im Leitfaden für Kopf- und Fußzeilen beschrieben – ist ähnlich unkompliziert.

Was sind die nächsten Schritte nach der Einrichtung der PDF-Datenextraktion?

Sie verfügen nun über funktionierende Muster für die Textextraktion, das Lesen von Formulardaten, das Parsen von Tabellen und das asynchrone Hochladen. Hier sind einige weitere Möglichkeiten, die Sie je nach den Anforderungen Ihrer Anwendung erkunden können.

Falls Sie im Rahmen Ihres Extraktionsworkflows auch PDF-Berichte generieren müssen, bietet die Funktionsübersicht von IronPDF Informationen zu HTML-zu-PDF-Rendering, Stempelüberlagerungen und Seitenmanipulation. Für Anwendungen, die Berichte aus mehreren Quellen zusammenführen, beschreibt der Leitfaden zum Zusammenführen oder Aufteilen von PDFs das Kombinieren und Aufteilen von Dokumenten.

Für eine sichere Dokumentenübermittlung ermöglichen digitale Signaturen die Zertifizierung von PDFs vor dem Versenden an Kunden. Benutzerdefinierte Wasserzeichen fügen generierten Dokumenten ein visuelles Branding oder Entwurfsetiketten hinzu.

Wenn Ihr Projekt Daten aus gescannten PDFs (Bilder statt durchsuchbarem Text) extrahiert, benötigen Sie einen OCR-Schritt vor dem Aufruf von ExtractAllText. IronOCR von Iron Software integriert sich in IronPDF , um Arbeitsabläufe für gescannte Dokumente zu verwalten.

IronPDF ist mit flexiblen Lizenzoptionen für einzelne Entwickler und Teams erhältlich. Starten Sie mit einer kostenlosen Testversion , um alle Funktionen uneingeschränkt zu testen. Die vollständige Dokumentation umfasst eine API-Referenz, Anleitungen für den Einstieg sowie Hinweise zur Bereitstellung für Windows-, Linux-, Docker- und Cloud-Umgebungen.

Das Lesen von Daten aus PDF-Dateien in ASP.NET Core erfordert keinen Low-Level-Parsing-Code oder aufwändige Abhängigkeiten mehr. Mit IronPDF besteht der Weg von der hochgeladenen Datei zum extrahierten Inhalt aus nur wenigen Zeilen Code, die sich nahtlos in jede Controller- oder Serviceschicht einfügen.