Wie extrahiere ich Tabellendaten aus einer PDF-Datei in C#?

In vielen Branchen sind PDF-Dateien das gängige Format für den Austausch strukturierter Dokumente wie Berichte, Rechnungen und Datentabellen. Das Extrahieren von Daten aus PDF-Dateien, vor allem wenn es sich um Tabellen handelt, kann jedoch aufgrund der Beschaffenheit des PDF-Formats eine Herausforderung darstellen. Im Gegensatz zu strukturierten Datenformaten sind PDFs in erster Linie für die Präsentation und nicht für die Datenextraktion gedacht.

Mit IronPDF, einer leistungsstarken C# PDF .NET-Bibliothek, können Sie problemlos strukturierte Daten wie Tabellen direkt aus PDFs extrahieren und diese in Ihren .NET-Anwendungen verarbeiten. Dieser Artikel zeigt Ihnen Schritt für Schritt, wie Sie mit IronPDF Tabellendaten aus PDF-Dateien extrahieren können.

Wann würden Sie Tabellen aus PDF-Dokumenten extrahieren wollen?

Tabellen sind eine praktische Möglichkeit, Daten zu strukturieren und darzustellen, sei es bei der Bestandsverwaltung, der Dateneingabe, der Aufzeichnung von Daten wie z. B. Regenfällen usw. Es kann also viele Gründe geben, warum Tabellen und Tabellendaten aus PDF-Dokumenten extrahiert werden müssen. Einige der häufigsten Anwendungsfälle sind:

• Automatisierung der Dateneingabe: Das Extrahieren von Daten aus Tabellen in PDF-Berichten oder Rechnungen kann Prozesse wie das Befüllen von Datenbanken oder Tabellenkalkulationen automatisieren.
• Datenanalyse: Unternehmen erhalten häufig strukturierte Berichte im PDF-Format. Das Extrahieren von Tabellen ermöglicht es Ihnen, diese Daten programmatisch zu analysieren.
• Dokumentenkonvertierung: Das Extrahieren tabellarischer Daten in zugänglichere Formate wie Excel oder CSV ermöglicht eine einfachere Manipulation, Speicherung und Weitergabe.
• Prüfung und Compliance: Für rechtliche oder finanzielle Unterlagen kann das programmatische Extrahieren von tabellarischen Daten aus PDF-Dokumenten helfen, Prüfungen zu automatisieren und die Compliance sicherzustellen.

Wie funktionieren PDF-Tabellen?

Das PDF-Dateiformat bietet keine native Möglichkeit, Daten in strukturierten Formaten wie Tabellen zu speichern. Die Tabelle, die wir im heutigen Beispiel verwenden, wurde in HTML erstellt, bevor sie in das PDF-Format konvertiert wurde. Tabellen werden als Text und Linien gerendert, daher erfordert das Extrahieren von Tabellendaten oft ein gewisses Parsen und Interpretieren des Inhalts, es sei denn, Sie verwenden eine OCR-Software wie IronOCR.

Wie extrahiere ich Tabellendaten aus einer PDF-Datei in C#

Bevor wir untersuchen, wie IronPDF diese Aufgabe bewältigen kann, wollen wir uns zunächst ein Online-Tool ansehen, das die PDF-Extraktion beherrscht. Um eine Tabelle aus einem PDF-Dokument mit einem Online-PDF-Tool zu extrahieren, gehen Sie wie folgt vor:

1. Navigieren Sie zum kostenlosen Online-Tool zur PDF-Extraktion

2. Laden Sie die PDF-Datei mit der Tabelle hoch

3. Anzeigen und Herunterladen der Ergebnisse

Schritt eins: Navigieren Sie zum kostenlosen Online-PDF-Extraktionstool

Heute werden wir Docsumo als unser Online-PDF-Tool-Beispiel verwenden. Docsumo ist eine Online-KI für PDF-Dokumente, die ein kostenloses Tool zur Extraktion von PDF-Tabellen anbietet.

Schritt zwei: Hochladen der PDF-Datei, die die Tabelle enthält

Klicken Sie nun auf die Schaltfläche "Datei hochladen", um Ihre PDF-Datei zur Extraktion hochzuladen. Das Tool beginnt sofort mit der Verarbeitung Ihrer PDF-Datei.

Dritter Schritt: Anzeigen und Herunterladen der Ergebnisse

Sobald Docsumo die Verarbeitung der PDF-Datei abgeschlossen hat, wird die extrahierte Tabelle angezeigt. Sie können dann Anpassungen an der Tabellenstruktur vornehmen, z. B. Zeilen hinzufügen oder entfernen. Hier können Sie die Tabelle entweder als weitere PDF-, XLS-, JSON- oder Text-Datei herunterladen.

Extrahieren von Tabellendaten mit IronPDF

IronPDF ermöglicht die Extraktion von Daten, Text und Grafiken aus PDF-Dateien, die dann zur programmgesteuerten Rekonstruktion von Tabellen verwendet werden können. Zu diesem Zweck müssen Sie zunächst den Textinhalt aus der Tabelle in der PDF-Datei extrahieren und dann diesen Text verwenden, um die Tabelle in Zeilen und Spalten zu zerlegen. Bevor wir mit der Extraktion von Tabellen beginnen, werfen wir einen Blick darauf, wie die ExtractAllText()-Methode von IronPDF funktioniert, indem sie die Daten innerhalb einer Tabelle extrahiert:

using IronPDF;
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
string text = pdf.ExtractAllText();
Console.WriteLine(text);

using IronPDF;
PdfDocument pdf = PdfDocument.FromFile("example.pdf");
string text = pdf.ExtractAllText();
Console.WriteLine(text);

Imports IronPDF
Private pdf As PdfDocument = PdfDocument.FromFile("example.pdf")
Private text As String = pdf.ExtractAllText()
Console.WriteLine(text)

In diesem Beispiel haben wir das PDF-Dokument mit der PdfDocument-Klasse geladen und dann die ExtractAllText()-Methode verwendet, um den gesamten Text im Dokument zu extrahieren, bevor der Text schließlich auf der Konsole angezeigt wird.

Extrahieren von Tabellendaten aus Text mit IronPDF

Nach dem Extrahieren des Textes aus der PDF-Datei wird die Tabelle als eine Reihe von Zeilen und Spalten im Klartext angezeigt. Sie können diesen Text basierend auf Zeilenumbrüchen (\n) aufteilen und die Zeilen dann weiter in Spalten basierend auf konsistenten Abständen oder Trennzeichen wie Kommas oder Tabs unterteilen. Hier ist ein einfaches Beispiel dafür, wie die Tabelle aus dem Text analysiert werden kann:

using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("table.pdf");
string text = pdf.ExtractAllText();
string[] lines = text.Split('\n');
foreach (string line in lines)
{
    string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
    Console.WriteLine("Row: ");
    foreach (string column in columns)
    {
        Console.WriteLine("  " + column);
    }
}

using IronPdf;
PdfDocument pdf = PdfDocument.FromFile("table.pdf");
string text = pdf.ExtractAllText();
string[] lines = text.Split('\n');
foreach (string line in lines)
{
    string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
    Console.WriteLine("Row: ");
    foreach (string column in columns)
    {
        Console.WriteLine("  " + column);
    }
}

Imports Microsoft.VisualBasic
Imports IronPdf
Private pdf As PdfDocument = PdfDocument.FromFile("table.pdf")
Private text As String = pdf.ExtractAllText()
Private lines() As String = text.Split(ControlChars.Lf)
For Each line As String In lines
	Dim columns() As String = line.Split(ControlChars.Tab).Where(Function(col) Not String.IsNullOrWhiteSpace(col)).ToArray()
	Console.WriteLine("Row: ")
	For Each column As String In columns
		Console.WriteLine("  " & column)
	Next column
Next line

In diesem Beispiel folgen wir denselben Schritten wie zuvor, um unser PDF-Dokument zu laden und den Text zu extrahieren. Dann verwenden wir text.Split('\n'), um den extrahierten Text anhand von Zeilenumbrüchen in Zeilen aufzuteilen und die Ergebnisse im lines-Array zu speichern. Eine foreach-Schleife wird dann verwendet, um durch die Zeilen im Array zu iterieren, wobei line.Split('\t') verwendet wird, um die Zeilen weiter in Spalten zu teilen, indem das Tabulatorzeichen '\t' als Trennzeichen verwendet wird. Der nächste Abschnitt des Spalten-Arrays, Where(col => !string.IsNullOrWhiteSpace(col)).ToArray(), filtert leere Spalten heraus, die durch zusätzliche Leerzeichen entstehen können, und fügt dann die Spalten dem Spalten-Array hinzu.

Schließlich schreiben wir Text in das Konsolenausgabefenster mit einfacher Zeilen- und Spaltenstrukturierung.

Exportieren von extrahierten Tabellendaten nach CSV

Nachdem wir uns nun damit beschäftigt haben, wie man Tabellen aus PDF-Dateien extrahiert, wollen wir uns nun ansehen, was man mit den extrahierten Daten machen kann. Das Exportieren der exportierten Tabelle als CSV-Datei ist eine nützliche Methode, um Tabellendaten zu verarbeiten und Aufgaben wie die Dateneingabe zu automatisieren. Für dieses Beispiel haben wir eine Tabelle mit simulierten Daten gefüllt, in diesem Fall die tägliche Niederschlagsmenge in einer Woche, die Tabelle aus der PDF-Datei extrahiert und sie dann in eine CSV-Datei exportiert.

class Program
{
    static void Main(string[] args)
    {
        string pdfPath = "table.pdf";
        string csvPath = "output.csv";
        // Extract and parse table data
        var tableData = ExtractTableDataFromPdf(pdfPath);
        // Write the extracted data to a CSV file
        WriteDataToCsv(tableData, csvPath);
        Console.WriteLine($"Data extracted and saved to {csvPath}");
    }
    static List<string[]> ExtractTableDataFromPdf(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        var text = pdf.ExtractTextFromPage(0); // Extract text from the first page
        var rows = new List<string[]>();
        // Split text into lines (rows)
        var lines = text.Split('\n');
        // Variable to hold column values temporarily
        var tempColumns = new List<string>();
        foreach (var line in lines)
        {
            var trimmedLine = line.Trim();
            // Check for empty lines or lines that don't contain table data
            if (string.IsNullOrEmpty(trimmedLine) 
 trimmedLine.Contains("Header"))
            {
                continue;
            }
            // Split line into columns. Adjust this based on how columns are separated.
            var columns = trimmedLine.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
            if (columns.Length > 0)
            {
                // Add columns to temporary list
                tempColumns.AddRange(columns);
                rows.Add(tempColumns.ToArray());
                tempColumns.Clear(); // Clear temporary list after adding to rows
            }
        }
        return rows;
    }
    static void WriteDataToCsv(List<string[]> data, string csvPath)
    {
        using (var writer = new StreamWriter(csvPath))
        {
            foreach (var row in data)
            {
                // Join columns with commas and quote each field to handle commas within data
                var csvRow = string.Join(",", row.Select(field => $"\"{field.Replace("\"", "\"\"")}\""));
                writer.WriteLine(csvRow);
            }
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        string pdfPath = "table.pdf";
        string csvPath = "output.csv";
        // Extract and parse table data
        var tableData = ExtractTableDataFromPdf(pdfPath);
        // Write the extracted data to a CSV file
        WriteDataToCsv(tableData, csvPath);
        Console.WriteLine($"Data extracted and saved to {csvPath}");
    }
    static List<string[]> ExtractTableDataFromPdf(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        var text = pdf.ExtractTextFromPage(0); // Extract text from the first page
        var rows = new List<string[]>();
        // Split text into lines (rows)
        var lines = text.Split('\n');
        // Variable to hold column values temporarily
        var tempColumns = new List<string>();
        foreach (var line in lines)
        {
            var trimmedLine = line.Trim();
            // Check for empty lines or lines that don't contain table data
            if (string.IsNullOrEmpty(trimmedLine) 
 trimmedLine.Contains("Header"))
            {
                continue;
            }
            // Split line into columns. Adjust this based on how columns are separated.
            var columns = trimmedLine.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
            if (columns.Length > 0)
            {
                // Add columns to temporary list
                tempColumns.AddRange(columns);
                rows.Add(tempColumns.ToArray());
                tempColumns.Clear(); // Clear temporary list after adding to rows
            }
        }
        return rows;
    }
    static void WriteDataToCsv(List<string[]> data, string csvPath)
    {
        using (var writer = new StreamWriter(csvPath))
        {
            foreach (var row in data)
            {
                // Join columns with commas and quote each field to handle commas within data
                var csvRow = string.Join(",", row.Select(field => $"\"{field.Replace("\"", "\"\"")}\""));
                writer.WriteLine(csvRow);
            }
        }
    }
}

Imports Microsoft.VisualBasic

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfPath As String = "table.pdf"
		Dim csvPath As String = "output.csv"
		' Extract and parse table data
		Dim tableData = ExtractTableDataFromPdf(pdfPath)
		' Write the extracted data to a CSV file
		WriteDataToCsv(tableData, csvPath)
		Console.WriteLine($"Data extracted and saved to {csvPath}")
	End Sub
	Private Shared Function ExtractTableDataFromPdf(ByVal pdfPath As String) As List(Of String())
		Dim pdf = PdfDocument.FromFile(pdfPath)
		Dim text = pdf.ExtractTextFromPage(0) ' Extract text from the first page
		Dim rows = New List(Of String())()
		' Split text into lines (rows)
		Dim lines = text.Split(ControlChars.Lf)
		' Variable to hold column values temporarily
		Dim tempColumns = New List(Of String)()
		For Each line In lines
			Dim trimmedLine = line.Trim()
			' Check for empty lines or lines that don't contain table data
			If String.IsNullOrEmpty(trimmedLine) trimmedLine.Contains("Header") Then
				Continue For
			End If
			' Split line into columns. Adjust this based on how columns are separated.
			Dim columns = trimmedLine.Split( { " "c, ControlChars.Tab }, StringSplitOptions.RemoveEmptyEntries)
			If columns.Length > 0 Then
				' Add columns to temporary list
				tempColumns.AddRange(columns)
				rows.Add(tempColumns.ToArray())
				tempColumns.Clear() ' Clear temporary list after adding to rows
			End If
		Next line
		Return rows
	End Function
	Private Shared Sub WriteDataToCsv(ByVal data As List(Of String()), ByVal csvPath As String)
		Using writer = New StreamWriter(csvPath)
			For Each row In data
				' Join columns with commas and quote each field to handle commas within data
				Dim csvRow = String.Join(",", row.Select(Function(field) $"""{field.Replace("""", """""")}"""))
				writer.WriteLine(csvRow)
			Next row
		End Using
	End Sub
End Class

Beispiel-PDF-Datei

Ausgabe CSV-Datei

Wie Sie sehen können, haben wir die PDF-Tabelle erfolgreich in CSV exportiert. Zunächst haben wir die PDF-Datei mit der Tabelle geladen und einen neuen CSV-Dateipfad erstellt. Danach haben wir die Tabelle mit der Zeile var tableData = ExtractTableDataFromPdf(pdfPath) extrahiert, die die ExtractTableDataFromPdf()-Methode aufruft. Diese Methode extrahiert den gesamten Text auf der PDF-Seite, auf der sich die Tabelle befindet, und speichert ihn in der text-Variable.

Anschließend teilen wir den Text in Zeilen und Spalten auf. Schließlich, nachdem wir das Ergebnis dieses Aufteilungsprozesses zurückgegeben haben, rufen wir die Methode static void WriteDataToCsv() auf, die den extrahierten, aufgeteilten Text entgegennimmt und ihn mit StreamWriter in unsere CSV-Datei schreibt.

Tipps und bewährte Praktiken

Bei der Arbeit mit PDF-Tabellen kann die Einhaltung einiger grundlegender Best Practices dazu beitragen, die Wahrscheinlichkeit von Fehlern oder Problemen zu minimieren.

• PDFs vorverarbeiten: Verarbeiten Sie Ihre PDFs nach Möglichkeit vor, um eine einheitliche Formatierung sicherzustellen, was den Extraktionsprozess vereinfacht.
• Daten validieren: Validieren Sie immer die extrahierten Daten, um Genauigkeit und Vollständigkeit sicherzustellen.
• Fehler behandeln: Implementieren Sie eine Fehlerbehandlung, um Fälle zu verwalten, in denen die Textextraktion oder das Parsen fehlschlägt, indem Sie Ihren Code beispielsweise in einen Try-Catch-Block einbetten.
• Optimieren Sie die Leistung: Bei großen PDFs sollten Sie die Textextraktion und das Parsing optimieren, um Leistungsprobleme zu bewältigen.

IronPDF-Lizenzierung

IronPDF bietet verschiedene Lizenzen an, die es Ihnen ermöglichen, alle leistungsstarken Funktionen von IronPDF selbst auszuprobieren, bevor Sie sich für eine Lizenz entscheiden.

Schlussfolgerung

Das Extrahieren von Tabellen aus PDFs mit IronPDF ist eine leistungsstarke Methode, um die Datenextraktion zu automatisieren, die Analyse zu erleichtern und Dokumente in zugänglichere Formate umzuwandeln. Egal, ob es sich um einfache Tabellen oder komplexe, unregelmäßige Formate handelt, IronPDF bietet die Werkzeuge, die für eine effiziente Extraktion und Verarbeitung von Tabellendaten erforderlich sind.

Mit IronPDF können Sie Arbeitsabläufe wie die automatische Dateneingabe, Dokumentenkonvertierung und Datenanalyse optimieren. Die Flexibilität und die fortschrittlichen Funktionen, die IronPDF bietet, machen es zu einem wertvollen Werkzeug für die Bearbeitung verschiedener PDF-basierter Aufgaben.