Ícono de mensaje
Saltar al pie de página
  1. IronXL
  2. Blog de IronXL
  3. Usando IronXL
  4. C# Exportar Tabla HTML a Excel
USANDO IRONXL

Cómo exportar una tabla HTML a Excel en C# usando IronXL

Jordi Bardia
Jordi Bardia
Actualizado:

Extraer datos de una tabla HTML y convertirlos a una hoja de Excel es un requisito común en las aplicaciones comerciales, ya sea para la migración de datos, la generación de informes o páginas web que necesitan un análisis más profundo. Esta guía proporciona pasos claros para exportar datos de tablas HTML a formato Excel utilizando IronXL y HTML Agility Pack .

Cuando necesita exportar una tabla HTML a Excel, es esencial comprender la relación entre las estructuras de las hojas de cálculo de Excel y las tablas HTML. Esta guía muestra cómo transferir eficazmente datos de tablas HTML a formato Excel, creando hojas de cálculo Excel profesionales que mantienen la integridad de los datos.

IronXL proporciona una forma flexible de convertir el contenido de una tabla HTML en una hoja de cálculo de Excel, combinando sus potentes capacidades de manipulación de Excel con el análisis de HTML para exportar una tabla HTML a Excel en C#. Ya sea que necesite descargar datos de una URL o procesar contenido de una base de datos, esta solución maneja varios escenarios de entrada sin necesidad de tener instalado Microsoft Office en la máquina.

¿Por qué debería utilizar IronXL para exportar datos de tablas HTML?

IronXL se destaca en la creación y manipulación de archivos Excel sin necesidad de instalar Microsoft Office , lo que lo hace ideal para entornos de servidor y aplicaciones multiplataforma. Cuando se combina con HTML Agility Pack , un analizador de contenido y archivos HTML capaz, IronXL se convierte en una solución versátil para convertir cualquier estructura de tabla HTML en datos de hojas de Excel. Este enfoque funciona bien con aplicaciones .NET 10 y puede manejar grandes conjuntos de datos de manera eficiente.

A diferencia de bibliotecas como XlsIO de la biblioteca Excel de Syncfusion, que ofrece una función ImportHtmlTable limitada a formatos HTML y estructuras de tabla específicos, el enfoque IronXL brinda a los desarrolladores control total sobre el proceso de análisis y conversión. Esta flexibilidad significa que los desarrolladores pueden manejar escenarios complejos como tablas anidadas, formato de datos personalizado y extracción selectiva de columnas que los métodos rígidos incorporados no pueden acomodar.

IronXL también ofrece un conjunto completo de funciones de Excel, que incluyen compatibilidad con fórmulas , estilo de celdas , administración de múltiples hojas de trabajo y varios formatos de exportación (XLSX, XLS, JSON y CSV). Puede crear gráficos, exportar a PDF y administrar datos de campos ocultos, lo que lo convierte en una solución completa para la automatización de Excel más allá de la simple conversión de tablas HTML.

¿Cómo instalar las bibliotecas necesarias?

Instale IronXL y HTML Agility Pack a través del Administrador de paquetes NuGet . IronXL ofrece una prueba gratuita para probar todas las funciones antes de comprometerse con una licencia.

Consola del administrador de paquetes

Install-Package IronXl.Excel
Install-Package HtmlAgilityPack
Install-Package IronXl.Excel
Install-Package HtmlAgilityPack
SHELL

CLI de .NET

dotnet add package IronXl.Excel
dotnet add package HtmlAgilityPack
dotnet add package IronXl.Excel
dotnet add package HtmlAgilityPack
SHELL

Estos paquetes NuGet le permiten crear, cargar y guardar documentos Excel programáticamente. Después de instalar ambos paquetes, agregue las declaraciones using necesarias en la parte superior de su archivo C#:

using IronXL;
using HtmlAgilityPack;
using System;
using System.Linq;
using IronXL;
using HtmlAgilityPack;
using System;
using System.Linq;
$vbLabelText   $csharpLabel

Estas bibliotecas funcionan bien juntas: HTML Agility Pack se encarga del análisis de HTML mientras que IronXL administra la creación y manipulación de archivos Excel. Este ejemplo demuestra un enfoque claro para convertir tablas HTML al formato XLSX.

¿Cómo analizar datos de tablas HTML con HTML Agility Pack?

HTML Agility Pack proporciona una forma sencilla de navegar por documentos HTML utilizando expresiones XPath. El siguiente código muestra cómo extraer datos de una tabla HTML y prepararlos para exportar:

// 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");
$vbLabelText   $csharpLabel

Este código carga el contenido HTML en un objeto HtmlDocument y utiliza XPath para consultar y seleccionar el elemento de la tabla. El método SelectSingleNode devuelve la primera tabla encontrada en el HTML, lo que facilita la identificación de tablas específicas cuando existen varias. Cada fila de la tabla se procesa para extraer el valor de la celda para la conversión.

¿Qué expresiones XPath funcionan mejor para el análisis de tablas?

Para las tablas HTML estándar, la expresión XPath //table selecciona la primera tabla del documento. Al trabajar con páginas más complejas que contienen varias tablas, puede utilizar selectores posicionales como (//table)[2] para apuntar a una tabla específica por su índice. Los selectores basados ​​en atributos como //table[@id='data-table'] o //table[@class='products'] también son útiles cuando las tablas llevan identificadores significativos.

Cuando el HTML proviene de una URL activa, puedes cargar el documento directamente usando la clase 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']");
$vbLabelText   $csharpLabel

Esto le permite extraer tablas directamente de páginas web públicas sin tener que guardar manualmente primero el HTML.

¿Cómo exportar datos analizados a Excel usando IronXL?

Con IronXL, puede convertir los datos de la tabla HTML analizados en una hoja de cálculo de Excel profesional con el formato adecuado. El siguiente código demuestra cómo exportar los datos con un estilo personalizado:

// 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");
$vbLabelText   $csharpLabel

Este código demuestra la API intuitiva para la manipulación de Excel en C# con IronXL. Crea un nuevo WorkBook y WorkSheet , luego itera a través de los encabezados de tabla HTML analizados, colocándolos en la primera fila mientras aplica formato en negrita y un color de fondo verde. Las filas de datos de la tabla HTML se procesan fila por fila, y el contenido de texto de cada celda se extrae y se coloca en la celda de Excel correspondiente. La función AutoSizeColumn garantiza que todo el contenido sea visible y que el libro se guarde como un archivo XLSX.

C# Exportar tabla HTML a archivo Excel con IronXL: Imagen 1 - Salida de datos de la tabla analizada por IronXL

Aquí puedes ver la tabla HTML original comparada con la salida del código anterior:

C# Exportar tabla HTML a archivo Excel con IronXL: Imagen 2 - Datos de Excel analizados vs. la tabla HTML original

¿Cómo se aplica el formato de celda a los datos exportados?

Más allá del color básico en negrita y de fondo que se muestra arriba, IronXL le brinda un control preciso sobre el estilo de las celdas . Puede configurar el tamaño de fuente, la familia de fuentes, la alineación del texto, los bordes y los formatos de números para cualquier celda o rango:

// 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
$vbLabelText   $csharpLabel

Para los anchos de columna, AutoSizeColumn maneja la mayoría de los casos, pero también puede establecer anchos explícitos usando el método SetColumnWidth cuando necesite un diseño preciso. Estos controles de estilo son parte de la misma API IronXL que maneja los estilos de fuente de celda en el resto de su libro de trabajo.

¿Cómo manejar múltiples tablas y escenarios de error?

Al trabajar con varias tablas en una sola página, utilice SelectNodes("//table") para recuperar todas las tablas e iterarlas, creando una hoja de trabajo separada para cada una:

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");
$vbLabelText   $csharpLabel

¿Qué debe hacer cuando el HTML está mal formado?

El HTML del mundo real no siempre es válido. Las páginas extraídas de fuentes externas pueden tener etiquetas de cierre faltantes, estructuras tbody inconsistentes o elementos th y td mixtos en la fila del encabezado. HTML Agility Pack es indulgente por diseño y analizará la mayoría del HTML malformado sin generar excepciones, pero sus selectores XPath pueden no coincidir con lo que espera.

Un patrón seguro es envolver la lógica de análisis en un bloque try-catch y agregar una alternativa que busque elementos tr directamente debajo de la tabla cuando no se encuentra ningún 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}");
}
$vbLabelText   $csharpLabel

IronXL maneja automáticamente la detección de tipos de datos, convirtiendo cadenas numéricas a números cuando es apropiado. Para escenarios más complejos que involucran contenido renderizado en JavaScript, puede combinar este enfoque con herramientas como Selenium WebDriver o Playwright para primero renderizar la página y luego pasar el HTML resultante a HTML Agility Pack para su análisis.

¿Cómo guardar y exportar el archivo Excel?

IronXL admite múltiples formatos de salida más allá de XLSX. Puede guardarlo como XLS, CSV, TSV o JSON según los requisitos posteriores. También puede transmitir la salida directamente a una respuesta HTTP en ASP.NET Core, lo que evita escribir un archivo en el disco:

// 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());
$vbLabelText   $csharpLabel

Al transmitir una respuesta HTTP, asegúrese de que el encabezado Content-Disposition esté configurado en attachment para que el navegador trate la respuesta como una descarga de archivo. Este patrón funciona bien tanto en controladores MVC como en Razor Pages.

Para los escenarios en los que necesita exportar datos a una plantilla de Excel existente , IronXL puede cargar un libro existente y completar rangos con nombre o direcciones de celdas específicas con los datos HTML analizados, conservando todo el formato de la plantilla.

¿Cuáles son las mejores prácticas para el uso en producción?

Prácticas recomendadas al exportar tablas HTML a Excel en producción
Inquietud Recomendación Notas
Grandes conjuntos de datos Procesar filas en lotes IronXL maneja miles de filas, pero la salida en streaming evita la presión de la memoria
HTML mal formado Utilice selectores XPath de respaldo HTML Agility Pack es indulgente; agrega comprobaciones nulas explícitas en todas las llamadas SelectNodes
Contenido dinámico Pre-renderizado con Selenium o Playwright Las páginas con mucho JavaScript requieren un navegador sin interfaz gráfica antes del análisis HTML
Formato de archivo Prefiero XLSX sobre XLS XLSX admite más filas, valores de celda más grandes y funciones de estilo modernas
Anchos de columna Llamar a AutoSizeColumn después de escribir todos los datos Llamarlo antes de que se escriban los datos reducirá el tamaño de las columnas.
Licencias Establecer la clave de licencia al inicio Llama `IronXl.License.LicenseKey = "...";` antes de cualquier llamada a IronXL

Al procesar contenido de una URL o una consulta de base de datos para un análisis posterior, gestione detalles adicionales como valores de campos ocultos o requisitos de formato especiales. El comportamiento predeterminado funciona bien para las tablas estándar, pero puede personalizar el tamaño de fuente, la familia de fuentes y otras propiedades de estilo para cada columna o cualquier fila de tabla específica.

Para volver a leer datos de archivos Excel después de la exportación, IronXL utiliza la misma API WorkBook.Load, lo que hace que los flujos de trabajo de ida y vuelta sean sencillos. También puede convertir el archivo Excel resultante a otros formatos como JSON o XML para su posterior procesamiento.

¿Cómo se gestionan las licencias y la implementación?

IronXL requiere una clave de licencia para uso en producción. La prueba gratuita incluye todas las funciones y es ideal para evaluar la biblioteca antes de comprarla. Explore las opciones de precios y licencias para encontrar el nivel adecuado para su equipo.

Para la implementación en entornos Docker, Azure Functions o Linux, IronXL no depende de Microsoft Office ni de COM Interop, lo que lo convierte en una dependencia sencilla de administrar. Es compatible con .NET 10 , .NET 9, .NET 8, .NET Framework 4.6.2+ y es totalmente compatible con los patrones de exportación actuales de ASP.NET Core .

La combinación de IronXL y HTML Agility Pack proporciona una solución flexible para exportar tablas HTML a Excel en C#. El enfoque demostrado aquí ofrece más control que los métodos integrados rígidos, lo que le permite manejar estructuras HTML complejas mientras aprovecha el conjunto completo de funciones de Excel de IronXL.

Ya sea que esté creando raspadores web, migrando datos heredados de una base de datos, automatizando la generación de informes o realizando análisis de datos en grandes conjuntos de datos, esta solución se escala para satisfacer las necesidades empresariales. Los ejemplos de código muestran cómo manejar varias fuentes de entrada, desde cadenas HTML estáticas hasta contenido dinámico recuperado a través de URL. Los resultados se pueden exportar para su descarga o procesamiento posterior en su aplicación .NET .

¿Está listo para transformar sus datos HTML en archivos profesionales de Excel? Comience hoy su prueba gratuita de IronXL y experimente la flexibilidad de la manipulación programática de Excel sin dependencias de Office.

Preguntas Frecuentes

¿Cuál es el principal objetivo de la conversión de tablas HTML a Excel en las aplicaciones empresariales?

El objetivo principal es facilitar la migración de datos, la generación de informes o el análisis posterior de datos de páginas web mediante la transformación de datos de tablas HTML a un formato que sea fácilmente manejable y analizable en Excel.

¿Qué biblioteca sugiere la guía para convertir tablas HTML a Excel en C#?

La guía sugiere el uso de IronXL para convertir tablas HTML a Excel en C#, ya que proporciona un enfoque flexible sin necesidad de Microsoft Office.

¿Por qué algunas bibliotecas no son adecuadas para convertir tablas HTML a Excel?

Algunas bibliotecas pueden no ser adecuadas porque tienen limitaciones en los formatos de archivo o carecen de funciones de apoyo, lo que puede restringir su eficacia en el manejo de diversas necesidades de conversión de datos.

¿Es necesario Microsoft Office para utilizar IronXL para exportar tablas HTML a Excel?

No, Microsoft Office no es necesario para utilizar IronXL. Funciona en varias plataformas y ofrece una solución flexible para exportar tablas HTML a Excel.

¿Puede IronXL manejar conversiones multiplataforma de tablas HTML a Excel?

Sí, IronXL puede manejar conversiones multiplataforma de tablas HTML a Excel, lo que lo convierte en una herramienta versátil para desarrolladores que trabajan en diferentes entornos.

¿Cuáles son los casos de uso más comunes para convertir tablas HTML a Excel?

Los casos de uso comunes incluyen la migración de datos, la generación de informes y el análisis de datos de páginas web en un formato más estructurado y accesible.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me