IronPDF vereinfacht die PDF-Datenextraktion in ASP.NET Core , indem es Methoden zum Lesen von Text, Formulardaten und Tabellen aus PDF-Dateien mit unkompliziertem C#-Code ohne komplexe Abhängigkeiten oder manuelles Parsen bereitstellt.

Die Arbeit mit PDF-Dateien in .NET Anwendungen kann schwieriger sein, als es zunächst scheint. Möglicherweise müssen Sie Text aus hochgeladenen Rechnungen extrahieren, Formulardaten aus Umfragen abrufen oder Tabellen für Ihre Datenbank analysieren. Viele Projekte verlangsamen sich, weil Entwickler auf übermäßig komplexe Bibliotheken zurückgreifen, die umfangreichen benutzerdefinierten Parsing-Code erfordern. IronPDF bietet eine unkomplizierte Alternative, mit der Sie PDF-Dokumente mit minimalem Aufwand lesen und bearbeiten können.

Egal ob einfacher Text, interaktive Formularfelder oder strukturierte Tabellendaten – die IronPDF-API ermöglicht Ihnen den direkten Zugriff auf PDF-Inhalte ohne aufwändiges Parsen. Dieser Leitfaden beschreibt, wie man Daten aus PDF-Dateien in ASP.NET Core liest und behandelt dabei die Textextraktion, das Abrufen von Formulardaten, das Parsen von Tabellen und die asynchrone Verarbeitung von Datei-Uploads – alles mit C#-Code, den Sie in Ihr Projekt einfügen können.

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

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

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 extrahieren, 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)

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 kompletten Textinhalt als einzelnen String zurück, wobei Zeilenumbrüche erhalten bleiben. ExtractTextFromPage zielt auf eine einzelne Seite ab, indem ein null-basierter Index verwendet wird, was nützlich ist, wenn Sie nur Inhalte aus einem bestimmten Abschnitt 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.

Wie integriert man die Textextraktion in einen ASP.NET Core Controller?

Die folgende Controller-Aktion akzeptiert eine hochgeladene PDF-Datei über IFormFile, liest sie in einen MemoryStream ein und gibt den extrahierten Text als JSON zurück:

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

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

Dieser Endpunkt konvertiert die hochgeladene Datei in ein Byte-Array und übergibt es direkt an PdfDocument. Es werden keine temporären Dateien auf die Festplatte geschrieben, wodurch der Code sauber bleibt und unnötiger Speicherbedarf vermieden wird. Die IFormFile-Schnittstelle funktioniert selbstverständlich sowohl mit multipart-Formularübermittlungen als auch mit API-Clients wie Postman.

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 stellt Formularfelder über die Form-Eigenschaft von PdfDocument bereit, wodurch Sie den Namen und den Wert jedes Feldes im Dokument erhalten.

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

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 verfügt über eine Name-Eigenschaft (die im PDF-Erstellungstool festgelegte Feldkennung) und eine Value-Eigenschaft (den vom Benutzer eingegebenen 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 Workflows, die das programmgesteuerte Erstellen oder Bearbeiten von PDF-Formularen beinhalten, zeigt der PDF-Formularleitfaden, wie man Felder hinzufügt und Werte vorab füllt.

Wie sieht eine typische Antwort auf eine Formularauswertung aus?

Die obige Antwort zeigt ein 200 OK-Ergebnis, das die Feldnamen und Werte aus einem Beispiel-Kontaktformular im PDF-Format enthält. Die Struktur ist eine flache Schlüssel-Wert-Zuordnung, die sich problemlos auf die meisten Datenbankschemata oder REST-Payloads abbilden lässt.

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.

Das ExtractAllText von IronPDF bewahrt Leerzeichen und Tabulatorzeichen, was es ermöglicht, Zeilen programmgesteuert in Spalten zu teilen. 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

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.

Wann sollte man Tabellen manuell parsen?

Manuelles Parsen ist die richtige Wahl, wenn die PDF-Datei nicht aus HTML oder einer strukturierten Datenquelle generiert wurde – beispielsweise aus gescannten Rechnungen oder Dokumenten, die mit Desktop-Publishing-Tools erstellt wurden. Die Tab-Split-Methode verarbeitet viele Standard-PDFs zuverlässig. Bei unregelmäßigen Spaltengrenzen können Sie die Logik verfeinern, indem Sie die rohen Zeichenkoordinaten über die DOM-Zugriffs-API von IronPDF untersuchen.

Bei Dokumenten, die aus HTML generiert werden, empfiehlt sich die Verwendung eines HTML-Zwischenspeichers für die Roundtrip-Funktion. Wenn Sie Ihr PDF aus einer datengesteuerten HTML-Vorlage generieren (wie im Leitfaden "HTML-String zu PDF " beschrieben), sind die Textpositionen vorhersehbar und die Extraktion unkompliziert.

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 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

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.

Wie kann man die Größe von Upload-Dateien begrenzen?

ASP.NET Core erzwingt eine standardmäßige Beschränkung der Anforderungstextgröße auf 30 MB. Bei größeren PDFs erhöhen Sie das Limit in Program.cs:

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)

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

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

Kestrel hat ein eigenes Limit, das Sie möglicherweise ebenfalls erhöhen müssen:

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)

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

Legen Sie diese Werte basierend auf der realistischen maximalen Größe der PDFs fest, die Ihre Anwendung verarbeiten wird. Um unerwartete Eingaben zu vermeiden, sollten Sie vor der Übergabe der hochgeladenen Datei an IronPDF immer den MIME-Typ und die Dateierweiterung überprüfen.

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 anstelle von durchsuchbarem Text) extrahiert, benötigen Sie einen OCR-Schritt, bevor Sie ExtractAllText aufrufen. 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.