Exportar dados do Excel para um DataTable oferece acesso estruturado e na memória ao conteúdo da planilha, que funciona naturalmente com bancos de dados, controles de interface do usuário e consultas LINQ. A direção inversa -- escrever um DataTable de volta em um arquivo Excel -- é igualmente importante para a geração de relatórios e fluxos de trabalho de armazenamento de dados. O IronXL lida com ambas as direções em .NET puro, sem dependência do Microsoft Office e sem configuração de interoperabilidade COM.
Instale o IronXL antes de executar qualquer um dos exemplos abaixo:
Uma vez instalado, os tipos WorkBook e WorkSheet expõem métodos ToDataTable e ToDataSet que mapeiam diretamente para estruturas System.Data. Você também pode reverter o processo escrevendo valores DataRow de volta em uma planilha e salvando o arquivo no formato XLSX ou XLS.
O método ToDataTable converte uma planilha inteira -- ou um intervalo nomeado -- em um System.Data.DataTable. Passe true para tratar a primeira linha como cabeçalhos de coluna, para que os nomes das colunas da tabela resultante correspondam exatamente aos seus cabeçalhos da planilha.
using IronXL;
using System.Data;
// Load the workbook from disk
WorkBook workbook = WorkBook.Load("customers.xlsx");
// Grab the default (first) worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Convert the entire sheet; first row becomes column headers
DataTable dataTable = worksheet.ToDataTable(true);
// Iterate every row and print each cell value
foreach (DataRow row in dataTable.Rows)
{
for (int i = 0; i < dataTable.Columns.Count; i++)
{
Console.Write(row[i] + "\t");
}
Console.WriteLine();
}Imports IronXL
Imports System.Data
' Load the workbook from disk
Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")
' Grab the default (first) worksheet
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Convert the entire sheet; first row becomes column headers
Dim dataTable As DataTable = worksheet.ToDataTable(True)
' Iterate every row and print each cell value
For Each row As DataRow In dataTable.Rows
For i As Integer = 0 To dataTable.Columns.Count - 1
Console.Write(row(i) & vbTab)
Next
Console.WriteLine()
NextWorkBook.Load lê o arquivo XLSX sem qualquer automação do Office. worksheet.ToDataTable(true) itera cada célula na planilha e a mapeia para um DataRow, usando a primeira linha como nomes DataColumn. O DataTable resultante é um objeto padrão System.Data -- você pode vinculá-lo a um DataGridView, passá-lo a um SqlBulkCopy, ou executar consultas LINQ imediatamente.
A chamada ToDataTable suporta formatos XLS e XLSX, para que o mesmo código funcione para planilhas legadas sem modificação. Consulte a documentação de DataTable e DataSet do IronXL para a referência completa da API.
Quando uma planilha contém várias regiões de dados, ou quando você só precisa de um subconjunto de linhas e colunas, você pode exportar um intervalo de células específico em vez da planilha inteira. Essa abordagem é mais eficiente para arquivos grandes porque o IronXL só processa as células selecionadas.
using IronXL;
using System.Data;
WorkBook workbook = WorkBook.Load("financial_report.xlsx");
// Access a named worksheet
WorkSheet worksheet = workbook.GetWorkSheet("Summary");
// Select only the region A1:D20 and convert it
DataTable dt = worksheet["A1:D20"].ToDataTable(true);
Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}");
foreach (DataRow row in dt.Rows)
{
foreach (var item in row.ItemArray)
{
Console.Write(item + "\t");
}
Console.WriteLine();
}Imports IronXL
Imports System.Data
Dim workbook As WorkBook = WorkBook.Load("financial_report.xlsx")
' Access a named worksheet
Dim worksheet As WorkSheet = workbook.GetWorkSheet("Summary")
' Select only the region A1:D20 and convert it
Dim dt As DataTable = worksheet("A1:D20").ToDataTable(True)
Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}")
For Each row As DataRow In dt.Rows
For Each item In row.ItemArray
Console.Write(item & vbTab)
Next
Console.WriteLine()
NextA sintaxe de colchetes worksheet["A1:D20"] retorna um objeto IronXL.Range. Chamar ToDataTable nesse intervalo limita o processamento exatamente a essas células, o que significa uma execução mais rápida e um menor uso de memória quando o arquivo de origem possui dezenas de milhares de linhas.
Você também pode especificar intervalos nomeados ou construir a string do intervalo dinamicamente em tempo de execução -- por exemplo, $"A1:D{lastRow}" -- tornando a abordagem flexível para exportações de dados de comprimento variável. A referência da API da classe Range documenta todos os métodos de seleção e consulta disponíveis.
Livros com várias folhas mapeiam naturalmente para System.Data.DataSet, onde cada folha se torna um DataTable separado. O método ToDataSet realiza essa conversão em uma única chamada.
using IronXL;
using System.Data;
WorkBook workbook = WorkBook.Load("multi_sheet.xlsx");
// Each worksheet becomes a DataTable inside the DataSet
DataSet dataSet = workbook.ToDataSet();
foreach (DataTable table in dataSet.Tables)
{
Console.WriteLine($"Sheet: {table.TableName}");
Console.WriteLine($"Rows: {table.Rows.Count}");
Console.WriteLine();
}Imports IronXL
Imports System.Data
Dim workbook As WorkBook = WorkBook.Load("multi_sheet.xlsx")
' Each worksheet becomes a DataTable inside the DataSet
Dim dataSet As DataSet = workbook.ToDataSet()
For Each table As DataTable In dataSet.Tables
Console.WriteLine($"Sheet: {table.TableName}")
Console.WriteLine($"Rows: {table.Rows.Count}")
Console.WriteLine()
NextCada DataTable no DataSet retornado usa o nome da planilha original como sua propriedade TableName, para que você possa recuperar uma folha específica com dataSet.Tables["Summary"] em vez de iterar a coleção. Isso torna simples construir lógica de relatórios com múltiplas planilhas ou combinar dados de várias planilhas antes de escrever os resultados em um banco de dados.
Para mais maneiras de trabalhar com múltiplas planilhas e navegar na estrutura de livros, veja como abrir e gerenciar planilhas do Excel.
A direção de importação para DataTable é apenas metade da história. Quando você precisa gravar dados estruturados de volta como uma planilha -- para relatórios, downloads ou arquivamento -- você cria um novo livro, preenche células a partir do DataTable e salva.
using IronXL;
using System.Data;
// Build a sample DataTable
DataTable dt = new DataTable();
dt.Columns.Add(new DataColumn("ProductID", typeof(int)));
dt.Columns.Add(new DataColumn("ProductName", typeof(string)));
dt.Columns.Add(new DataColumn("UnitPrice", typeof(decimal)));
dt.Rows.Add(1, "Widget Pro", 29.99m);
dt.Rows.Add(2, "Gadget Max", 49.99m);
dt.Rows.Add(3, "Sensor Kit", 14.50m);
// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create();
WorkSheet worksheet = workbook.CreateWorkSheet("Products");
// Write column headers from DataTable.Columns
for (int col = 0; col < dt.Columns.Count; col++)
{
worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
worksheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
}
}
// Save as XLSX
workbook.SaveAs("products_export.xlsx");
Console.WriteLine("Export complete.");Imports IronXL
Imports System.Data
' Build a sample DataTable
Dim dt As New DataTable()
dt.Columns.Add(New DataColumn("ProductID", GetType(Integer)))
dt.Columns.Add(New DataColumn("ProductName", GetType(String)))
dt.Columns.Add(New DataColumn("UnitPrice", GetType(Decimal)))
dt.Rows.Add(1, "Widget Pro", 29.99D)
dt.Rows.Add(2, "Gadget Max", 49.99D)
dt.Rows.Add(3, "Sensor Kit", 14.50D)
' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create()
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")
' Write column headers from DataTable.Columns
For col As Integer = 0 To dt.Columns.Count - 1
worksheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
' Write data rows
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
worksheet.SetCellValue(row + 1, col, dt.Rows(row)(col))
Next
Next
' Save as XLSX
workbook.SaveAs("products_export.xlsx")
Console.WriteLine("Export complete.")SetCellValue(rowIndex, columnIndex, value) aceita valores object, então você passa os nomes das colunas para a linha de cabeçalho e valores de células brutos para as linhas de dados sem qualquer conversão de tipo. O deslocamento de linha do row + 1 reserva a linha 0 para cabeçalhos. O arquivo XLSX resultante é uma planilha totalmente válida -- sem espaços reservados, sem arquivos temporários.
Para DataTables maiores, considere aplicar redimensionamento automático de colunas após a escrita dos dados para que o conteúdo seja exibido de forma clara sem formatação manual.
Um dos motivos mais comuns para exportar uma planilha do Excel para um DataTable é exibi-la em um DataGridView do Windows Forms. Depois que você tem um DataTable, a vinculação é uma única linha de código.
using IronXL;
using System.Data;
using System.Windows.Forms;
WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
DataTable dataTable = worksheet.ToDataTable(true);
// Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTable;Imports IronXL
Imports System.Data
Imports System.Windows.Forms
Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
Dim dataTable As DataTable = worksheet.ToDataTable(True)
' Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTableConfigurar DataSource aciona o DataGridView para ler nomes de colunas e dados de linhas do DataTable. Cada DataColumn se torna uma coluna da grade, e cada DataRow se torna uma linha visível. Você pode aplicar comportamento de ordenação, filtragem e seleção através dos controles embutidos da grade sem qualquer código adicional.
Este padrão funciona igualmente bem com DataGrid do WPF, GridView do ASP.NET, e qualquer outra infraestrutura de vinculação de dados do .NET. Para um guia passo a passo, veja como exportar um DataGridView para Excel para a direção reversa.
Depois de converter uma planilha em um DataTable, você pode executar consultas LINQ usando o método de extensão AsEnumerable(), que transforma cada DataRow em um elemento consultável.
using IronXL;
using System.Data;
using System.Linq;
WorkBook workbook = WorkBook.Load("sales.xlsx");
DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);
// Filter rows where the "Revenue" column exceeds 10000
var highRevenue = dt.AsEnumerable()
.Where(row => row.Field<double>("Revenue") > 10000)
.OrderByDescending(row => row.Field<double>("Revenue"))
.ToList();
Console.WriteLine($"High-revenue records: {highRevenue.Count}");
foreach (var row in highRevenue)
{
Console.WriteLine($"{row["Product"]}: {row["Revenue"]:C}");
}Imports IronXL
Imports System.Data
Imports System.Linq
Dim workbook As WorkBook = WorkBook.Load("sales.xlsx")
Dim dt As DataTable = workbook.DefaultWorkSheet.ToDataTable(True)
' Filter rows where the "Revenue" column exceeds 10000
Dim highRevenue = dt.AsEnumerable() _
.Where(Function(row) row.Field(Of Double)("Revenue") > 10000) _
.OrderByDescending(Function(row) row.Field(Of Double)("Revenue")) _
.ToList()
Console.WriteLine($"High-revenue records: {highRevenue.Count}")
For Each row In highRevenue
Console.WriteLine($"{row("Product")}: {row("Revenue"):C}")
NextAs consultas LINQ fornecem uma maneira legível e fortemente tipada de filtrar, ordenar, agrupar e projetar dados de uma planilha convertida. row.Field<t>(columnName) lida com coerção de tipo de forma clara, lançando um InvalidCastException se um valor não puder ser convertido, ao invés de retornar um nulo silencioso. Isso torna mais fácil capturar problemas de qualidade de dados cedo.
Combine esta abordagem com a exportação baseada em intervalo da seção anterior para consultar regiões específicas da planilha em vez de planilhas completas, mantendo o uso de memória baixo para arquivos grandes.
Planilhas do Excel frequentemente têm lacunas -- células vazias, regiões mescladas ou texto de espaço reservado. IronXL mapeia células vazias para DBNull.Value no DataTable exportado, correspondendo ao comportamento padrão do ADO.NET para que seu código existente de tratamento de nulos funcione sem modificação.
| Estado da célula do Excel | Valor do DataTable | Notas |
|---|---|---|
| Valor de texto | Corda | Retornado como está |
| Valor numérico | Duplo ou Decimal | Depende do formato da célula |
| Valor de data | Data e hora | Analisado a partir do número de série |
| Valor booleano | Booleano | VERDADEIRO/FALSO no Excel |
| Célula vazia | DBNull.Value | Null padrão do ADO.NET |
| Célula de fórmula | Resultado calculado | O IronXL avalia a fórmula primeiro |
Ao escrever um DataTable de volta para o Excel, campos DBNull.Value produzem células vazias, preservando a fidelidade de ida e volta. Se você precisar de uma string padrão para campos nulos, substitua DBNull.Value pelo seu espaço reservado antes de chamar SetCellValue.
Para mais orientações sobre preparação de dados, a documentação da classe DataTable da Microsoft cobre o tratamento de nulos, gerenciamento de restrições e estados de linhas em detalhes.
Para planilhas com muitos milhares de linhas, exportar a planilha inteira de uma vez aloca todos os dados na memória simultaneamente. Dois padrões IronXL reduzem o uso máximo de memória:
worksheet["A1:D5000"].ToDataTable(true) para processar uma região delimitada em vez da planilha inteira.worksheet.RowCount, depois faça um loop sobre intervalos de tamanho fixo -- por exemplo, 1.000 linhas de cada vez -- e processe cada lote antes de passar para o próximo.As propriedades worksheet.RowCount e worksheet.ColumnCount permitem que você construa strings de intervalo dinâmicas sem codificar dimensões:
using IronXL;
using System.Data;
WorkBook workbook = WorkBook.Load("large_dataset.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
int batchSize = 1000;
int totalRows = worksheet.RowCount;
for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
int endRow = Math.Min(startRow + batchSize - 1, totalRows);
string rangeAddress = $"A{startRow}:Z{endRow}";
DataTable batch = worksheet[rangeAddress].ToDataTable(false);
// Process each batch -- write to database, transform, etc.
Console.WriteLine($"Processed rows {startRow} to {endRow}");
}Imports IronXL
Imports System.Data
Dim workbook As WorkBook = WorkBook.Load("large_dataset.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
Dim batchSize As Integer = 1000
Dim totalRows As Integer = worksheet.RowCount
For startRow As Integer = 1 To totalRows Step batchSize
Dim endRow As Integer = Math.Min(startRow + batchSize - 1, totalRows)
Dim rangeAddress As String = $"A{startRow}:Z{endRow}"
Dim batch As DataTable = worksheet(rangeAddress).ToDataTable(False)
' Process each batch -- write to database, transform, etc.
Console.WriteLine($"Processed rows {startRow} to {endRow}")
NextEste padrão é particularmente relevante para ler grandes arquivos Excel em C# onde há restrições de memória.
Depois que você tem um DataTable, inseri-lo no SQL Server via SqlBulkCopy é o caminho mais rápido para grandes conjuntos de dados. SqlBulkCopy aceita um DataTable diretamente e transmite linhas em lotes sem construir declarações INSERT individuais.
using IronXL;
using System.Data;
using Microsoft.Data.SqlClient;
WorkBook workbook = WorkBook.Load("orders.xlsx");
DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);
string connectionString = "Server=.;Database=OrdersDB;Trusted_Connection=True;";
using SqlConnection connection = new(connectionString);
connection.Open();
using SqlBulkCopy bulkCopy = new(connection);
bulkCopy.DestinationTableName = "dbo.Orders";
bulkCopy.BatchSize = 500;
bulkCopy.BulkCopyTimeout = 60;
// Map DataTable columns to database columns
bulkCopy.ColumnMappings.Add("OrderID", "OrderID");
bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName");
bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount");
bulkCopy.WriteToServer(dataTable);
Console.WriteLine("Bulk insert complete.");Imports IronXL
Imports System.Data
Imports Microsoft.Data.SqlClient
Dim workbook As WorkBook = WorkBook.Load("orders.xlsx")
Dim dataTable As DataTable = workbook.DefaultWorkSheet.ToDataTable(True)
Dim connectionString As String = "Server=.;Database=OrdersDB;Trusted_Connection=True;"
Using connection As New SqlConnection(connectionString)
connection.Open()
Using bulkCopy As New SqlBulkCopy(connection)
bulkCopy.DestinationTableName = "dbo.Orders"
bulkCopy.BatchSize = 500
bulkCopy.BulkCopyTimeout = 60
' Map DataTable columns to database columns
bulkCopy.ColumnMappings.Add("OrderID", "OrderID")
bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName")
bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount")
bulkCopy.WriteToServer(dataTable)
End Using
End Using
Console.WriteLine("Bulk insert complete.")A coleção ColumnMappings corresponde aos nomes de colunas DataTable aos nomes de colunas do banco de dados. Se os nomes forem idênticos, você pode omitir mapeamentos individuais e SqlBulkCopy fará a correspondência automática pelo nome. Mapeamentos explícitos são mais seguros quando a ordem das colunas da planilha difere do esquema do banco de dados.
Para mais sobre a combinação do IronXL com fluxos de trabalho de banco de dados, o guia de importação do Excel em C# cobre cenários adicionais de importação, incluindo validação antes da inserção.
Para projetos baseados no Entity Framework, converta suas linhas DataTable em objetos de modelo tipados primeiro, depois use DbContext.BulkInsert de uma biblioteca como EFCore.BulkExtensions para inserção em lote compatível com ORM. A documentação do SqlBulkCopy da Microsoft explica opções de agrupamento e suporte a transações em detalhes.
Agora você tem um kit de ferramentas completo para mover dados entre Excel e DataTable em ambas as direções usando IronXL:
worksheet.ToDataTable(true) para exportações com reconhecimento de cabeçalhoworksheet["A1:D20"].ToDataTable(true)workbook.ToDataSet() para acesso completo DataSetDataTable de volta para XLSX ao iterar valores DataRow com SetCellValueDataTable a controles de interface do usuário como DataGridView com uma única atribuição DataSourceSqlBulkCopy diretamente de um DataTable para inserções de banco de dados de alta taxa de transferênciaPara aprofundar suas habilidades em IronXL, explore estes tópicos relacionados:
Comece com uma licença de teste gratuita do IronXL para executar esses exemplos em seus próprios projetos. Quando estiver pronto para implantar, compre uma licença de produção ou converse com a equipe para orientação de licenciamento.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronXL faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
A API do Excel que você precisa, sem as complicações do Office Interop.
