IRONPDF VERWENDEN

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

Veröffentlicht 23. Oktober 2024

Teilen Sie:

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.

Jedoch mitIronPDFmit der leistungsstarken C# PDF .NET-Bibliothek können Sie strukturierte Daten wie Tabellen direkt aus PDFs extrahieren und 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 Auffü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 von Tabellendaten in leichter zugängliche Formate wie Excel oder CSV ermöglicht eine einfachere Bearbeitung, Speicherung und gemeinsame Nutzung.
Prüfung und Einhaltung von Vorschriften: Bei rechtlichen oder finanziellen Unterlagen kann die programmgesteuerte Extraktion von Tabellendaten aus PDF-Dokumenten dazu beitragen, Prüfungen zu automatisieren und die Einhaltung von Vorschriften 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 in unserem heutigen Beispiel verwenden, wurde in HTML erstellt, bevor sieins PDF-Format konvertiert. Tabellen werden als Text und Zeilen gerendert, so dass das Extrahieren von Tabellendaten oft ein gewisses Parsing und Interpretieren des Inhalts erfordert, es sei denn, Sie verwenden OCR-Software, wie z. BIronOCR.

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:

Navigieren Sie zum kostenlosen Online-Tool zur PDF-Extraktion
Laden Sie die PDF-Datei mit der Tabelle hoch
Anzeigen und Herunterladen der Ergebnisse

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

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

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

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.

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

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.

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

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 dem Extrahieren von Tabellen beginnen, werfen wir einen Blick darauf, wie IronPDFsExtractAllText() methode funktioniert durch Extraktion der Daten in einer Tabelle:

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)

VB C#

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

In diesem Beispiel haben wir das PDF-Dokument mit demPdfDocument klasse und verwendete dann die Funktion ExtractAllText() Methode zum Extrahieren des gesamten Textes innerhalb des Dokuments, 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 anhand von Zeilenumbrüchen aufteilen(\n) und dann Zeilen in Spalten auf der Grundlage einheitlicher Abstände oder Begrenzungszeichen wie Kommas oder Tabulatoren aufteilen. 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

VB C#

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

In diesem Beispiel folgen wir denselben Schritten wie zuvor, um unser PDF-Dokument zu laden und den Text zu extrahieren. Dann, mit text.Split('\n') Wir teilen den extrahierten Text anhand von Zeilenumbrüchen in Zeilen auf und speichern die Ergebnisse in dem Array lines. Dann wird eine foreach-Schleife verwendet, um die Zeilen im Array zu durchlaufen, wobei line.Split('\t') wird verwendet, um die Zeilen weiter in Spalten aufzuteilen, wobei das Tabulatorzeichen '\t' als Begrenzungszeichen verwendet wird. Der nächste Teil der Spaltenreihe, Wo(col =>!string.IsNullOrWhiteSpace(col)).ToArray() filtert leere Spalten heraus, die durch zusätzliche Leerzeichen entstehen können, und fügt die Spalten dann dem Spaltenarray 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

VB C#

Beispiel-PDF-Datei

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

Ausgabe CSV-Datei

Wie man Tabellendaten aus einer PDF-Datei in C# extrahiert: Abbildung 7

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 extrahierten wir die Tabelle mit var tableData = ExtractTableDataFromPdf(pdfPath) Zeile, die als ExtractTableDataFromPdf() Methode. Diese Methode extrahiert den gesamten Text auf der PDF-Seite, auf der sich die Tabelle befindet, und speichert ihn in der Variablen text.

Anschließend teilen wir den Text in Zeilen und Spalten auf. Nach der Rückgabe des Ergebnisses dieses Aufteilungsprozesses rufen wir schließlich die Methode static void WriteDataToCsv() Der extrahierte, aufgeteilte Text wird mit StreamWriter in unsere CSV-Datei geschrieben.

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: Wenn möglich, sollten Sie Ihre PDFs vorverarbeiten, um eine einheitliche Formatierung zu gewährleisten, was den Extraktionsprozess vereinfacht.
Validierung der Daten: Die extrahierten Daten müssen immer validiert werden, um ihre Richtigkeit und Vollständigkeit zu gewährleisten.
Fehlerbehandlung: Implementieren Sie eine Fehlerbehandlung für den Fall, dass die Textextraktion oder das Parsing fehlschlägt, z. B. indem Sie Ihren Code in einen try-catch-Block einschließen.
Optimieren Sie die Leistung: Bei großen PDF-Dateien sollten Sie die Textextraktion und das Parsing optimieren, um Leistungsprobleme zu vermeiden.

IronPDF-Lizenzierung

IronPDF bietet verschiedenelizenzierung können Sie alle leistungsstarken Funktionen von IronPDF selbst ausprobieren, bevor Sie sich für eine Lizenz entscheiden.

Schlussfolgerung

Extrahieren von Tabellen aus PDFs mitIronPDF ist eine leistungsstarke Methode zur Automatisierung der Datenextraktion, zur Erleichterung der Analyse und zur Konvertierung von Dokumenten in leichter zugängliche Formate. 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.

< PREVIOUS
Wie man einen C# PDF-Konverter erstellt

NÄCHSTES >
Konvertierung von HTML in PDF in ASP.NET mit C#