Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. Exportar tabela HTML para Excel em C#
USANDO O IRONXL

Como exportar uma tabela HTML para o Excel em C# usando o IronXL

Jordi Bardia
Jordi Bardia
Atualizado:

Extrair dados de tabela HTML e convertê-los em uma planilha do Excel é uma exigência comum em aplicativos de negócios -- seja para migração de dados, geração de relatórios ou páginas da web que precisam de uma análise mais aprofundada. Este guia fornece etapas claras para exportar dados de tabelas HTML para o formato Excel usando IronXL e HTML Agility Pack.

Quando você precisar exportar uma tabela HTML para o Excel, entender a relação entre as estruturas da planilha do Excel e as tabelas HTML é essencial. Este guia demonstra como transferir eficientemente dados de tabelas HTML para o formato Excel, criando saídas profissionais de planilhas Excel que mantêm a integridade dos dados.

IronXL oferece uma maneira flexível de converter conteúdo de tabela HTML para uma planilha do Excel, combinando suas poderosas capacidades de manipulação do Excel com parsing HTML para exportar tabelas HTML para Excel em C#. Quer você precise baixar dados de uma URL ou processar conteúdo de um banco de dados, essa solução lida com vários cenários de entrada sem precisar que o Microsoft Office esteja instalado na máquina.

Por que você deve usar IronXL para exportar dados de tabelas HTML?

IronXL se destaca em criar e manipular arquivos Excel sem exigir a instalação do Microsoft Office, tornando-se ideal para ambientes de servidor e aplicativos multiplataforma. Quando emparelhado com HTML Agility Pack, um parser de arquivos HTML e conteúdo capaz, o IronXL torna-se uma solução versátil para converter qualquer estrutura de tabela HTML para dados de planilha Excel. Esta abordagem funciona bem com aplicações .NET 10 e pode manipular conjuntos de dados grandes de forma eficiente.

Ao contrário de bibliotecas como a biblioteca Syncfusion Excel's XlsIO, que oferece uma função ImportHtmlTable limitada a formatos HTML específicos e estruturas de tabela, a abordagem IronXL dá aos desenvolvedores controle total sobre o processo de análise e conversão. Essa flexibilidade significa que os desenvolvedores podem lidar com cenários complexos como tabelas aninhadas, formatação de dados personalizada e extração seletiva de colunas que métodos integrados rígidos não podem acomodar.

IronXL também fornece um conjunto completo de recursos Excel, incluindo suporte a fórmulas, estilização de células, gerenciamento de múltiplas planilhas, e vários formatos de exportação (XLSX, XLS, JSON e CSV). Você pode criar gráficos, exportar para PDF e gerenciar dados de campo ocultos, tornando-se uma solução completa para automação do Excel além da simples conversão de tabela HTML.

Como instalar as bibliotecas necessárias?

Instale tanto o IronXL quanto o HTML Agility Pack através do Gerenciador de Pacotes NuGet. IronXL oferece um teste gratuito para testar todos os recursos antes de adquirir uma licença.

Console do Gerenciador de Pacotes

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

CLI .NET

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

Esses pacotes NuGet permitem que você crie, carregue e salve documentos Excel programaticamente. Após instalar ambos os pacotes, adicione as declarações using necessárias no topo do seu arquivo C#:

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

Essas bibliotecas funcionam bem juntas, com o HTML Agility Pack lidando com o parsing HTML enquanto o IronXL gerencia a criação e manipulação de arquivos Excel. Este exemplo demonstra uma abordagem clara para converter tabelas HTML para o formato XLSX.

Como parsing de dados de tabelas HTML com HTML Agility Pack?

HTML Agility Pack fornece uma maneira direta de navegar em documentos HTML usando expressões XPath. O seguinte código mostra como extrair dados de uma tabela HTML e prepará-los para exportação:

// 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 carrega o conteúdo HTML em um objeto HtmlDocument e usa XPath para consultar e selecionar o elemento da tabela. O método SelectSingleNode retorna a primeira tabela encontrada no HTML, facilitando a segmentação de tabelas específicas quando existem múltiplas. Cada linha da tabela é então processada para extrair o valor da célula para conversão.

Quais expressões XPath funcionam melhor para parsing de tabelas?

Para tabelas HTML padrão, a expressão XPath //table seleciona a primeira tabela no documento. Ao trabalhar com páginas mais complexas contendo várias tabelas, você pode usar seletores posicional, como (//table)[2] para segmentar uma tabela específica pelo seu índice. Seletores baseados em atributos como //table[@id='data-table'] ou //table[@class='products'] também são úteis quando as tabelas têm identificadores significativos.

Quando o HTML vem de um URL ao vivo, você pode carregar o documento diretamente usando a 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']");
$vbLabelText   $csharpLabel

Isso permite que você extraia tabelas diretamente de páginas web públicas sem salvar manualmente o HTML primeiro.

Como Exportar Dados Analisados para Excel Usando IronXL?

Com IronXL, você pode converter os dados da tabela HTML analisada em uma planilha Excel profissional com formatação adequada. O código a seguir demonstra como exportar os dados com formatação personalizada:

// 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 demonstra a API intuitiva do IronXL para manipulação de Excel em C#. Ele cria um novo WorkBook e WorkSheet, depois itera pelos cabeçalhos da tabela HTML analisada, colocando-os na primeira linha enquanto aplica formatação em negrito e uma cor de fundo verde. As linhas de dados da tabela HTML são processadas uma a uma, com o conteúdo de texto de cada célula sendo extraído e colocado na célula correspondente do Excel. A função AutoSizeColumn garante que todo o conteúdo esteja visível e a planilha é salva como um arquivo XLSX.

C# Exportar Tabela HTML para Arquivo Excel com IronXL: Imagem 1 - Saída dos dados da tabela analisada com IronXL

Aqui você pode ver a tabela HTML original comparada à saída do código acima:

C# Exportar Tabela HTML para Arquivo Excel com IronXL: Imagem 2 - Dados do Excel analisados vs. a tabela HTML original

Como Aplicar Formatação de Célula aos Dados Exportados?

Além do básico negrito e cor de fundo mostrado acima, IronXL oferece controle detalhado sobre estilos de célula. Você pode definir o tamanho da fonte, família da fonte, alinhamento de texto, bordas, e formatos numéricos para qualquer célula ou intervalo:

// 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 largura das colunas, AutoSizeColumn lida com a maioria dos casos, mas você também pode definir larguras explícitas usando o método SetColumnWidth quando precisar de um layout preciso. Esses controles de estilo fazem parte da mesma API do IronXL que gerencia estilos de fonte de célula em todo o resto do seu workbook.

Como Lidar com Múltiplas Tabelas e Cenários de Erro?

Ao trabalhar com várias tabelas em uma única página, use SelectNodes("//table") para recuperar todas as tabelas e iterar através delas, criando uma planilha separada para cada:

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

O Que Fazer Quando o HTML Está Malformado?

O HTML do mundo real nem sempre é válido. Páginas raspadas de fontes externas podem ter tags de fechamento ausentes, estruturas inconsistentes tbody ou elementos th e td misturados na linha de cabeçalho. HTML Agility Pack é leniente por design e vai analisar a maior parte do HTML malformado sem lançar exceções, mas seus seletores XPath podem não corresponder ao que você espera.

Um padrão seguro é envolver a lógica de análise em um bloco try-catch e adicionar um fallback que procura por elementos tr diretamente sob a tabela quando nenhum thead é encontrado:

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 lida automaticamente com a detecção do tipo de dados, convertendo strings numéricas em números quando apropriado. Para cenários mais complexos envolvendo conteúdo renderizado por JavaScript, você pode combinar esta abordagem com ferramentas como Selenium WebDriver ou Playwright para primeiro renderizar a página e então passar o HTML resultante para o HTML Agility Pack para análise.

Como Salvar e Exportar o Arquivo Excel?

IronXL suporta múltiplos formatos de saída além de XLSX. Você pode salvar como XLS, CSV, TSV, ou JSON dependendo dos requisitos de downstream. Você também pode transmitir a saída diretamente para uma resposta HTTP no ASP.NET Core, o que evita a escrita de um arquivo no 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

Ao transmitir para uma resposta HTTP, certifique-se de que o cabeçalho Content-Disposition esteja definido como attachment para que o navegador trate a resposta como um download de arquivo. Este padrão funciona bem tanto em controladores MVC quanto em Razor Pages.

Para cenários onde você precisa exportar dados para um template Excel existente, IronXL pode carregar um workbook existente e preencher intervalos nomeados ou endereços de células específicos com os dados HTML analisados, preservando toda a formatação no template.

Quais são as melhores práticas para uso na produção?

Práticas recomendadas ao exportar tabelas HTML para Excel em produção
Preocupação Recomendação Notas
Conjuntos de dados grandes Processar linhas em lotes IronXL lida com milhares de linhas, mas a transmissão da saída evita pressão de memória
HTML Malformado Usar seletores XPath de fallback HTML Agility Pack é leniente; adicione verificações de nulo explícitas em todas as chamadas SelectNodes
Conteúdo Dinâmico Pré-renderizar com Selenium ou Playwright Páginas pesadas em JavaScript requerem um navegador sem cabeça antes da análise HTML
Formato de Arquivo Preferir XLSX sobre XLS XLSX suporta mais linhas, valores de célula maiores e recursos de estilo modernos
Larguras das Colunas Chamar AutoSizeColumn após escrever todos os dados Chamar isso antes de os dados serem escritos subdimensionará as colunas
Licenciamento Definir a chave de licença na inicialização Chamar `IronXl.License.LicenseKey = "...";` antes de qualquer chamada do IronXL

Ao processar conteúdo de uma URL ou consulta de banco de dados para análise posterior, lidar com detalhes adicionais, como valores de campos ocultos ou requisitos especiais de formatação. O comportamento padrão funciona bem para tabelas padrão, mas você pode personalizar o tamanho da fonte, a família de fontes e outras propriedades de estilo para cada coluna ou qualquer linha específica da tabela.

Para ler os dados de volta a partir de arquivos Excel após a exportação, o IronXL utiliza a mesma API WorkBook.Load, tornando os fluxos de trabalho de ida e volta simples. Você também pode converter o arquivo Excel resultante para outros formatos como JSON ou XML para processamento adicional.

Como Você Gerencia Licenciamento e Implantação?

IronXL requer uma chave de licença para uso em produção. A versão de teste gratuita inclui todos os recursos e é ideal para avaliar a biblioteca antes de comprar. Explore as opções de preços e licenciamento para encontrar o nível certo para sua equipe.

Para implantação em Docker, Azure Functions ou ambientes Linux, IronXL não depende do Microsoft Office ou do COM Interop, tornando-o uma dependência fácil de gerenciar. Ele oferece suporte a .NET 10, .NET 9, .NET 8, .NET Framework 4.6.2+ e é totalmente compatível com os atuais padrões de exportação ASP.NET Core.

A combinação de IronXL e HTML Agility Pack fornece uma solução flexível para exportar tabelas HTML para Excel em C#. A abordagem demonstrada aqui oferece mais controle do que os métodos incorporados rígidos, permitindo que você lide com estruturas HTML complexas enquanto aproveita todo o conjunto de recursos do IronXL para Excel.

Se você está construindo raspadores web, migrando dados legados de um banco de dados, automatizando a geração de relatórios ou realizando análise de dados em grandes conjuntos de dados, esta solução se escala para atender às necessidades empresariais. Os exemplos de código mostram como lidar com várias fontes de entrada, de strings HTML estáticas a conteúdo dinâmico recuperado via URL. Os resultados podem ser exportados para download ou para processamento posterior em sua aplicação .NET.

Pronto para transformar seus dados HTML em arquivos Excel profissionais? Comece sua avaliação gratuita do IronXL hoje e experimente a flexibilidade da manipulação programática de Excel sem dependências do Office.

Perguntas frequentes

Qual é o principal objetivo de converter tabelas HTML para Excel em aplicações empresariais?

O objetivo principal é facilitar a migração de dados, a geração de relatórios ou análises adicionais de dados de páginas da web, transformando dados de tabelas HTML em um formato facilmente gerenciável e analisável no Excel.

Qual biblioteca o guia sugere para converter tabelas HTML em Excel usando C#?

O guia sugere o uso do IronXL para converter tabelas HTML em Excel em C#, pois ele oferece uma abordagem flexível sem a necessidade do Microsoft Office.

Por que algumas bibliotecas podem não ser adequadas para converter tabelas HTML em Excel?

Algumas bibliotecas podem não ser adequadas por apresentarem limitações nos formatos de arquivo ou por não possuírem recursos de suporte, o que pode restringir sua eficácia no tratamento de diversas necessidades de conversão de dados.

É necessário o Microsoft Office para usar o IronXL para exportar tabelas HTML para o Excel?

Não, o Microsoft Office não é necessário para usar o IronXL. Ele funciona em várias plataformas e oferece uma solução flexível para exportar tabelas HTML para o Excel.

O IronXL consegue lidar com conversões multiplataforma de tabelas HTML para Excel?

Sim, o IronXL consegue lidar com conversões multiplataforma de tabelas HTML para Excel, tornando-se uma ferramenta versátil para desenvolvedores que trabalham em diferentes ambientes.

Quais são alguns casos de uso comuns para converter tabelas HTML em Excel?

Os casos de uso mais comuns incluem migração de dados, geração de relatórios e análise de dados de páginas da web em um formato mais estruturado e acessível.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Iron Support Team

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