Ícone de mensagem
Ir para o conteúdo do rodapé
  1. Iron Software
  2. Blog IronXL
  3. Usando o IronXL
  4. Exportação de conjunto de dados para Excel
USANDO O IRONXL

Exportar conjunto de dados para o Excel em C# usando IronXL | Sem necessidade do Office

Jordi Bardia
Jordi Bardia
Atualizado:

Exportar um DataSet ou DataTable para Excel em C# oferece uma maneira confiável de transformar dados estruturados em memória em arquivos de planilhas profissionais -- sem depender do Microsoft Office instalado na máquina de destino. Quer você recupere registros de um banco de dados SQL, construa um DataSet programaticamente ou trabalhe com um DataGrid existente, IronXL lida com todo o fluxo através de uma API limpa e orientada a código. Este guia percorre todos os cenários principais -- desde a exportação de uma tabela única até livros com múltiplas folhas e resultados de consultas de banco de dados ao vivo -- usando instruções de C# de nível superior e .NET 10.

Instale o IronXL uma vez, escreva algumas linhas de código, e seus dados estarão em um arquivo XLSX sem uma única dependência do Office. As seções abaixo cobrem instalação, padrões principais, formatação avançada e integração de banco de dados de uma forma que você pode copiar e colar diretamente em seus próprios projetos.

Como Instalar o IronXL para Exportação de Excel?

Antes de escrever qualquer código de exportação, adicione o IronXL ao seu projeto através do Gerenciador de Pacotes NuGet. Abra um terminal na raiz do seu projeto e execute o comando CLI do .NET ou use o Console do Gerenciador de Pacotes no Visual Studio com o comando Install-Package:

dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
SHELL

Após a instalação, adicione uma instrução using de nível superior para importar o namespace IronXL:

using IronXL;
using System.Data;
using IronXL;
using System.Data;
$vbLabelText   $csharpLabel

IronXL é direcionado a .NET 8, .NET 9, e .NET 10, bem como versões mais antigas do .NET Framework (4.6.2+). Nenhuma instalação do Office é necessária em qualquer máquina -- servidor, desktop ou nuvem. Uma vez que o pacote está instalado, você pode criar, ler e escrever arquivos XLSX, XLS, e CSV inteiramente em código gerenciado.

Para opções detalhadas de instalação, veja o guia de instalação do IronXL e a página do pacote NuGet para histórico de versões.

Como Exportar uma Única DataTable para um Arquivo Excel?

O cenário mais comum é exportar um DataTable para uma única planilha. As classes WorkBook e WorkSheet do IronXL mapeiam naturalmente o modelo de objeto do Excel. Você cria um livro, adiciona uma planilha, e então itera pelas colunas e linhas do DataTable.

O exemplo a seguir cria um DataTable Employees na memória e escreve para EmployeeData.xlsx:

using IronXL;
using System.Data;

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows starting at row 1
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].ToString());
    }
}

workbook.SaveAs("EmployeeData.xlsx");
using IronXL;
using System.Data;

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows starting at row 1
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].ToString());
    }
}

workbook.SaveAs("EmployeeData.xlsx");
$vbLabelText   $csharpLabel

Saída

Como Exportar Dataset para Excel VB .NET: Um Guia Completo com IronXL: Imagem 1 - Saída para exportar um DataTable simples para Excel em VB.NET

SetCellValue aceita int, double, string e bool -- assim, você obtém tipos nativos de células do Excel sem conversão adicional. O padrão de loop funciona para tabelas de qualquer tamanho porque o IronXL escreve diretamente na memória e libera para o disco apenas quando SaveAs é chamado, mantendo o processo eficiente mesmo para milhares de linhas.

Para uma visão mais ampla das técnicas de leitura e escrita, o tutorial de C# do IronXL cobre toda a gama de operações de arquivo ao lado deste padrão de exportação.

Como Exportar um DataSet para Múltiplas Planilhas de Excel?

Quando um DataSet contém várias tabelas relacionadas -- como Produtos e Pedidos -- você pode mapear cada DataTable para sua própria planilha dentro de um livro. Isso permite que os destinatários vejam todos os dados relacionados em um único arquivo sem precisar abrir múltiplos documentos.

O loop abaixo itera ds.Tables e cria uma planilha por tabela:

using IronXL;
using System.Data;

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

    // Write headers
    for (int col = 0; col < table.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
    }

    // Write rows
    for (int row = 0; row < table.Rows.Count; row++)
    {
        for (int col = 0; col < table.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
        }
    }
}

workbook.SaveAs("CompanyReport.xlsx");
using IronXL;
using System.Data;

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

    // Write headers
    for (int col = 0; col < table.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
    }

    // Write rows
    for (int row = 0; row < table.Rows.Count; row++)
    {
        for (int col = 0; col < table.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
        }
    }
}

workbook.SaveAs("CompanyReport.xlsx");
$vbLabelText   $csharpLabel

Saída

Como Exportar Dataset para Excel VB .NET: Um Guia Completo com IronXL: Imagem 2 - Arquivo Excel gerado com o DataSet exportado como planilhas separadas

Cada planilha é nomeada de acordo com o DataTable de origem, tornando a navegação no Excel direta. Porque WorkBook.Create aloca o livro na memória, você pode continuar adicionando planilhas no loop sem reabrir o arquivo -- o IronXL constrói toda a estrutura XLSX antes de escrever no disco.

A documentação do IronXL WorkBook lista todos os métodos disponíveis no objeto WorkBook, incluindo reordenamento de planilhas, proteção com senha e salvamento em formatos diferentes de XLSX.

Como Adicionar Formatação de Cabeçalho a Exportações para Excel?

Exportações de dados simples são funcionais, mas adicionar cabeçalhos em negrito e larguras de coluna torna a saída imediatamente utilizável em um contexto empresarial. O IronXL expõe o estilo de células e intervalos através do objeto Style anexado a qualquer intervalo WorkSheet.

O trecho abaixo aplica formatação de fonte em negrito à linha de cabeçalho e ajusta automaticamente o tamanho das colunas após a escrita dos dados:

using IronXL;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("Nãorth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
    }
}

workbook.SaveAs("SalesReport.xlsx");
using IronXL;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("Nãorth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
    }
}

workbook.SaveAs("SalesReport.xlsx");
$vbLabelText   $csharpLabel

A propriedade Style.Font.Bold aplica-se ao intervalo de cabeçalho inteiro em uma única instrução. O IronXL também suporta cores de fundo (Style.BackgroundColor), estilos de borda (Style.Border), formatos numéricos (Style.NumberFormat.FormatCode) e alinhamento horizontal (Style.HorizontalAlignment). Para uma referência completa de formatação, veja o guia de formatação de células do IronXL.

Como Exportar Resultados de Consultas de Banco de Dados para Excel?

Conectar-se a um banco de dados SQL e exportar os resultados diretamente para o Excel abrange um grande caso de uso do mundo real -- relatórios agendados, instantâneos de dados e exportações administrativas. A abordagem preenche um DataSet usando SqlDataAdapter, depois mapeia o DataTable resultante para uma planilha do IronXL.

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
$vbLabelText   $csharpLabel

Pontos-Chave para Exportações de Banco de Dados

O guardião nulo (valorDaCelula == DBNull.Value ? "" : cellValue.ToString()) prevents exceptions when the database returns valoresNULL` -- uma ocorrência comum com colunas opcionais. A formatação em negrito na linha de cabeçalho permite que os destinatários do relatório distingam imediatamente os cabeçalhos dos dados.

Para mais padrões sobre como ler dados de volta do Excel para objetos C#, o tutorial de exportação de DataTable do IronXL mostra como reverter esse fluxo de trabalho.

Como Comparar o IronXL com Outras Abordagens de Exportação para Excel?

Antes de escolher uma biblioteca, é útil entender como as principais opções se comparam nas áreas que mais importam para cenários de exportação de DataSet.

Comparação de bibliotecas de exportação de Excel para cenários de DataSet .NET
Abordagem Escritório necessário Suporte a XLSX API de Estilização Multi-Planilha Performance (grandes volumes de dados)
IronXL Não Sim Completo Sim Alto
Interoperabilidade com o Microsoft Office Sim Sim Completo Sim Baixo
EPPlus Não Sim Parcial Sim Alto
XML fechado Não Sim Parcial Sim Médio
CSV (manual) Não Não Nenhum Não Muito alta

O Interoperabilidade com o Microsoft Office só funciona em máquinas Windows com o Office instalado, o que o descarta para implantações em servidores e funções na nuvem. IronXL, EPPlus e XML fechado todos suportam geração do lado do servidor -- o principal diferencial é a amplitude da API de estilização e o modelo de licenciamento. O licenciamento do IronXL inclui uso comercial e cobre todas as estruturas de destino .NET a partir de um único pacote.

Para benchmarks de terceiros e comparações, a documentação da Microsoft sobre formatos de arquivos Excel e a página do projeto EPPlus proporcionam contexto adicional para fazer a escolha certa para o seu projeto.

Como Lidar com Conjuntos de Dados Grandes Sem Problemas de Memória?

Ao exportar DataTables com dezenas de milhares de linhas, manter o uso de memória previsível é importante. O padrão abaixo transmite dados de um IDataReader em vez de carregar o conjunto de resultados completo em um DataTable primeiro. Isso evita o custo de memória dupla de manter tanto o buffer do leitor quanto o DataTable simultaneamente.

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
$vbLabelText   $csharpLabel

Este padrão é recomendado quando o conjunto de resultados pode exceder 50.000 linhas ou quando executado em um serviço com restrição de memória. A documentação de performance do IronXL cobre opções adicionais de ajuste de memória e rendimento para exportações de alto volume.

Salvamento em Lote para CSV para Exportações Muito Grandes

Para exportações que excedem 500.000 linhas onde a memória é extremamente limitada, considere dividir a saída em várias pastas de trabalho ou exportar para o formato CSV:

using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
$vbLabelText   $csharpLabel

O CSV perde formatação e suporte a múltiplas planilhas, mas permanece válido para processamentos ETL a jusante que consomem dados delimitados brutos.

Como Salvar Arquivos Excel em Diferentes Formatos e Localizações?

IronXL suporta salvar para caminho de arquivo, MemoryStream, e byte[] -- o que importa para aplicativos ASP.NET retornando Excel como resposta de download.

using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
$vbLabelText   $csharpLabel

Para ASP.NET Core, retorne File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx") da sua ação do controlador para acionar um download no navegador. O guia do IronXL ASP.NET Excel mostra o padrão completo de integração do controlador.

Para bibliotecas Excel alternativas for .NET, o Open XML SDK é a base de código aberto sobre a qual muitas bibliotecas são construídas.

Formatos de Saída Compatíveis

O IronXL salva nos seguintes formatos sem dependências adicionais:

  • XLSX -- Formato OpenXML, compatível com o Excel 2007 e posterior
  • XLS -- Formato binário legado, compatível com o Excel 97-2003
  • CSV -- Valores separados por vírgula, universalmente suportado
  • TSV -- Valores separados por tabulação
  • JSON -- Exportação de dados estruturados

Alterne formatos mudando a extensão do arquivo no caminho SaveAs ou usando o método sobrecarregado que aceita um valor enum ExcelFileFormat.

Como Verificar se o Arquivo Excel Exportado Está Correto?

Após a exportação, você pode ler o arquivo de volta com IronXL para verificar a contagem de linhas, verificar valores ou executar assertivas automatizadas em um projeto de teste:

using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
$vbLabelText   $csharpLabel

Este padrão de verificação é particularmente útil em suítes de teste de integração onde a correção da exportação deve ser confirmada antes de enviar arquivos para sistemas externos. O tutorial de leitura do IronXL mostra a gama completa de operações de leitura disponíveis após carregar um arquivo.

Para mais leitura sobre padrões de DataSet e DataTable no .NET, a documentação da Microsoft sobre DataSet cobre o modelo de objeto ADO.NET em profundidade.

Quais são os seus próximos passos?

Agora você tem padrões funcionais para cada cenário principal de exportação de DataSet para Excel em C# -- desde uma única DataTable até livros com várias planilhas, exportações baseadas em banco de dados, cabeçalhos formatados e transmissão de dados em grande escala. Aqui está como dar o próximo passo com base no seu objetivo:

  • Experimente IronXL gratuitamente -- Comece com uma licença de teste gratuita e execute os exemplos acima com seus próprios dados antes de comprometer-se com a produção.
  • Leia a referência completa da API -- A referência de objeto do IronXL cobre todos os métodos em WorkBook, WorkSheet e intervalos de células.
  • Explore tutoriais de exportação relacionados -- O guia C# DataTable para Excel cobre o fluxo de trabalho inverso -- lendo de volta o Excel em objetos DataTable.
  • Revise as opções de formatação -- A documentação de formatação de células do IronXL mostra formatos de número, bordas, cores de fundo e opções de alinhamento.
  • Verifique as licenças -- Para implantações em produção, veja a página de licenciamento do IronXL para escolher entre as opções Developer, Organization e Royalty-Free.
  • Compare com outras ferramentas do Iron Software -- Se o seu projeto também precisar de geração de PDF ou OCR, a suíte de produtos Iron Software permite que você agrupe várias bibliotecas a um preço reduzido.

Com base nos padrões abordados aqui, você pode incorporar automação de tarefas agendadas, endpoints de download de ASP.NET Core e pipelines de saída em múltiplos formatos inteiramente em C# gerenciado -- sem Office, sem COM, sem dependências de tempo de execução além do pacote NuGet.

Perguntas frequentes

Como posso exportar um DataSet para o Excel em C#?

Você pode exportar um DataSet para o Excel em C# usando a biblioteca IronXL , que fornece uma API "code-first" para criar, editar e manipular arquivos do Excel sem a necessidade do Microsoft Office.

Preciso ter o Microsoft Office instalado para usar o IronXL?

Não, o IronXL não exige que o Microsoft Office esteja instalado no computador para exportar ou manipular arquivos do Excel.

Que tipos de dados posso exportar usando o IronXL?

O IronXL permite exportar dados estruturados, como DataTables e DataSets, para arquivos do Excel, bem como dados do SqlDataReader e de outras fontes .NET .

O IronXL consegue criar e editar arquivos do Excel?

Sim, o IronXL oferece funcionalidades para criar, editar e manipular arquivos do Excel programaticamente em C#.

O IronXL é adequado para aplicações em nuvem e do lado do servidor?

Sim, o IronXL é ideal para aplicações do lado do servidor e funções em nuvem que precisam gerar arquivos do Excel sem a necessidade de instalação do Office.

Quais são os benefícios de usar o IronXL para exportar conjuntos de dados?

O IronXL lida com a criação e manipulação de arquivos Excel sem dependências externas como o Microsoft Office, suporta os formatos XLSX, XLS e CSV e funciona em todas as plataformas .NET .

É possível usar o IronXL no ASP.NET Core para retornar um arquivo Excel para download?

Sim, o IronXL pode salvar planilhas em um MemoryStream, e a matriz de bytes resultante pode ser retornada de uma ação de controlador ASP.NET Core como um download de arquivo.

O IronXL suporta conjuntos de dados grandes?

Sim, o IronXL pode transmitir dados diretamente do SqlDataReader sem armazenar em buffer um DataTable completo, mantendo o uso de memória previsível para grandes conjuntos de resultados.

Quais formatos do Excel o IronXL suporta para salvar?

O IronXL permite salvar nos formatos XLSX, XLS, CSV, TSV e JSON sem quaisquer dependências adicionais.

Posso aplicar formatação, como cabeçalhos em negrito, ao exportar para o Excel?

Sim, o IronXL fornece uma API de Estilos em intervalos de células para negrito, cores de fundo, bordas, formatos de número e alinhamento.

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