Comment lire un tableau PDF en C#

Extraire des données de tableau structurées à partir de documents PDF est une nécessité fréquente pour les développeurs C#, cruciale pour l'analyse des données, la création de rapports ou l'intégration d'informations dans d'autres systèmes. Cependant, les PDF sont principalement conçus pour une présentation visuelle cohérente, et non pour une extraction de données simplifiée. Cela peut rendre la lecture des tableaux à partir de fichiers PDF de manière programmatique en C# une tâche ardue, d'autant plus que les tableaux peuvent varier considérablement : des grilles simples basées sur du texte aux mises en page complexes avec cellules fusionnées, ou même des tableaux intégrés sous forme d'images dans des documents scannés.

Ce guide fournit un tutoriel C# complet sur la façon d'aborder l'extraction de tableaux PDF à l'aide de IronPDF. Nous explorerons principalement l'utilisation des puissantes capacités d'extraction de texte d'IronPDF pour accéder et ensuite analyser des données tabulaires à partir de PDF basés sur du texte. Nous discuterons de l'efficacité de cette méthode, fournirons des stratégies pour le parsing et offrirons des perspectives sur la gestion des informations extraites. De plus, nous aborderons des stratégies pour traiter des scénarios plus complexes, y compris les PDF scannés.

Étapes Clés pour Extraire des Données de Tableaux à partir de PDFs en C#

1. Installez la bibliothèque IronPDF C# (https://nuget.org/packages/IronPdf/) pour le traitement des PDF.

2. (Étape de démonstration facultative) Créez un exemple de PDF avec un tableau à partir d'une chaîne HTML en utilisant RenderHtmlAsPdf de IronPDF. (Voir la section : (Étape de démonstration) Créer un document PDF avec des données de tableau)

3. Chargez n'importe quel document PDF et utilisez la méthode ExtractAllText pour récupérer son contenu texte brut. (Voir la section : Extraire tout le texte contenant des données de table du PDF)

4. Implémentez la logique C# pour analyser le texte extrait et identifier les lignes et cellules du tableau. (Voir la section : Analyse du texte extrait pour reconstruire les données de tableau en C#)

5. Exporter les données structurées du tableau ou les enregistrer dans un fichier CSV pour une utilisation ultérieure. (Voir la section : Analyse du texte extrait pour reconstruire les données de tableau en C#)

6. Envisagez des techniques avancées comme l'OCR pour les PDF scannés (discuté plus tard).

   ---

IronPDF - Bibliothèque PDF C#

IronPDF est une solution de bibliothèque .NET en C# pour la manipulation de PDF dans .NET (https://ironpdf.com/), qui aide les développeurs à lire, créer et éditer des documents PDF facilement dans leurs applications logicielles. Son moteur Chromium robuste rend les documents PDF à partir de HTML avec une grande précision et rapidité. Il permet aux développeurs de convertir des formats différents en PDF et vice versa de manière transparente. Il prend en charge les derniers frameworks .NET y compris .NET 7, .NET 6, 5, 4, .NET Core et Standard.

De plus, l'API IronPDF .NET permet également aux développeurs de manipuler et d'éditer des PDFs, d'ajouter des en-têtes et des pieds de page, et surtout, d'extraire facilement du texte, des images et, comme nous le verrons, des données de tableau à partir de PDFs.

Parmi les fonctionnalités importantes, on trouve :

• Créer des fichiers PDF à partir de diverses sources (Images en PDF)
• Charger, enregistrer et imprimer des fichiers PDF
• séparer des fichiers PDF
• Extraire des données (texte, images et données structurées comme des tableaux) à partir de fichiers PDF

Étapes pour extraire les données de tableau en C# en utilisant la bibliothèque IronPDF

Pour extraire les données de tableau à partir de documents PDF, nous allons configurer un projet C# :

1. Visual Studio : Assurez-vous d'avoir Visual Studio (par exemple, 2022) installé. Si ce n'est pas le cas, téléchargez-le depuis le site Web de Visual Studio (https://visualstudio.microsoft.com/downloads/).

2. Créer un projet :

   • Ouvrez Visual Studio 2022 et cliquez sur Créer un nouveau projet.

   

   Écran de démarrage de Visual Studio

   • Sélectionnez "Application Console" (ou votre type de projet C# préféré) et cliquez sur Suivant.

   

   Créer une nouvelle application Console dans Visual Studio

   • Nommer votre projet (par exemple, "ReadPDFTableDemo") et cliquez sur Suivant.

   

   Configurer la nouvelle application créée

   • Choisissez le .NET Framework souhaité (par exemple, .NET 6 ou ultérieur).

   

   Sélectionnez un .NET Framework

   • Cliquez sur Créer. Le projet de console sera créé.

3. Installer IronPDF :

   • Utiliser le gestionnaire de packages NuGet de Visual Studio :

     • Faites un clic droit sur votre projet dans l'Explorateur de solutions et sélectionnez "Gérer les packages NuGet..."

   

   Outils et gérer les packages NuGet

   • Dans le gestionnaire de packages NuGet, recherchez "IronPdf" et cliquez sur "Installer".

   

   Outils et gérer les packages NuGet

   • Télécharger directement le package NuGet : Visitez la page du package NuGet d'IronPDF (https://www.nuget.org/packages/IronPdf/).

   • Téléchargez la bibliothèque .DLL d'IronPDF : Téléchargez depuis le site officiel d'IronPDF et référencez la DLL dans votre projet.

(Étape de démonstration) Créer un document PDF avec des données de tableau

Pour ce tutoriel, nous allons d'abord créer un exemple de PDF contenant un simple tableau à partir d'une chaîne HTML. Cela nous donne une structure PDF connue pour démontrer le processus d'extraction. Dans un scénario réel, vous chargeriez vos fichiers PDF préexistants.

Ajoutez l'espace de noms IronPDF et, éventuellement, définissez votre clé de licence (IronPDF est gratuit pour le développement, mais nécessite une licence pour le déploiement commercial sans filigranes) :

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

Voici la chaîne HTML pour notre table d'exemple :

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

Maintenant, utilisez ChromePdfRenderer pour créer un PDF à partir de cet HTML :

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.")

La méthode SaveAs enregistre le PDF. Le fichier table_example.pdf généré ressemblera à ceci (image conceptuelle basée sur HTML) :

Rechercher IronPDF dans l'interface du gestionnaire de packages NuGet

Extraire tout le texte contenant des données de table à partir du PDF

Pour extraire les données du tableau, nous chargeons d'abord le PDF (soit celui que nous venons de créer, soit tout PDF existant) et utilisons la méthode ExtractAllText. Cette méthode extrait tout le contenu textuel des pages du PDF.

// 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()

La variable allText contient maintenant tout le contenu textuel du PDF. Vous pouvez l'afficher pour voir l'extraction brute :

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)

Le fichier PDF pour extraire du texte

Analyser le texte extrait pour reconstruire des données de table en C#

Avec le texte brut extrait, le prochain défi est d'analyser cette chaîne pour identifier et structurer les données tabulaires. Cette étape dépend fortement de la cohérence et du format des tableaux dans vos fichiers PDF.

Stratégies générales d'analyse :

1. Identifier les délimiteurs de ligne : Les caractères de nouvelle ligne (\n ou \r\n) sont des séparateurs de lignes courants.

2. Identifier les délimiteurs de colonnes : Les cellules au sein d'une ligne peuvent être séparées par plusieurs espaces, des tabulations ou des caractères spécifiques connus (comme ' ' ou ';'). Parfois, si les colonnes sont visuellement alignées mais manquent de délimiteurs de texte clairs, vous pouvez déduire la structure en vous basant sur des motifs d'espacement cohérents, bien que cela soit plus complexe.

3. Filtrer le contenu non-table : La méthode ExtractAllText récupère tout le texte. Vous aurez besoin de logique pour isoler le texte qui constitue réellement votre tableau, éventuellement en recherchant des mots-clés d'en-tête ou en sautant le texte d'introduction/de conclusion.

   La méthode String.Split en C# est un outil de base pour cela. Voici un exemple qui tente d'extraire uniquement les lignes de table de notre échantillon, en filtrant les lignes avec des points (une heuristique simple pour cet exemple spécifique) :

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

Ce code divise le texte en lignes. La condition if est un filtre très basique pour le texte non tabulaire de cet exemple spécifique. Dans des scénarios réels, vous auriez besoin d'une logique plus robuste pour identifier et analyser les lignes et les cellules de tableau avec précision.

Sortie du texte filtré simple :

La console affiche les textes extraits

Considérations importantes pour la méthode d'analyse de texte :

• Idéal pour : Les PDFs basés sur du texte avec des structures de table simples et cohérentes et des délimiteurs textuels clairs.

• Limitations : Cette méthode peut rencontrer des difficultés avec :

  • Tables avec des cellules fusionnées ou des structures imbriquées complexes.

  • Tables où les colonnes sont définies par un espacement visuel plutôt que par des délimiteurs de texte.

  • Tableaux intégrés sous forme d'images (nécessitant l'OCR).

  • Variations dans la génération de PDF entraînant un ordre d'extraction de texte incohérent.

  Vous pouvez enregistrer les lignes filtrées (qui représentent idéalement des lignes de tableau) dans un fichier 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");

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

Stratégies pour une extraction de tableaux PDF plus complexe en C#

L'extraction de données à partir de tableaux PDF complexes ou basés sur des images nécessite souvent des techniques plus avancées qu'une simple analyse de texte. IronPDF propose des fonctionnalités qui peuvent aider :

• Utilisation des capacités d'IronOCR pour les tableaux numérisés : Si les tableaux sont dans des images (par exemple, des PDF numérisés), ExtractAllText() seul ne les capturera pas. La fonctionnalité de détection de texte d'IronOCR peut d'abord convertir ces images en texte.

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

Pour des conseils détaillés, visitez la documentation IronOCR (https://ironsoftware.com/csharp/ocr/). Après l'OCR, vous analyseriez la chaîne de texte résultante.

• Extraction de texte basée sur les coordonnées (Avancé) : Bien que la fonction ExtractAllText() d'IronPDF fournisse le flux de texte, certains scénarios pourraient bénéficier de la connaissance des coordonnées x, y de chaque extrait de texte. Si IronPDF propose des API pour obtenir du texte avec ses informations de cadre de délimitation (consultez la documentation actuelle), cela pourrait permettre une analyse spatiale plus sophistiquée pour reconstruire des tableaux en fonction de l'alignement visuel.
• Conversion de PDF en un autre format : IronPDF peut convertir des PDF en formats structurés comme HTML. Souvent, analyser un tableau HTML est plus simple que d'analyser du texte brut d'un PDF.

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.

• Reconnaissance de motifs et expressions régulières : Pour les tableaux avec des motifs très prévisibles mais des délimiteurs incohérents, des expressions régulières complexes appliquées au texte extrait peuvent parfois isoler les données du tableau.

  Choisir la bonne stratégie dépend de la complexité et de la cohérence de vos PDF source. Pour de nombreux documents commerciaux courants contenant des tableaux basés sur du texte, la fonction ExtractAllText de IronPDF associée à une logique de parsing intelligente en C# peut être très efficace. Pour les tableaux basés sur des images, ses capacités OCR sont essentielles.

Résumé

Cet article a démontré comment extraire des données de tableau à partir d'un document PDF en C# en utilisant IronPDF, en se concentrant principalement sur l'utilisation de la méthode ExtractAllText() et le traitement ultérieur de la chaîne. Nous avons constaté que, bien que cette approche soit puissante pour les tableaux basés sur du texte, des scénarios plus complexes comme les tableaux basés sur des images peuvent être traités en utilisant les fonctionnalités OCR d'IronPDF ou en convertissant d'abord les PDF vers d'autres formats.

IronPDF offre une boîte à outils polyvalente pour les développeurs .NET, simplifiant de nombreuses tâches liées aux PDF, de la création et l'édition à l'extraction de données complète. Il propose des méthodes comme DOCX vers PDF.

IronPDF est gratuit pour le développement et offre une licence d'essai gratuite pour tester ses fonctionnalités commerciales complètes. Pour le déploiement en production, diverses options de licence sont disponibles.

Pour plus de détails et des cas d'utilisation avancés, explorez la documentation officielle et les exemples d'IronPDF (https://ironpdf.com/)