L'extraction des données d'un tableau HTML et leur conversion en feuille Excel est une exigence courante dans les applications d'entreprise, que ce soit pour la migration de données, la génération de rapports ou les pages Web nécessitant une analyse plus approfondie. Ce guide fournit des étapes claires pour exporter des données de tableaux HTML au format Excel à l'aide IronXL et de HTML Agility Pack .

Lorsque vous devez exporter un tableau HTML vers Excel, il est essentiel de comprendre la relation entre les structures des feuilles de calcul Excel et les tableaux HTML. Ce guide montre comment transférer efficacement les données des tableaux HTML vers le format Excel, en créant des sorties de feuilles de calcul Excel professionnelles qui préservent l'intégrité des données.

IronXL offre une méthode flexible pour convertir le contenu d'un tableau HTML en une feuille de calcul Excel, en combinant ses puissantes capacités de manipulation Excel avec l'analyse HTML pour exporter un tableau HTML vers Excel en C#. Que vous ayez besoin de télécharger des données à partir d'une URL ou de traiter du contenu provenant d'une base de données, cette solution gère différents scénarios d'entrée sans nécessiter l'installation de Microsoft Office sur la machine.

Pourquoi utiliser IronXL pour exporter des données de tableau HTML ?

IronXL excelle dans la création et la manipulation de fichiers Excel sans nécessiter l'installation de Microsoft Office , ce qui le rend idéal pour les environnements serveur et les applications multiplateformes. Associé à HTML Agility Pack , un analyseur de fichiers et de contenu HTML performant, IronXL devient une solution polyvalente pour convertir n'importe quelle structure de tableau HTML en données de feuille Excel. Cette approche fonctionne bien avec les applications .NET 10 et peut gérer efficacement de grands ensembles de données.

Contrairement aux bibliothèques telles que la bibliothèque Excel XlsIO de Syncfusion, qui offre une fonction ImportHtmlTable limitée à des formats HTML spécifiques et à des structures de table, l'approche IronXL donne aux développeurs un contrôle total sur le processus d'analyse et de conversion. Cette flexibilité signifie que les développeurs peuvent gérer des scénarios complexes tels que des tables imbriquées, des formats de données personnalisés et l'extraction de colonnes sélectives que les méthodes intégrées rigides ne peuvent pas accueillir.

IronXL offre également une Suite complète de fonctionnalités Excel, notamment la prise en charge des formules , la mise en forme des cellules , la gestion de plusieurs feuilles de calcul et divers formats d'exportation (XLSX, XLS, JSON et CSV). Vous pouvez créer des graphiques, exporter au format PDF et gérer les données des champs cachés, ce qui en fait une solution complète pour l'automatisation d'Excel, allant bien au-delà de la simple conversion de tableaux HTML.

Comment installer les bibliothèques requises ?

Installez IronXL et HTML Agility Pack via le gestionnaire de packages NuGet . IronXL propose un essai gratuit pour tester toutes les fonctionnalités avant de souscrire à une licence.

Console du Gestionnaire de Packages

Install-Package IronXL.Excel

.NET CLI

dotnet add package IronXL.Excel

Ces packages NuGet vous permettent de créer, charger et enregistrer des documents Excel programmatiquement. Après avoir installé les deux packages, ajoutez les instructions using nécessaires en haut de votre fichier C# :

using IronXL;
using HtmlAgilityPack;
using System;
using System.Linq;

using IronXL;
using HtmlAgilityPack;
using System;
using System.Linq;

Imports IronXL
Imports HtmlAgilityPack
Imports System
Imports System.Linq

Imports IronXL
Imports HtmlAgilityPack
Imports System
Imports System.Linq

Ces bibliothèques fonctionnent bien ensemble : HTML Agility Pack gère l'analyse HTML tandis IronXL gère la création et la manipulation des fichiers Excel. Cet exemple illustre une méthode claire pour convertir des tableaux HTML au format XLSX.

Comment analyser les données d'un tableau HTML avec HTML Agility Pack ?

HTML Agility Pack offre une méthode simple pour naviguer dans les documents HTML à l'aide d'expressions XPath. Le code suivant montre comment extraire des données d'une table HTML et les préparer pour l'exportation :

// Sample HTML table with product data
string htmlContent = @"
<table>
    <thead>
        <tr>
            <th>Product</th>
            <th>Price</th>
            <th>Stock</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Laptop</td>
            <td>$999</td>
            <td>15</td>
        </tr>
        <tr>
            <td>Mouse</td>
            <td>$25</td>
            <td>50</td>
        </tr>
        <tr>
            <td>Keyboard</td>
            <td>$75</td>
            <td>30</td>
        </tr>
    </tbody>
</table>";

// Load HTML document for parsing
var doc = new HtmlDocument();
doc.LoadHtml(htmlContent);

// Select the HTML table element using XPath
var table = doc.DocumentNode.SelectSingleNode("//table");

// Sample HTML table with product data
string htmlContent = @"
<table>
    <thead>
        <tr>
            <th>Product</th>
            <th>Price</th>
            <th>Stock</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Laptop</td>
            <td>$999</td>
            <td>15</td>
        </tr>
        <tr>
            <td>Mouse</td>
            <td>$25</td>
            <td>50</td>
        </tr>
        <tr>
            <td>Keyboard</td>
            <td>$75</td>
            <td>30</td>
        </tr>
    </tbody>
</table>";

// Load HTML document for parsing
var doc = new HtmlDocument();
doc.LoadHtml(htmlContent);

// Select the HTML table element using XPath
var table = doc.DocumentNode.SelectSingleNode("//table");

' Sample HTML table with product data
Dim htmlContent As String = "
<table>
    <thead>
        <tr>
            <th>Product</th>
            <th>Price</th>
            <th>Stock</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Laptop</td>
            <td>$999</td>
            <td>15</td>
        </tr>
        <tr>
            <td>Mouse</td>
            <td>$25</td>
            <td>50</td>
        </tr>
        <tr>
            <td>Keyboard</td>
            <td>$75</td>
            <td>30</td>
        </tr>
    </tbody>
</table>"

' Load HTML document for parsing
Dim doc As New HtmlDocument()
doc.LoadHtml(htmlContent)

' Select the HTML table element using XPath
Dim table = doc.DocumentNode.SelectSingleNode("//table")

' Sample HTML table with product data
Dim htmlContent As String = "
<table>
    <thead>
        <tr>
            <th>Product</th>
            <th>Price</th>
            <th>Stock</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Laptop</td>
            <td>$999</td>
            <td>15</td>
        </tr>
        <tr>
            <td>Mouse</td>
            <td>$25</td>
            <td>50</td>
        </tr>
        <tr>
            <td>Keyboard</td>
            <td>$75</td>
            <td>30</td>
        </tr>
    </tbody>
</table>"

' Load HTML document for parsing
Dim doc As New HtmlDocument()
doc.LoadHtml(htmlContent)

' Select the HTML table element using XPath
Dim table = doc.DocumentNode.SelectSingleNode("//table")

Ce code charge le contenu HTML dans un objet HtmlDocument et utilise XPath pour interroger et sélectionner l'élément de table. La méthode SelectSingleNode retourne la première table trouvée dans le HTML, ce qui facilite le ciblage de tables spécifiques lorsqu'il en existe plusieurs. Chaque ligne de table est ensuite traitée pour extraire la valeur des cellules pour la conversion.

Quelles expressions XPath sont les plus performantes pour l'analyse de tableaux ?

Pour les tables HTML standard, l'expression XPath //table sélectionne la première table dans le document. Lors du travail avec des pages plus complexes contenant plusieurs tables, vous pouvez utiliser des sélecteurs positionnels tels que (//table)[2] pour cibler une table spécifique par son index. Les sélecteurs basés sur les attributs comme //table[@id='data-table'] ou //table[@class='products'] sont également utiles lorsque les tables portent des identifiants significatifs.

Lorsque le HTML provient d'une URL en direct, vous pouvez charger directement le document à l'aide de la classe HtmlWeb :

var web = new HtmlWeb();
var remoteDoc = web.Load("https://example.com/data-page");
var remoteTable = remoteDoc.DocumentNode.SelectSingleNode("//table[@class='data-table']");

var web = new HtmlWeb();
var remoteDoc = web.Load("https://example.com/data-page");
var remoteTable = remoteDoc.DocumentNode.SelectSingleNode("//table[@class='data-table']");

Dim web As New HtmlWeb()
Dim remoteDoc = web.Load("https://example.com/data-page")
Dim remoteTable = remoteDoc.DocumentNode.SelectSingleNode("//table[@class='data-table']")

Dim web As New HtmlWeb()
Dim remoteDoc = web.Load("https://example.com/data-page")
Dim remoteTable = remoteDoc.DocumentNode.SelectSingleNode("//table[@class='data-table']")

Cela vous permet d'extraire des tableaux directement à partir de pages web publiques sans avoir à enregistrer manuellement le code HTML au préalable.

Comment exporter des données analysées vers Excel à l'aide IronXL?

Avec IronXL, vous pouvez convertir les données d'un tableau HTML analysé en une feuille de calcul Excel Professional avec une mise en forme appropriée. Le code suivant montre comment exporter les données avec un style personnalisé :

// Create a new Excel workbook
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Exported Data");

// Extract and write headers
var headers = table.SelectNodes(".//thead/tr/th");
if (headers != null)
{
    for (int col = 0; col < headers.Count; col++)
    {
        workSheet.SetCellValue(0, col, headers[col].InnerText.Trim());

        // Apply header formatting
        var headerCell = workSheet.GetCellAt(0, col);
        headerCell.Style.Font.Bold = true;
        headerCell.Style.BackgroundColor = "#4CAF50";
    }
}

// Extract and write data rows
var rows = table.SelectNodes(".//tbody/tr");
if (rows != null)
{
    for (int row = 0; row < rows.Count; row++)
    {
        var cells = rows[row].SelectNodes("td");
        if (cells != null)
        {
            for (int col = 0; col < cells.Count; col++)
            {
                string cellValue = cells[col].InnerText.Trim();
                workSheet.SetCellValue(row + 1, col, cellValue);
            }
        }
    }
}

// Auto-fit columns for better readability
for (int col = 0; col < headers?.Count; col++)
{
    workSheet.AutoSizeColumn(col);
}

// Save the Excel file
workBook.SaveAs("ExportedTable.xlsx");

// Create a new Excel workbook
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Exported Data");

// Extract and write headers
var headers = table.SelectNodes(".//thead/tr/th");
if (headers != null)
{
    for (int col = 0; col < headers.Count; col++)
    {
        workSheet.SetCellValue(0, col, headers[col].InnerText.Trim());

        // Apply header formatting
        var headerCell = workSheet.GetCellAt(0, col);
        headerCell.Style.Font.Bold = true;
        headerCell.Style.BackgroundColor = "#4CAF50";
    }
}

// Extract and write data rows
var rows = table.SelectNodes(".//tbody/tr");
if (rows != null)
{
    for (int row = 0; row < rows.Count; row++)
    {
        var cells = rows[row].SelectNodes("td");
        if (cells != null)
        {
            for (int col = 0; col < cells.Count; col++)
            {
                string cellValue = cells[col].InnerText.Trim();
                workSheet.SetCellValue(row + 1, col, cellValue);
            }
        }
    }
}

// Auto-fit columns for better readability
for (int col = 0; col < headers?.Count; col++)
{
    workSheet.AutoSizeColumn(col);
}

// Save the Excel file
workBook.SaveAs("ExportedTable.xlsx");

Imports System
Imports System.Xml

' Create a new Excel workbook
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Exported Data")

' Extract and write headers
Dim headers As XmlNodeList = table.SelectNodes(".//thead/tr/th")
If headers IsNot Nothing Then
    For col As Integer = 0 To headers.Count - 1
        workSheet.SetCellValue(0, col, headers(col).InnerText.Trim())

        ' Apply header formatting
        Dim headerCell = workSheet.GetCellAt(0, col)
        headerCell.Style.Font.Bold = True
        headerCell.Style.BackgroundColor = "#4CAF50"
    Next
End If

' Extract and write data rows
Dim rows As XmlNodeList = table.SelectNodes(".//tbody/tr")
If rows IsNot Nothing Then
    For row As Integer = 0 To rows.Count - 1
        Dim cells As XmlNodeList = rows(row).SelectNodes("td")
        If cells IsNot Nothing Then
            For col As Integer = 0 To cells.Count - 1
                Dim cellValue As String = cells(col).InnerText.Trim()
                workSheet.SetCellValue(row + 1, col, cellValue)
            Next
        End If
    Next
End If

' Auto-fit columns for better readability
For col As Integer = 0 To If(headers?.Count, 0) - 1
    workSheet.AutoSizeColumn(col)
Next

' Save the Excel file
workBook.SaveAs("ExportedTable.xlsx")

Imports System
Imports System.Xml

' Create a new Excel workbook
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Exported Data")

' Extract and write headers
Dim headers As XmlNodeList = table.SelectNodes(".//thead/tr/th")
If headers IsNot Nothing Then
    For col As Integer = 0 To headers.Count - 1
        workSheet.SetCellValue(0, col, headers(col).InnerText.Trim())

        ' Apply header formatting
        Dim headerCell = workSheet.GetCellAt(0, col)
        headerCell.Style.Font.Bold = True
        headerCell.Style.BackgroundColor = "#4CAF50"
    Next
End If

' Extract and write data rows
Dim rows As XmlNodeList = table.SelectNodes(".//tbody/tr")
If rows IsNot Nothing Then
    For row As Integer = 0 To rows.Count - 1
        Dim cells As XmlNodeList = rows(row).SelectNodes("td")
        If cells IsNot Nothing Then
            For col As Integer = 0 To cells.Count - 1
                Dim cellValue As String = cells(col).InnerText.Trim()
                workSheet.SetCellValue(row + 1, col, cellValue)
            Next
        End If
    Next
End If

' Auto-fit columns for better readability
For col As Integer = 0 To If(headers?.Count, 0) - 1
    workSheet.AutoSizeColumn(col)
Next

' Save the Excel file
workBook.SaveAs("ExportedTable.xlsx")

Ce code démontre l'API intuitive d'IronXL pour la manipulation Excel en C#. Il crée un nouveau classeur et une nouvelle feuille de calcul , puis parcourt les en-têtes de tableau HTML analysés, en les plaçant dans la première ligne tout en appliquant une mise en forme en gras et une couleur de fond verte. Les lignes de données du tableau HTML sont traitées ligne par ligne, le contenu textuel de chaque cellule étant extrait et placé dans la cellule Excel correspondante. La fonction AutoSizeColumn garantit que tout le contenu est visible, et le classeur est enregistré en tant que fichier XLSX.

Vous pouvez voir ici le tableau HTML original comparé au résultat du code ci-dessus :

Comment appliquer une mise en forme aux cellules des données exportées ?

Au-delà des couleurs de fond et de gras de base présentées ci-dessus, IronXL vous offre un contrôle précis sur le style des cellules . Vous pouvez définir la taille de la police, la famille de polices, l'alignement du texte, les bordures et les formats numériques pour n'importe quelle cellule ou plage :

// Apply number formatting to a price column (column index 1)
var priceRange = workSheet[$"B2:B{rows.Count + 1}"];
priceRange.FormatString = "$#,##0.00";

// Set font size on all header cells
var headerRange = workSheet[$"A1:{(char)('A' + headers.Count - 1)}1"];
headerRange.Style.Font.Height = 13; // in half-points, so 13 = 6.5pt

// Apply number formatting to a price column (column index 1)
var priceRange = workSheet[$"B2:B{rows.Count + 1}"];
priceRange.FormatString = "$#,##0.00";

// Set font size on all header cells
var headerRange = workSheet[$"A1:{(char)('A' + headers.Count - 1)}1"];
headerRange.Style.Font.Height = 13; // in half-points, so 13 = 6.5pt

' Apply number formatting to a price column (column index 1)
Dim priceRange = workSheet($"B2:B{rows.Count + 1}")
priceRange.FormatString = "$#,##0.00"

' Set font size on all header cells
Dim headerRange = workSheet($"A1:{Chr(Asc("A"c) + headers.Count - 1)}1")
headerRange.Style.Font.Height = 13 ' in half-points, so 13 = 6.5pt

' Apply number formatting to a price column (column index 1)
Dim priceRange = workSheet($"B2:B{rows.Count + 1}")
priceRange.FormatString = "$#,##0.00"

' Set font size on all header cells
Dim headerRange = workSheet($"A1:{Chr(Asc("A"c) + headers.Count - 1)}1")
headerRange.Style.Font.Height = 13 ' in half-points, so 13 = 6.5pt

Pour les largeurs de colonne, AutoSizeColumn gère la plupart des cas, mais vous pouvez également définir des largeurs explicites à l'aide de la méthode SetColumnWidth lorsque vous avez besoin d'une mise en page précise. Ces options de style font partie de la même API IronXL qui gère les styles de police des cellules dans le reste de votre classeur.

Comment gérez-vous plusieurs tables et les scénarios d'erreur ?

Lors du travail avec plusieurs tables sur une seule page, utilisez SelectNodes("//table") pour récupérer toutes les tables et itérer à travers elles, en créant une feuille de calcul séparée pour chacune :

var tables = doc.DocumentNode.SelectNodes("//table");
if (tables != null)
{
    for (int t = 0; t < tables.Count; t++)
    {
        WorkSheet ws = workBook.CreateWorkSheet($"Table_{t + 1}");
        var tblHeaders = tables[t].SelectNodes(".//thead/tr/th");
        var tblRows = tables[t].SelectNodes(".//tbody/tr");

        if (tblHeaders != null)
        {
            for (int col = 0; col < tblHeaders.Count; col++)
            {
                ws.SetCellValue(0, col, tblHeaders[col].InnerText.Trim());
                ws.GetCellAt(0, col).Style.Font.Bold = true;
            }
        }

        if (tblRows != null)
        {
            for (int row = 0; row < tblRows.Count; row++)
            {
                var cells = tblRows[row].SelectNodes("td");
                if (cells != null)
                {
                    for (int col = 0; col < cells.Count; col++)
                    {
                        ws.SetCellValue(row + 1, col, cells[col].InnerText.Trim());
                    }
                }
            }
        }
    }
}

workBook.SaveAs("MultiTableExport.xlsx");

var tables = doc.DocumentNode.SelectNodes("//table");
if (tables != null)
{
    for (int t = 0; t < tables.Count; t++)
    {
        WorkSheet ws = workBook.CreateWorkSheet($"Table_{t + 1}");
        var tblHeaders = tables[t].SelectNodes(".//thead/tr/th");
        var tblRows = tables[t].SelectNodes(".//tbody/tr");

        if (tblHeaders != null)
        {
            for (int col = 0; col < tblHeaders.Count; col++)
            {
                ws.SetCellValue(0, col, tblHeaders[col].InnerText.Trim());
                ws.GetCellAt(0, col).Style.Font.Bold = true;
            }
        }

        if (tblRows != null)
        {
            for (int row = 0; row < tblRows.Count; row++)
            {
                var cells = tblRows[row].SelectNodes("td");
                if (cells != null)
                {
                    for (int col = 0; col < cells.Count; col++)
                    {
                        ws.SetCellValue(row + 1, col, cells[col].InnerText.Trim());
                    }
                }
            }
        }
    }
}

workBook.SaveAs("MultiTableExport.xlsx");

Imports System

Dim tables = doc.DocumentNode.SelectNodes("//table")
If tables IsNot Nothing Then
    For t As Integer = 0 To tables.Count - 1
        Dim ws As WorkSheet = workBook.CreateWorkSheet($"Table_{t + 1}")
        Dim tblHeaders = tables(t).SelectNodes(".//thead/tr/th")
        Dim tblRows = tables(t).SelectNodes(".//tbody/tr")

        If tblHeaders IsNot Nothing Then
            For col As Integer = 0 To tblHeaders.Count - 1
                ws.SetCellValue(0, col, tblHeaders(col).InnerText.Trim())
                ws.GetCellAt(0, col).Style.Font.Bold = True
            Next
        End If

        If tblRows IsNot Nothing Then
            For row As Integer = 0 To tblRows.Count - 1
                Dim cells = tblRows(row).SelectNodes("td")
                If cells IsNot Nothing Then
                    For col As Integer = 0 To cells.Count - 1
                        ws.SetCellValue(row + 1, col, cells(col).InnerText.Trim())
                    Next
                End If
            Next
        End If
    Next
End If

workBook.SaveAs("MultiTableExport.xlsx")

Imports System

Dim tables = doc.DocumentNode.SelectNodes("//table")
If tables IsNot Nothing Then
    For t As Integer = 0 To tables.Count - 1
        Dim ws As WorkSheet = workBook.CreateWorkSheet($"Table_{t + 1}")
        Dim tblHeaders = tables(t).SelectNodes(".//thead/tr/th")
        Dim tblRows = tables(t).SelectNodes(".//tbody/tr")

        If tblHeaders IsNot Nothing Then
            For col As Integer = 0 To tblHeaders.Count - 1
                ws.SetCellValue(0, col, tblHeaders(col).InnerText.Trim())
                ws.GetCellAt(0, col).Style.Font.Bold = True
            Next
        End If

        If tblRows IsNot Nothing Then
            For row As Integer = 0 To tblRows.Count - 1
                Dim cells = tblRows(row).SelectNodes("td")
                If cells IsNot Nothing Then
                    For col As Integer = 0 To cells.Count - 1
                        ws.SetCellValue(row + 1, col, cells(col).InnerText.Trim())
                    Next
                End If
            Next
        End If
    Next
End If

workBook.SaveAs("MultiTableExport.xlsx")

Que faire lorsque le code HTML est malformé ?

Le code HTML utilisé dans le monde réel n'est pas toujours valide. Les pages extraites de sources externes peuvent avoir des balises de fermeture manquantes, des structures tbody incohérentes, ou des éléments th et td mélangés dans la ligne d'en-tête. HTML Agility Pack est conçu pour être tolérant et analysera la plupart des codes HTML malformés sans générer d'exceptions, mais vos sélecteurs XPath peuvent ne pas correspondre à ce que vous attendez.

Un modèle sûr est d'envelopper la logique d'analyse dans un bloc try-catch et d'ajouter un retour qui recherche les éléments tr directement sous la table lorsqu'aucun thead n'est trouvé :

try
{
    var headerNodes = table.SelectNodes(".//thead/tr/th")
                     ?? table.SelectNodes(".//tr[1]/th")
                     ?? table.SelectNodes(".//tr[1]/td");

    var dataRows = table.SelectNodes(".//tbody/tr")
                  ?? table.SelectNodes(".//tr[position()>1]");

    // ... process as normal
}
catch (Exception ex)
{
    Console.WriteLine($"Table parsing failed: {ex.Message}");
}

try
{
    var headerNodes = table.SelectNodes(".//thead/tr/th")
                     ?? table.SelectNodes(".//tr[1]/th")
                     ?? table.SelectNodes(".//tr[1]/td");

    var dataRows = table.SelectNodes(".//tbody/tr")
                  ?? table.SelectNodes(".//tr[position()>1]");

    // ... process as normal
}
catch (Exception ex)
{
    Console.WriteLine($"Table parsing failed: {ex.Message}");
}

Imports System

Try
    Dim headerNodes = table.SelectNodes(".//thead/tr/th") _
                     OrElse table.SelectNodes(".//tr[1]/th") _
                     OrElse table.SelectNodes(".//tr[1]/td")

    Dim dataRows = table.SelectNodes(".//tbody/tr") _
                  OrElse table.SelectNodes(".//tr[position()>1]")

    ' ... process as normal
Catch ex As Exception
    Console.WriteLine($"Table parsing failed: {ex.Message}")
End Try

Imports System

Try
    Dim headerNodes = table.SelectNodes(".//thead/tr/th") _
                     OrElse table.SelectNodes(".//tr[1]/th") _
                     OrElse table.SelectNodes(".//tr[1]/td")

    Dim dataRows = table.SelectNodes(".//tbody/tr") _
                  OrElse table.SelectNodes(".//tr[position()>1]")

    ' ... process as normal
Catch ex As Exception
    Console.WriteLine($"Table parsing failed: {ex.Message}")
End Try

IronXL gère automatiquement la détection du type de données, convertissant les chaînes numériques en nombres lorsque cela est approprié. Pour des scénarios plus complexes impliquant du contenu rendu en JavaScript, vous pouvez combiner cette approche avec des outils comme Selenium WebDriver ou Playwright pour d'abord rendre la page, puis transmettre le code HTML résultant à HTML Agility Pack pour analyse.

Comment enregistrer et exporter un fichier Excel ?

IronXL prend en charge de multiples formats de sortie autres que XLSX. Vous pouvez enregistrer au format XLS, CSV, TSV ou JSON en fonction des exigences en aval. Vous pouvez également diffuser la sortie directement vers une réponse HTTP dans ASP.NET Core, ce qui évite d'écrire un fichier sur le disque :

// Save to disk as XLSX
workBook.SaveAs("ExportedTable.xlsx");

// Save as CSV
workBook.SaveAsCsv("ExportedTable.csv");

// Stream to HTTP response (ASP.NET Core)
// Response.Headers["Content-Disposition"] = "attachment; filename=ExportedTable.xlsx";
// workBook.SaveAs(Response.BodyWriter.AsStream());

// Save to disk as XLSX
workBook.SaveAs("ExportedTable.xlsx");

// Save as CSV
workBook.SaveAsCsv("ExportedTable.csv");

// Stream to HTTP response (ASP.NET Core)
// Response.Headers["Content-Disposition"] = "attachment; filename=ExportedTable.xlsx";
// workBook.SaveAs(Response.BodyWriter.AsStream());

' Save to disk as XLSX
workBook.SaveAs("ExportedTable.xlsx")

' Save as CSV
workBook.SaveAsCsv("ExportedTable.csv")

' Stream to HTTP response (ASP.NET Core)
' Response.Headers("Content-Disposition") = "attachment; filename=ExportedTable.xlsx"
' workBook.SaveAs(Response.BodyWriter.AsStream())

' Save to disk as XLSX
workBook.SaveAs("ExportedTable.xlsx")

' Save as CSV
workBook.SaveAsCsv("ExportedTable.csv")

' Stream to HTTP response (ASP.NET Core)
' Response.Headers("Content-Disposition") = "attachment; filename=ExportedTable.xlsx"
' workBook.SaveAs(Response.BodyWriter.AsStream())

Lors de l'envoi en continu à une réponse HTTP, assurez-vous que l'en-tête Content-Disposition est défini sur attachment afin que le navigateur traite la réponse comme un téléchargement de fichier. Ce modèle fonctionne aussi bien avec les contrôleurs MVC qu'avec les pages Razor .

Pour les scénarios où vous devez exporter des données vers un modèle Excel existant , IronXL peut charger un classeur existant et remplir des plages nommées ou des adresses de cellules spécifiques avec les données HTML analysées, en préservant toute la mise en forme du modèle.

Quelles sont les meilleures pratiques pour une utilisation en production ?

Lors du traitement du contenu provenant d'une URL ou d'une requête de base de données en vue d'une analyse plus approfondie, tenez compte des détails supplémentaires tels que les valeurs des champs cachés ou les exigences de formatage particulières. Le comportement par défaut convient parfaitement aux tableaux standard, mais vous pouvez personnaliser la taille de la police, la famille de polices et d'autres propriétés de style pour chaque colonne ou pour chaque ligne de tableau spécifique.

Pour relire les données des fichiers Excel après exportation, IronXL utilise la même API WorkBook.Load, ce qui rend les flux de travail aller-retour simples. Vous pouvez également convertir le fichier Excel obtenu en d'autres formats tels que JSON ou XML pour un traitement ultérieur.

Comment gérez-vous les licences et le déploiement ?

IronXL nécessite une clé de licence pour une utilisation en production. L' essai gratuit inclut toutes les fonctionnalités et est idéal pour évaluer la bibliothèque avant de l'acheter. Explorez les options de tarification et de licence pour trouver le niveau qui convient le mieux à votre équipe.

Pour un déploiement dans des environnements Docker, Azure Functions ou Linux, IronXL ne dépend pas de Microsoft Office ni de l'interopérabilité COM, ce qui simplifie sa gestion. Il prend en charge .NET 10 , .NET 9, .NET 8, .NET Framework 4.6.2+ et est entièrement compatible avec les modèles d'exportation ASP.NET Core actuels.

L'association d' IronXL et d'HTML Agility Pack offre une solution flexible pour l'exportation de tableaux HTML vers Excel en C#. L'approche présentée ici offre un contrôle plus précis que les méthodes intégrées rigides, vous permettant de gérer des structures HTML complexes tout en tirant parti de l'ensemble des fonctionnalités Excel d'IronXL.

Que vous créiez des robots d'extraction de données Web, migriez des données existantes à partir d'une base de données, automatisiez la génération de rapports ou effectuiez des analyses de données sur de grands ensembles de données, cette solution s'adapte aux besoins des Enterprise . Les exemples de code montrent comment gérer différentes sources d'entrée, des chaînes HTML statiques au contenu dynamique récupéré via une URL. Les résultats peuvent être exportés pour être téléchargés ou traités ultérieurement dans votre application .NET .

Prêt à transformer vos données HTML en fichiers Excel Professional ? Démarrez votre essai gratuit d' IronXL dès aujourd'hui et découvrez la flexibilité de la manipulation programmatique d'Excel sans dépendance à Office.