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

Wann müssen Sie Tabellen aus PDF-Dokumenten extrahieren?

Tabellen sind eine praktische Möglichkeit, Ihre Daten zu strukturieren und darzustellen, sei es bei der Lagerverwaltung, Datenerfassung, Aufzeichnung von Daten wie Niederschlagen usw. Daher gibt es möglicherweise viele Gründe, Tabellen und Tabellendaten aus PDF-Dokumenten extrahieren zu 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 Fü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 Konformität: Für rechtliche oder finanzielle Aufzeichnungen kann das programmatische Extrahieren tabellarischer Daten aus PDF-Dokumenten helfen, Audits 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 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 eine Analyse und Interpretation des Inhalts, es sei denn, Sie verwenden OCR-Software wie IronOCR.

So extrahieren Sie Tabellendaten aus einer PDF-Datei in C

Bevor wir untersuchen, wie IronPDF diese Aufgabe bewältigen kann, schauen wir uns zunächst ein Online-Tool an, das in der Lage ist, PDF-Extraktionen durchzuführen. Um eine Tabelle mit einem Online-PDF-Tool aus einem PDF-Dokument zu extrahieren, befolgen Sie die nachstehend aufgeführten Schritte:

1. Navigieren Sie zum kostenlosen Online-PDF-Extraktionstool.
2. Laden Sie das PDF hoch, das die Tabelle enthält.
3. Zeigen Sie die Ergebnisse an und laden Sie sie herunter.

Tabellendaten mit IronPDF extrahieren

IronPDF ermöglicht es Ihnen, Daten, Text und Grafiken aus PDFs zu extrahieren, die dann verwendet werden können, um Tabellen programmatisch zu rekonstruieren. Dazu müssen Sie zuerst den Textinhalt aus der Tabelle im PDF extrahieren und diesen Text dann verwenden, um die Tabelle in Zeilen und Spalten zu zerlegen. Bevor wir mit dem Extrahieren von Tabellen beginnen, werfen wir einen Blick darauf, wie die ExtractAllText()-Methode von IronPDF funktioniert, indem wir die Daten innerhalb einer Tabelle extrahieren:

using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("example.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Output the extracted text to the console
        Console.WriteLine(text);
    }
}

using IronPDF;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("example.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Output the extracted text to the console
        Console.WriteLine(text);
    }
}

Imports IronPDF

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the PDF document
		Dim pdf As PdfDocument = PdfDocument.FromFile("example.pdf")

		' Extract all text from the PDF
		Dim text As String = pdf.ExtractAllText()

		' Output the extracted text to the console
		Console.WriteLine(text)
	End Sub
End Class

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

Tabellendaten aus Text extrahieren mit IronPDF

Nach der Textextraktion aus dem PDF erscheint die Tabelle als eine Reihe von Zeilen und Spalten im Klartext. Sie können diesen Text basierend auf Zeilenumbrüchen (\n) aufteilen und dann die Zeilen weiter in Spalten anhand von konstantem Abstand oder Trennzeichen wie Kommas oder Tabs aufteilen. Hier ist ein einfaches Beispiel, wie die Tabelle aus dem Text geparst wird:

using IronPDF;
using System;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("table.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Split the text into lines (rows)
        string[] lines = text.Split('\n');

        foreach (string line in lines)
        {
            // Split the line into columns using the tab character
            string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
            Console.WriteLine("Row:");

            foreach (string column in columns)
            {
                Console.WriteLine("  " + column); // Output each column in the row
            }
        }
    }
}

using IronPDF;
using System;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        // Load the PDF document
        PdfDocument pdf = PdfDocument.FromFile("table.pdf");

        // Extract all text from the PDF
        string text = pdf.ExtractAllText();

        // Split the text into lines (rows)
        string[] lines = text.Split('\n');

        foreach (string line in lines)
        {
            // Split the line into columns using the tab character
            string[] columns = line.Split('\t').Where(col => !string.IsNullOrWhiteSpace(col)).ToArray();
            Console.WriteLine("Row:");

            foreach (string column in columns)
            {
                Console.WriteLine("  " + column); // Output each column in the row
            }
        }
    }
}

Imports Microsoft.VisualBasic
Imports IronPDF
Imports System
Imports System.Linq

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the PDF document
		Dim pdf As PdfDocument = PdfDocument.FromFile("table.pdf")

		' Extract all text from the PDF
		Dim text As String = pdf.ExtractAllText()

		' Split the text into lines (rows)
		Dim lines() As String = text.Split(ControlChars.Lf)

		For Each line As String In lines
			' Split the line into columns using the tab character
			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) ' Output each column in the row
			Next column
		Next line
	End Sub
End Class

In diesem Beispiel folgten wir den gleichen Schritten wie zuvor, um unser PDF-Dokument zu laden und den Text zu extrahieren. Dann haben wir mit text.Split('\n') den extrahierten Text in Zeilen aufgeteilt basierend auf Zeilenumbrüchen und die Ergebnisse im lines-Array gespeichert. Eine foreach-Schleife wird dann verwendet, um durch die Zeilen im Array zu schleifen, wobei line.Split('\t') verwendet wird, um die Zeilen weiter in Spalten zu unterteilen, wobei das Tabulatorzeichen '\t' als Trennzeichen dient. Der nächste Teil des Spaltenarrays, Where(col => !string.IsNullOrWhiteSpace(col)).ToArray() filtert leere Spalten heraus, die aufgrund von zusätzlichen Leerzeichen entstehen können, und fügt die Spalten dann dem Spaltenarray hinzu.

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

Exportieren von extrahierten Tabellendaten nach CSV

Da wir nun behandelt haben, wie man Tabellen aus PDF-Dateien extrahiert, schauen wir uns an, was wir mit diesen extrahierten Daten machen können. Das Exportieren der Tabelle als CSV-Datei ist eine nützliche Möglichkeit, Tabellendaten zu handhaben und Aufgaben wie die Dateneingabe zu automatisieren. Für dieses Beispiel haben wir eine Tabelle mit simulierten Daten gefüllt, in diesem Fall der täglichen Niederschlagsmenge in einer Woche, die Tabelle aus dem PDF extrahiert und dann in eine CSV-Datei exportiert.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using IronPDF;

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

        // Extract text from the first page
        var text = pdf.ExtractTextFromPage(0); 
        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);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using IronPDF;

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

        // Extract text from the first page
        var text = pdf.ExtractTextFromPage(0); 
        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
Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Linq
Imports IronPDF

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)

		' Extract text from the first page
		Dim text = pdf.ExtractTextFromPage(0)
		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) OrElse 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

Tipps und bewährte Praktiken

Beim Arbeiten mit PDF-Tabellen können einige grundlegende bewährte Praktiken helfen, die Wahrscheinlichkeit von Fehlern oder Problemen zu minimieren.

• Vorverarbeitung von PDFs: Wenn möglich, verarbeiten Sie Ihre PDFs vor, um ein einheitliches Format sicherzustellen, was den Extraktionsprozess vereinfacht.
• Datenvalidierung: Validieren Sie immer die extrahierten Daten, um Genauigkeit und Vollständigkeit sicherzustellen.
• Fehlerbehandlung: Implementieren Sie eine Fehlerbehandlung, um Fälle zu verwalten, in denen die Textextraktion oder das Parsing fehlschlägt, indem Sie beispielsweise Ihren Code in einem try-catch-Block umschließen.
• Leistungsoptimierung: Für große PDFs sollten Sie die Textextraktion und das Parsing optimieren, um Leistungsprobleme zu bewältigen.

IronPDF Lizenzierung

IronPDF bietet verschiedene Lizenzierungs-Optionen, mit denen Sie alle leistungsstarken Funktionen von IronPDF selbst ausprobieren können, bevor Sie sich für eine Lizenz entscheiden.

Abschluss

Das Extrahieren von Tabellen aus PDFs mit IronPDF ist eine leistungsstarke Methode, um die Datenextraktion zu automatisieren, Analysen zu erleichtern und Dokumente in zugänglichere Formate zu konvertieren. Egal, ob Sie es mit einfachen Tabellen oder komplexen, unregelmäßigen Formaten zu tun haben, IronPDF stellt die Werkzeuge bereit, die Sie benötigen, um Tabellendaten effizient zu extrahieren und zu verarbeiten.

Mit IronPDF können Sie Workflows wie automatisierte Dateneingabe, Dokumentenkonvertierung und Datenanalyse rationalisieren. Die Flexibilität und erweiterten Funktionen von IronPDF machen es zu einem wertvollen Werkzeug für die Bearbeitung verschiedener PDF-basierter Aufgaben.