Pobieranie danych z tabel HTML i konwersja ich do arkusza Excel jest częstym wymaganiem w aplikacjach biznesowych — czy to w celu migracji danych, generowania raportów, czy też w przypadku stron internetowych wymagających dalszej analizy. Ten przewodnik zawiera jasne instrukcje dotyczące eksportowania danych z tabel HTML do formatu Excel przy użyciu IronXL i HTML Agility Pack.

Jeśli chcesz wyeksportować tabelę HTML do Excela, kluczowe znaczenie ma zrozumienie relacji między strukturą arkuszy Excela a tabelami HTML. W niniejszym przewodniku pokazano, jak efektywnie przenosić dane z tabel HTML do formatu Excel, tworząc profesjonalne arkusze kalkulacyjne, które zachowują integralność danych.

IronXL zapewnia elastyczny sposób konwersji zawartości tabel HTML na arkusz kalkulacyjny Excel, łącząc swoje potężne możliwości manipulacji danymi Excel z parsowaniem HTML w celu eksportowania tabel HTML do Excela w języku C#. Niezależnie od tego, czy chcesz pobrać dane z adresu URL, czy przetworzyć zawartość z bazy danych, to rozwiązanie obsługuje różne scenariusze wejściowe bez konieczności instalowania pakietu Microsoft Office na komputerze.

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.

Konsola menedżera pakietów

Install-Package IronXL.Excel

.NET CLI

dotnet add package IronXL.Excel

Te pakiety NuGet umożliwiają programowe tworzenie, wczytywanie i zapisywanie dokumentów Excel. Po zainstalowaniu obu pakietów, dodaj niezbędne instrukcje using na początku pliku 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

Biblioteki te dobrze ze sobą współpracują: HTML Agility Pack zajmuje się parsowaniem kodu HTML, a biblioteka IronXL tworzeniem i edycją plików Excel. Ten przykład pokazuje jasne podejście do konwersji tabel HTML do formatu XLSX.

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

' 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.

Jakie wyrażenia XPath najlepiej sprawdzają się podczas analizowania tabel?

Dla standardowych tabel HTML, wyrażenie XPath //table wybiera pierwszą tabelę w dokumencie. Podczas pracy ze skomplikowanymi stronami zawierającymi wiele tabel, można używać selektorów pozycyjnych, takich jak (//table)[2], aby kierować się na konkretną tabelę według jej indeksu. Selektory oparte na atrybutach, takie jak //table[@id='data-table'] lub //table[@class='products'], są również przydatne, gdy tabele posiadają znaczące identyfikatory.

Gdy HTML pochodzi z aktywnego URL-a, można załadować dokument bezpośrednio za pomocą klasy 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']")

Pozwala to na pobieranie tabel bezpośrednio z publicznych stron internetowych bez konieczności ręcznego zapisywania kodu HTML.

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

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:

Jak zastosować formatowanie komórek do wyeksportowanych danych?

Oprócz podstawowych opcji pogrubienia i koloru tła pokazanych powyżej, IronXL zapewnia precyzyjną kontrolę nad stylem komórek. Możesz ustawić rozmiar czcionki, rodzinę czcionek, wyrównanie tekstu, obramowania i formaty liczb dla dowolnej komórki lub zakresu:

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

Dla szerokości kolumn AutoSizeColumn radzi sobie w większości przypadków, ale można także ustawić explicite szerokości przy użyciu metody SetColumnWidth, gdy potrzebne jest precyzyjne rozmieszczenie. Te elementy sterujące stylem są częścią tego samego interfejsu API IronXL, który obsługuje style czcionek komórek w pozostałej części skoroszytu.

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

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

Co należy zrobić, gdy kod HTML jest nieprawidłowy?

Rzeczywisty kod HTML nie zawsze jest poprawny. Strony skanowane ze źródeł zewnętrznych mogą mieć brakujące tagi zamykające, niespójne struktury tbody, lub mieszane elementy th i td w wierszu nagłówka. HTML Agility Pack jest z założenia tolerancyjny i analizuje większość nieprawidłowo sformułowanego kodu HTML bez zgłaszania wyjątków, ale selektory XPath mogą nie odpowiadać oczekiwaniom użytkownika.

Bezpiecznym wzorcem jest opakowanie logiki parsowania w blok try-catch i dodanie opcji zapasowej, która wyszukuje elementy tr bezpośrednio pod tabelą, gdy nie zostanie znaleziony thead:

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 automatycznie obsługuje wykrywanie typów danych, konwertując ciągi numeryczne na liczby w odpowiednich przypadkach. W przypadku bardziej złożonych scenariuszy obejmujących treści renderowane w JavaScript można połączyć to podejście z narzędziami takimi jak Selenium WebDriver lub Playwright, aby najpierw wyrenderować stronę, a następnie przekazać wynikowy kod HTML do HTML Agility Pack w celu parsowania.

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

' 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.