IRONPDF VERWENDEN

Lesen einer PDF-Tabelle in C#

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Chipego Kalinda

25. März 2023

Aktualisiert 19. Mai 2025

Teilen Sie:

Das Extrahieren strukturierter Tabellendaten aus PDF-Dokumenten ist eine häufige Notwendigkeit für C#-Entwickler, entscheidend für die Datenanalyse, Berichterstellung oder die Integration von Informationen in andere Systeme. Allerdings sind PDFs hauptsächlich für eine konsistente visuelle Darstellung konzipiert, nicht für einfache Datenauswertung. Dies kann das programmatische Lesen von Tabellen aus PDF-Dateien in C# zu einer anspruchsvollen Aufgabe machen, insbesondere da Tabellen stark variieren können—von einfachen textbasierten Gittern bis zu komplexen Layouts mit zusammengeführten Zellen oder sogar Tabellen, die als Bilder in gescannten Dokumenten eingebettet sind.

Diese Anleitung bietet ein umfassendes C#-Tutorial, wie man die PDF-Tabellenextraktion mit IronPDF angeht. Wir werden hauptsächlich untersuchen, wie man die leistungsstarken Textextraktionsfähigkeiten von IronPDF nutzt, um tabellarische Daten aus textbasierten PDFs zu extrahieren und zu analysieren. Wir werden die Effektivität dieser Methode besprechen, Strategien für das Parsen bereitstellen und Einblicke in die Handhabung der extrahierten Informationen geben. Zusätzlich werden wir Strategien zur Bewältigung komplexerer Szenarien besprechen, einschließlich gescannter PDFs.

Wichtige Schritte zur Extraktion von Tabellendaten aus PDFs in C#

Installieren Sie die IronPDF C#-Bibliothek (https://nuget.org/packages/IronPdf/) für die PDF-Verarbeitung.
(Optionaler Demoschritt) Erstellen Sie ein Beispiel-PDF mit einer Tabelle aus einem HTML-String mit RenderHtmlAsPdf von IronPDF. (Siehe Abschnitt: (Demo-Schritt) Erstellen eines PDF-Dokuments mit Tabellendaten)
Laden Sie ein beliebiges PDF-Dokument und verwenden Sie die ExtractAllText-Methode, um dessen Rohtextinhalt abzurufen. (Siehe Abschnitt: Extrahieren Sie alle Textdaten, die Tabellendaten aus dem PDF enthalten)
Implementieren Sie C#-Logik, um den extrahierten Text zu parsen und Tabellenzeilen und -zellen zu identifizieren. (Siehe Abschnitt: Parsen extrahierter Text zur Rekonstruktion von Tabellendaten in C#)
Geben Sie die strukturierten Tabellendaten aus oder speichern Sie sie zur weiteren Verwendung in einer CSV-Datei. (Siehe Abschnitt: Parsen extrahierter Text zur Rekonstruktion von Tabellendaten in C#)
Ziehen Sie fortgeschrittene Techniken wie OCR für gescannte PDFs in Betracht (später besprochen).

IronPDF - C# PDF-Bibliothek

IronPDF ist eine C# .NET Bibliothekslösung für PDF-Manipulationen in .NET (https://ironpdf.com/), die Entwicklern hilft, PDF-Dokumente einfach in ihren Softwareanwendungen zu lesen, zu erstellen und zu bearbeiten. Die robuste Chromium-Engine rendert PDF-Dokumente aus HTML mit hoher Genauigkeit und Geschwindigkeit. Es ermöglicht Entwicklern die nahtlose Konvertierung von verschiedenen Formaten in PDF und umgekehrt. Es unterstützt die neuesten .NET-Frameworks einschließlich .NET 7, .NET 6, 5, 4, .NET Core und Standard.

Darüber hinaus ermöglicht die IronPDF .NET API Entwicklern auch, PDFs zu manipulieren und zu bearbeiten, Kopf- und Fußzeilen hinzuzufügen und, was besonders wichtig ist, Text, Bilder und (wie wir sehen werden) Tabellendaten einfach aus PDFs zu extrahieren.

Einige wichtige Funktionen umfassen:

Erstellen Sie PDF-Dateien aus verschiedenen Quellen (Bilder zu PDF)
Laden, Speichern und PDF-Dateien drucken
PDF-Dateien teilen
Daten extrahieren (Text, Bilder und strukturierte Daten wie Tabellen) aus PDF-Dateien

Schritte zum Extrahieren von Tabellendaten in C# mit der IronPDF-Bibliothek

Um Tabellendaten aus PDF-Dokumenten zu extrahieren, richten wir ein C#-Projekt ein:

Visual Studio: Stellen Sie sicher, dass Visual Studio (z.B. 2022) installiert ist. Wenn nicht, laden Sie es von der Visual Studio-Website herunter (https://visualstudio.microsoft.com/downloads/).
Projekt erstellen:
- Öffnen Sie Visual Studio 2022 und klicken Sie auf Neues Projekt erstellen.
Startbildschirm von Visual Studio
- Wählen Sie "Konsolenanwendung" (oder Ihren bevorzugten C#-Projekttyp) und klicken Sie auf Weiter.
Erstellen Sie eine neue Konsolenanwendung in Visual Studio
- Benennen Sie Ihr Projekt (z. B. "ReadPDFTableDemo") und klicken Sie auf Weiter.
Konfigurieren Sie die neu erstellte Anwendung
- Wählen Sie Ihr gewünschtes .NET Framework (z.B. .NET 6 oder höher).
Wählen Sie ein .NET Framework aus
- Klicken Sie auf Erstellen. Das Konsolenprojekt wird erstellt.
IronPDF installieren:
- Verwendung des Visual Studio NuGet-Paketmanagers:
  - Klicken Sie mit der rechten Maustaste auf Ihr Projekt im Lösungsexplorer und wählen Sie "NuGet-Pakete verwalten..."
Tools & Pakete verwalten mit NuGet
- Im NuGet-Paket-Manager suchen Sie nach "IronPdf" und klicken Sie auf "Installieren".
Tools & Pakete verwalten mit NuGet
- NuGet-Paket direkt herunterladen: Besuchen Sie die NuGet-Paketseite von IronPDF (https://www.nuget.org/packages/IronPdf/).
- IronPDF .DLL-Bibliothek herunterladen: Laden Sie von der offiziellen IronPDF-Website herunter und binden Sie die DLL in Ihr Projekt ein.

(Demo Schritt) Erstellen Sie ein PDF-Dokument mit Tabellendaten

Für dieses Tutorial erstellen wir zunächst ein Beispiel-PDF, das eine einfache Tabelle aus einem HTML-String enthält. Dies gibt uns eine bekannte PDF-Struktur, um den Extraktionsprozess zu demonstrieren. In einem realen Szenario würden Sie Ihre bereits vorhandenen PDF-Dateien laden.

Fügen Sie den IronPDF-Namespace hinzu und optional Ihren Lizenzschlüssel ein (IronPDF ist für die Entwicklung kostenlos, erfordert jedoch eine Lizenz für den kommerziellen Einsatz ohne Wasserzeichen):

using IronPdf;
using System;       // For StringSplitOptions, Console
using System.IO;    // For StreamWriter

// Apply your license key if you have one. Otherwise, IronPDF runs in trial mode.
// License.LicenseKey = "YOUR-TRIAL/PURCHASED-LICENSE-KEY";

using IronPdf;
using System;       // For StringSplitOptions, Console
using System.IO;    // For StreamWriter

// Apply your license key if you have one. Otherwise, IronPDF runs in trial mode.
// License.LicenseKey = "YOUR-TRIAL/PURCHASED-LICENSE-KEY";

Imports IronPdf
Imports System ' For StringSplitOptions, Console
Imports System.IO ' For StreamWriter

' Apply your license key if you have one. Otherwise, IronPDF runs in trial mode.
' License.LicenseKey = "YOUR-TRIAL/PURCHASED-LICENSE-KEY";

$vbLabelText $csharpLabel

Hier ist der HTML-String für unsere Beispieltabelle:

string HTML = "<html>" +
        "<style>" +
            "table, th, td {" +
                "border:1px solid black;" +
            "}" +
        "</style>" +
        "<body>" +
            "<h1>A Simple table example</h1>" + // Corrected typo: h1 not h2
            "<table>" +
                "<tr>" +
                    "<th>Company</th>" +
                    "<th>Contact</th>" +
                    "<th>Country</th>" +
               "</tr>" +
                "<tr>" +
                    "<td>Alfreds Futterkiste</td>" +
                    "<td>Maria Anders</td>" +
                    "<td>Germany</td>" +
                "</tr>" +
                "<tr>" +
                    "<td>Centro comercial Moctezuma</td>" +
                    "<td>Francisco Chang</td>" +
                    "<td>Mexico</td>" +
                "</tr>" +
            "</table>" +
            "<p>To understand the example better, we have added borders to the table.</p>" +
        "</body>" +
        "</html>";

string HTML = "<html>" +
        "<style>" +
            "table, th, td {" +
                "border:1px solid black;" +
            "}" +
        "</style>" +
        "<body>" +
            "<h1>A Simple table example</h1>" + // Corrected typo: h1 not h2
            "<table>" +
                "<tr>" +
                    "<th>Company</th>" +
                    "<th>Contact</th>" +
                    "<th>Country</th>" +
               "</tr>" +
                "<tr>" +
                    "<td>Alfreds Futterkiste</td>" +
                    "<td>Maria Anders</td>" +
                    "<td>Germany</td>" +
                "</tr>" +
                "<tr>" +
                    "<td>Centro comercial Moctezuma</td>" +
                    "<td>Francisco Chang</td>" +
                    "<td>Mexico</td>" +
                "</tr>" +
            "</table>" +
            "<p>To understand the example better, we have added borders to the table.</p>" +
        "</body>" +
        "</html>";

HTML

Nun verwenden Sie ChromePdfRenderer, um aus diesem HTML eine PDF zu erstellen:

var renderer = new ChromePdfRenderer();
PdfDocument pdfDocument = renderer.RenderHtmlAsPdf(HTML);
pdfDocument.SaveAs("table_example.pdf");
Console.WriteLine("Sample PDF 'table_example.pdf' created.");

var renderer = new ChromePdfRenderer();
PdfDocument pdfDocument = renderer.RenderHtmlAsPdf(HTML);
pdfDocument.SaveAs("table_example.pdf");
Console.WriteLine("Sample PDF 'table_example.pdf' created.");

Dim renderer = New ChromePdfRenderer()
Dim pdfDocument As PdfDocument = renderer.RenderHtmlAsPdf(HTML)
pdfDocument.SaveAs("table_example.pdf")
Console.WriteLine("Sample PDF 'table_example.pdf' created.")

$vbLabelText $csharpLabel

Die SaveAs-Methode speichert die PDF. Das generierte table_example.pdf wird so aussehen (Konzeptbild basierend auf HTML):

Wie man eine PDF-Tabelle in C# liest, Abbildung 7: Suchen Sie nach IronPDF im NuGet-Paketmanager-UI

Suche nach IronPDF in der NuGet-Paketmanager-Benutzeroberfläche

Extrahieren Sie alle Texte, die Tabellendaten aus dem PDF enthalten

Um Tabellendaten zu extrahieren, laden wir zuerst das PDF (entweder das, das wir gerade erstellt haben, oder ein vorhandenes PDF) und verwenden die ExtractAllText-Methode. Diese Methode ruft alle Textinhalte von den PDF-Seiten ab.

// Load the PDF (if you just created it, it's already loaded in pdfDocument)
// If loading an existing PDF:
// PdfDocument pdfDocument = PdfDocument.FromFile("table_example.pdf"); 
// Or use the one created above:
string allText = pdfDocument.ExtractAllText();

// Load the PDF (if you just created it, it's already loaded in pdfDocument)
// If loading an existing PDF:
// PdfDocument pdfDocument = PdfDocument.FromFile("table_example.pdf"); 
// Or use the one created above:
string allText = pdfDocument.ExtractAllText();

' Load the PDF (if you just created it, it's already loaded in pdfDocument)
' If loading an existing PDF:
' PdfDocument pdfDocument = PdfDocument.FromFile("table_example.pdf"); 
' Or use the one created above:
Dim allText As String = pdfDocument.ExtractAllText()

$vbLabelText $csharpLabel

Die Variable allText enthält jetzt den gesamten Textinhalt des PDFs. Sie können es anzeigen, um die Rohdatenextraktion zu sehen:

Console.WriteLine("\n--- Raw Extracted Text ---");
Console.WriteLine(allText);

Console.WriteLine("\n--- Raw Extracted Text ---");
Console.WriteLine(allText);

Imports Microsoft.VisualBasic

Console.WriteLine(vbLf & "--- Raw Extracted Text ---")
Console.WriteLine(allText)

$vbLabelText $csharpLabel

Wie man eine PDF-Tabelle in C# liest, Abbildung 8: Die PDF-Datei zur Textextraktion

Die PDF-Datei zum Extrahieren von Text

Analysieren extrahierter Texte zur Rekonstruktion von Tabellendaten in C#

Mit dem extrahierten Rohtext besteht die nächste Herausforderung darin, diesen String zu parsen, um die tabellarischen Daten zu identifizieren und zu strukturieren. Dieser Schritt ist stark abhängig von der Konsistenz und dem Format der Tabellen in Ihren PDFs.

Allgemeine Parsing-Strategien:

Zeilenbegrenzungszeichen identifizieren: Zeilenumbrüche (\n oder \r\n) sind gängige Zeilentrenner.
Erkennen von Spaltentrennzeichen: Zellen innerhalb einer Zeile können durch mehrere Leerzeichen, Tabs oder spezifische bekannte Zeichen (wie ' ' oder ';'). Manchmal, wenn Spalten visuell ausgerichtet sind, aber klare Textbegrenzer fehlen, könnte man die Struktur anhand konsistenter Abstands-Muster ableiten, obwohl dies komplexer ist.
Nicht-tabellarische Inhalte filtern: Die ExtractAllText-Methode erfasst den gesamten Text. Sie benötigen Logik, um den Text zu isolieren, der tatsächlich Ihre Tabelle bildet, möglicherweise indem Sie nach Schlüsselwörtern in Überschriften suchen oder Einleitungs- bzw. Schlussabschnitte überspringen.
Die C#-Methode String.Split ist ein grundlegendes Werkzeug dafür. Hier ist ein Beispiel, das versucht, nur die Tabellenzeilen aus unserem Beispiel zu extrahieren und dabei Zeilen mit Punkten herauszufiltern (eine einfache Heuristik für dieses spezifische Beispiel):

Console.WriteLine("\n--- Parsed Table Data (Simple Heuristic) ---");
string[] textLines = allText.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in textLines)
{
    // Simple filter: skip lines with a period, assuming they are not table data in this example
    // and skip lines that are too short or headers if identifiable
    if (line.Contains(".") 
 line.Contains("A Simple table example") 
 line.Length < 5) 
    {
        continue;
    }
    else
    {
        // Further split line into cells based on expected delimiters (e.g., multiple spaces)
        // This part requires careful adaptation to your PDF's table structure
        // Example: string[] cells = line.Split(new[] { "  ", "\t" }, StringSplitOptions.None);
        Console.WriteLine(line); // For now, just print the filtered line
    }
}

Console.WriteLine("\n--- Parsed Table Data (Simple Heuristic) ---");
string[] textLines = allText.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in textLines)
{
    // Simple filter: skip lines with a period, assuming they are not table data in this example
    // and skip lines that are too short or headers if identifiable
    if (line.Contains(".") 
 line.Contains("A Simple table example") 
 line.Length < 5) 
    {
        continue;
    }
    else
    {
        // Further split line into cells based on expected delimiters (e.g., multiple spaces)
        // This part requires careful adaptation to your PDF's table structure
        // Example: string[] cells = line.Split(new[] { "  ", "\t" }, StringSplitOptions.None);
        Console.WriteLine(line); // For now, just print the filtered line
    }
}

Imports Microsoft.VisualBasic

Console.WriteLine(vbLf & "--- Parsed Table Data (Simple Heuristic) ---")
Dim textLines() As String = allText.Split( { ControlChars.Cr, ControlChars.Lf }, StringSplitOptions.RemoveEmptyEntries)
For Each line As String In textLines
	' Simple filter: skip lines with a period, assuming they are not table data in this example
	' and skip lines that are too short or headers if identifiable
	If line.Contains(".") line.Contains("A Simple table example") line.Length < 5 Then
		Continue For
	Else
		' Further split line into cells based on expected delimiters (e.g., multiple spaces)
		' This part requires careful adaptation to your PDF's table structure
		' Example: string[] cells = line.Split(new[] { "  ", "\t" }, StringSplitOptions.None);
		Console.WriteLine(line) ' For now, just print the filtered line
	End If
Next line

$vbLabelText $csharpLabel

Dieser Code teilt den Text in Zeilen auf. Die if-Bedingung ist ein sehr grundlegender Filter für den nicht-tabellarischen Text dieses spezifischen Beispiels. In realen Szenarien benötigen Sie robustere Logik, um Tabellenzeilen und -zellen genau zu identifizieren und zu analysieren.

Ausgabe des einfach gefilterten Textes:

Wie man eine PDF-Tabelle in C# liest, Abbildung 9: Die Konsole zeigt extrahierte Texte an

Die Konsole zeigt extrahierte Texte an

Wichtige Überlegungen zur Text-Parsing-Methode:

Am besten geeignet für: Textbasierte PDFs mit einfachen, konsistenten Tabellenstrukturen und klaren textuellen Trennzeichen.
Einschränkungen: Diese Methode kann Probleme haben mit:
- Tabellen mit zusammengeführten Zellen oder komplexen verschachtelten Strukturen.
- Tabellen, bei denen Spalten durch visuelle Abstände statt durch Texttrennzeichen definiert werden.
- Als Bilder eingebettete Tabellen (erfordern OCR).
- Variationen bei der PDF-Erstellung führen zu inkonsistenter Reihenfolge der Textextraktion.
Sie können die gefilterten Zeilen (die idealerweise Tabellenzeilen darstellen) in eine CSV-Datei speichern:

using (StreamWriter file = new StreamWriter("parsed_table_data.csv", false))
{
    file.WriteLine("Company,Contact,Country"); // Write CSV Header
    foreach (string line in textLines)
    {
        if (line.Contains(".") 
 line.Contains("A Simple table example") 
 line.Length < 5)
        {
            continue;
        }
        else
        {
            // For a real CSV, you'd split 'line' into cells and join with commas
            // E.g., string[] cells = line.Split(new[] {"  "}, StringSplitOptions.RemoveEmptyEntries);
            // string csvLine = string.Join(",", cells);
            // file.WriteLine(csvLine);
            file.WriteLine(line.Replace("  ", ",").Trim()); // Basic replacement for this example
        }
    }
}
Console.WriteLine("\nFiltered table data saved to parsed_table_data.csv");

using (StreamWriter file = new StreamWriter("parsed_table_data.csv", false))
{
    file.WriteLine("Company,Contact,Country"); // Write CSV Header
    foreach (string line in textLines)
    {
        if (line.Contains(".") 
 line.Contains("A Simple table example") 
 line.Length < 5)
        {
            continue;
        }
        else
        {
            // For a real CSV, you'd split 'line' into cells and join with commas
            // E.g., string[] cells = line.Split(new[] {"  "}, StringSplitOptions.RemoveEmptyEntries);
            // string csvLine = string.Join(",", cells);
            // file.WriteLine(csvLine);
            file.WriteLine(line.Replace("  ", ",").Trim()); // Basic replacement for this example
        }
    }
}
Console.WriteLine("\nFiltered table data saved to parsed_table_data.csv");

Imports Microsoft.VisualBasic

Using file As New StreamWriter("parsed_table_data.csv", False)
	file.WriteLine("Company,Contact,Country") ' Write CSV Header
	For Each line As String In textLines
		If line.Contains(".") line.Contains("A Simple table example") line.Length < 5 Then
			Continue For
		Else
			' For a real CSV, you'd split 'line' into cells and join with commas
			' E.g., string[] cells = line.Split(new[] {"  "}, StringSplitOptions.RemoveEmptyEntries);
			' string csvLine = string.Join(",", cells);
			' file.WriteLine(csvLine);
			file.WriteLine(line.Replace("  ", ",").Trim()) ' Basic replacement for this example
		End If
	Next line
End Using
Console.WriteLine(vbLf & "Filtered table data saved to parsed_table_data.csv")

$vbLabelText $csharpLabel

Strategien für die komplexere PDF-Tabellenextraktion in C#

Das Extrahieren von Daten aus komplexen oder bildbasierten PDF-Tabellen erfordert oft fortgeschrittenere Techniken als einfaches Textparsing. IronPDF bietet Funktionen, die unterstützen können:

Verwendung der Fähigkeiten von IronOCR für gescannte Tabellen: Wenn Tabellen in Bildern enthalten sind (z. B. gescannte PDFs), wird ExtractAllText() diese alleine nicht erfassen. IronOCRs Texterkennungs-Funktionalität kann diese Bilder zunächst in Text umwandeln.

// Conceptual OCR usage (refer to IronOCR's documentation for detailed implementation)
// Install Package IronOcr
using IronOcr;
using (var ocrInput = new OcrInput("scanned_pdf_with_table.pdf"))
{
     ocrInput.TargetDPI = 300; // Good DPI for OCR accuracy
     var ocrResult = new IronOcr().Read(ocrInput);
     string ocrExtractedText = ocrResult.Text;
     // Now, apply parsing logic to 'ocrExtractedText'
     Console.WriteLine("\n--- OCR Extracted Text for Table Parsing ---");
     Console.WriteLine(ocrExtractedText);
}

// Conceptual OCR usage (refer to IronOCR's documentation for detailed implementation)
// Install Package IronOcr
using IronOcr;
using (var ocrInput = new OcrInput("scanned_pdf_with_table.pdf"))
{
     ocrInput.TargetDPI = 300; // Good DPI for OCR accuracy
     var ocrResult = new IronOcr().Read(ocrInput);
     string ocrExtractedText = ocrResult.Text;
     // Now, apply parsing logic to 'ocrExtractedText'
     Console.WriteLine("\n--- OCR Extracted Text for Table Parsing ---");
     Console.WriteLine(ocrExtractedText);
}

' Conceptual OCR usage (refer to IronOCR's documentation for detailed implementation)
' Install Package IronOcr
Imports Microsoft.VisualBasic
Imports IronOcr
Using ocrInput As New OcrInput("scanned_pdf_with_table.pdf")
	 ocrInput.TargetDPI = 300 ' Good DPI for OCR accuracy
	 Dim ocrResult = (New IronOcr()).Read(ocrInput)
	 Dim ocrExtractedText As String = ocrResult.Text
	 ' Now, apply parsing logic to 'ocrExtractedText'
	 Console.WriteLine(vbLf & "--- OCR Extracted Text for Table Parsing ---")
	 Console.WriteLine(ocrExtractedText)
End Using

$vbLabelText $csharpLabel

Für detaillierte Anleitungen besuchen Sie die IronOCR-Dokumentation (https://ironsoftware.com/csharp/ocr/). Nach der OCR würden Sie den resultierenden Textstring analysieren.

Koordinatenbasierte Textextraktion (Fortgeschritten): Während ExtractAllText() von IronPDF den Textstrom liefert, könnten in einigen Szenarien die x,y-Koordinaten jedes Textausschnitts von Vorteil sein. Falls IronPDF APIs anbietet, um Text mit Informationen zu seinem Begrenzungsrahmen zu erhalten (prüfen Sie die aktuelle Dokumentation), könnte dies eine ausgefeiltere räumliche Analyse ermöglichen, um Tabellen basierend auf der visuellen Ausrichtung zu rekonstruieren.
Konvertierung von PDF in ein anderes Format: IronPDF kann PDFs in strukturierte Formate wie HTML konvertieren. Oft ist das Parsen einer HTML-Tabelle einfacher als das Parsen von rohem PDF-Text.

PdfDocument pdfToConvert = PdfDocument.FromFile("your_document.pdf");
string htmlOutput = pdfToConvert.ToHtmlString();
// Then use an HTML parsing library (e.g., HtmlAgilityPack) to extract tables from htmlOutput.

PdfDocument pdfToConvert = PdfDocument.FromFile("your_document.pdf");
string htmlOutput = pdfToConvert.ToHtmlString();
// Then use an HTML parsing library (e.g., HtmlAgilityPack) to extract tables from htmlOutput.

Dim pdfToConvert As PdfDocument = PdfDocument.FromFile("your_document.pdf")
Dim htmlOutput As String = pdfToConvert.ToHtmlString()
' Then use an HTML parsing library (e.g., HtmlAgilityPack) to extract tables from htmlOutput.

$vbLabelText $csharpLabel

Mustererkennung und reguläre Ausdrücke: Bei Tabellen mit sehr vorhersehbaren Mustern, jedoch inkonsistenten Trennzeichen, können komplexe reguläre Ausdrücke, die auf den extrahierten Text angewendet werden, manchmal Tabellendaten isolieren.
Die Wahl der richtigen Strategie hängt von der Komplexität und Konsistenz Ihrer Quell-PDFs ab. Für viele gängige Geschäftsdokumente mit textbasierten Tabellen kann IronPDF's ExtractAllText in Verbindung mit intelligenter C#-Parsing-Logik sehr effektiv sein. Für bildbasierte Tabellen sind seine OCR-Fähigkeiten unerlässlich.

Zusammenfassung

Dieser Artikel demonstrierte, wie man Tabellendaten aus einem PDF-Dokument in C# mit IronPDF extrahiert, wobei der Schwerpunkt hauptsächlich auf der Nutzung der ExtractAllText()-Methode und der anschließenden String-Analyse lag. Wir haben festgestellt, dass dieser Ansatz zwar für textbasierte Tabellen leistungsstark ist, aber komplexere Szenarien wie tabellenbasierte Bilder mit den OCR-Funktionen von IronPDF oder durch vorherige Umwandlung von PDFs in andere Formate bearbeitet werden können.

IronPDF bietet ein vielseitiges Toolkit für .NET-Entwickler und vereinfacht viele PDF-bezogene Aufgaben, von der Erstellung und Bearbeitung bis hin zur umfassenden Datenauswertung. Es bietet Methoden wie DOCX zu PDF.

IronPDF ist kostenlos für die Entwicklung und bietet eine kostenlose Testlizenz zum Testen seiner vollständigen kommerziellen Funktionen an. Für den Produktionseinsatz stehen verschiedene Lizenzierungsoptionen zur Verfügung.

Für weitere Details und fortgeschrittene Anwendungsfälle erkunden Sie die offizielle IronPDF-Dokumentation und Beispiele (https://ironpdf.com/)

Chipego Kalinda

Jetzt mit dem Ingenieurteam chatten

Software-Ingenieur

Chipego hat eine natürliche Fähigkeit zum Zuhören, die ihm hilft, Kundenprobleme zu verstehen und intelligente Lösungen anzubieten. Er trat dem Iron Software-Team 2023 bei, nachdem er einen Bachelor of Science in Informationstechnologie erworben hatte. IronPDF und IronOCR sind die beiden Produkte, auf die sich Chipego konzentriert hat, aber sein Wissen über alle Produkte wächst täglich, da er neue Wege findet, Kunden zu unterstützen. Er genießt die Zusammenarbeit bei Iron Software, da Teammitglieder aus dem gesamten Unternehmen ihre unterschiedlichen Erfahrungen einbringen und so zu effektiven, innovativen Lösungen beitragen. Wenn Chipego nicht an seinem Schreibtisch sitzt, kann man ihn oft bei einem guten Buch oder beim Fußballspielen antreffen.

< PREVIOUS
QR-Code in PDF umwandeln

NÄCHSTES >
C#-Tutorial: Erstellen eines PDF-Textanzeigers mit IronPDF (Windows Forms)