Jak eksportować tabelę HTML do Excel w C# używając IronXL

Dlaczego warto używać IronXL do eksportowania danych z tabel HTML?

IronXL doskonale sprawdza się w tworzeniu i edycji plików Excel bez konieczności instalowania pakietu Microsoft Office, co czyni go idealnym rozwiązaniem dla środowisk serwerowych i aplikacji wielopłatformowych. W połączeniu z HTML Agility Pack, wydajnym parserem plików HTML i treści, IronXL staje się wszechstronnym rozwiązaniem do konwersji dowolnej struktury tabeli HTML na dane arkusza Excel. To podejście sprawdza się dobrze w aplikacjach .NET 10 i pozwala efektywnie obsługiwać duże zbiory danych.

W przeciwieństwie do bibliotek takich jak XlsIO biblioteki Excel Syncfusion, oferującej funkcję ImportHtmlTable ograniczoną do określonych formatów HTML i struktur tabel, podejście IronXL daje programistom pełną kontrolę nad procesem parsowania i konwersji. Ta elastyczność oznacza, że programiści mogą radzić sobie ze złożonymi scenariuszami, takimi jak zagnieżdżone tabele, niestandardowe formatowanie danych i selektywne wyodrębnianie kolumn, których nie są w stanie obsłużyć sztywne metody wbudowane.

IronXL zapewnia również pełną Suite funkcji programu Excel, w tym obsługę formuł, stylizację komórek, zarządzanie wieloma arkuszami oraz różne formaty eksportu (XLSX, XLS, JSON i CSV). Można tworzyć wykresy, eksportować do formatu PDF oraz zarządzać danymi z pól ukrytych, co sprawia, że jest to kompletne rozwiązanie do automatyzacji programu Excel, wykraczające poza zwykłą konwersję tabel HTML.

Jak zainstalować wymagane biblioteki?

Zainstaluj zarówno IronXL, jak i HTML Agility Pack za pomocą menedżera pakietów NuGet. IronXL oferuje bezpłatną wersję próbną, która pozwala przetestować wszystkie funkcje przed zakupem licencji.

:ProductInstall
Install-Package HtmlAgilityPack

:ProductInstall
Install-Package HtmlAgilityPack

dotnet add package IronXL.Excel
dotnet add package HtmlAgilityPack

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

Jak analizować dane z tabel HTML za pomocą HTML Agility Pack?

HTML Agility Pack zapewnia prosty sposób nawigacji po dokumentach HTML przy użyciu wyrażeń XPath. Poniższy kod pokazuje, jak wyodrębnić dane z tabeli HTML i przygotować je do eksportu:

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

Ten kod ładuje zawartość HTML do obiektu HtmlDocument i używa XPath do wyszukiwania i wybierania elementu tabeli. Metoda SelectSingleNode zwraca pierwszą znalezioną tabelę w HTML, co ułatwia kierowanie na konkretne tabele, gdy jest ich wiele. Każdy wiersz tabeli jest następnie przetwarzany w celu wyciągnięcia wartości komórki do konwersji.

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

Jak wyeksportować przeanalizowane dane do programu Excel za pomocą IronXL?

Dzięki IronXL możesz przekonwertować przeanalizowane dane z tabeli HTML na profesjonalny arkusz kalkulacyjny Excel z odpowiednim formatowaniem. Poniższy kod pokazuje, jak wyeksportować dane z niestandardowym stylem:

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

Ten kod pokazuje intuicyjny interfejs API IronXL.Excel do manipulacji plikami Excel w języku C#. Tworzy nowy skoroszyt i arkusz, a następnie iteruje przez przeanalizowane nagłówki tabeli HTML, umieszczając je w pierwszym wierszu i stosując pogrubienie oraz zielone tło. Wiersze danych z tabeli HTML są przetwarzane wiersz po wierszu, a treść tekstowa każdej komórki jest wyodrębniana i umieszczana w odpowiedniej komórce arkusza Excel. Funkcja AutoSizeColumn zapewnia, że cała zawartość jest widoczna, a arkusz roboczy jest zapisany jako plik XLSX.

Poniżej można zobaczyć oryginalną tabelę HTML w porównaniu z wynikiem działania powyższego kodu:

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

Jak radzisz sobie z wieloma tabelami i scenariuszami błędów?

Podczas pracy z wieloma tabelami na jednej stronie użyj SelectNodes("//table"), aby pobrać wszystkie tabele i przetworzyć je, tworząc osobny arkusz dla każdej z nich:

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

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

Jak zapisać i wyeksportować plik Excel?

IronXL obsługuje wiele formatów wyjściowych poza XLSX. Możesz zapisać plik w formacie XLS, CSV, TSV lub JSON, w zależności od wymagań dalszego przetwarzania. W ASP.NET Core można również przekierować wynik bezpośrednio do odpowiedzi HTTP, co pozwala uniknąć zapisywania pliku na dysku:

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

Podczas przesyłania strumieniowego do odpowiedzi HTTP, upewnij się, że nagłówek Content-Disposition jest ustawiony na attachment, aby przeglądarka potraktowała odpowiedź jako pobieranie pliku. Ten wzorzec sprawdza się zarówno w kontrolerach MVC, jak i w Razor Pages.

W sytuacjach, gdy konieczne jest wyeksportowanie danych do istniejącego szablonu Excel, IronXL może załadować istniejący skoroszyt i wypełnić nazwane zakresy lub konkretne adresy komórek zanalizowanymi danymi HTML, zachowując całe formatowanie szablonu.

Jakie są najlepsze praktyki dotyczące użytkowania w środowisku produkcyjnym?

Podczas przetwarzania treści z adresu URL lub zapytania do bazy danych w celu dalszej analizy należy uwzględnić dodatkowe szczegóły, takie jak wartości ukrytych pól lub specjalne wymagania dotyczące formatowania. Domyślne ustawienia sprawdzają się dobrze w przypadku standardowych tabel, ale można dostosować rozmiar czcionki, rodzinę czcionek i inne właściwości stylów dla każdej kolumny lub konkretnego wiersza tabeli.

Do odczytywania danych z powrotem z plików Excel po eksporcie, IronXL używa tego samego API WorkBook.Load, co sprawia, że przepływy robocze typu round-trip są proste. Wynikowy plik Excel można również przekonwertować na inne formaty, takie jak JSON lub XML, w celu dalszego przetwarzania.

Jak zarządzasz licencjami i wdrażaniem?

IronXL wymaga klucza licencyjnego do użytku produkcyjnego. Bezpłatna wersja próbna zawiera wszystkie funkcje i jest idealna do oceny biblioteki przed zakupem. Zapoznaj się z opcjami cenowymi i licencyjnymi, aby znaleźć odpowiedni plan dla swojego zespołu.

W przypadku wdrożenia w środowiskach Docker, Azure Functions lub Linux, IronXL nie jest zależny od Microsoft Office ani COM Interop, co sprawia, że zarządzanie zależnościami jest proste. Obsługuje .NET 10, .NET 9, .NET 8, .NET Framework 4.6.2+ i jest w pełni kompatybilny z aktualnymi wzorcami eksportu ASP.NET Core.

Połączenie IronXL i HTML Agility Pack zapewnia elastyczne rozwiązanie do eksportowania tabel HTML do Excela w języku C#. Prezentowane tutaj podejście zapewnia większą kontrolę niż sztywne metody wbudowane, umożliwiając obsługę złożonych struktur HTML przy jednoczesnym wykorzystaniu pełnego zestawu funkcji programu Excel dostępnych w IronXL.

Niezależnie od tego, czy tworzysz narzędzia do scrapingu stron internetowych, migrujesz starsze dane z bazy danych, automatyzujesz generowanie raportów czy przeprowadzasz analizę dużych zbiorów danych, to rozwiązanie można skalować, aby spełnić potrzeby Enterprise. Przykłady kodu pokazują, jak obsługiwać różne źródła danych wejściowych, od statycznych ciągów HTML po treści dynamiczne pobierane za pośrednictwem adresów URL. Wyniki można wyeksportować w celu pobrania lub dalszego przetwarzania w aplikacji .NET.

Chcesz przekształcić swoje dane HTML w profesjonalne pliki Excel? Bezpłatna próba IronXL już dziś i przekonaj się o elastyczności programowej obróbki plików Excel bez konieczności korzystania z pakietu Office.