Exportar dados do SQL Server para Microsoft Excel é uma tarefa comum para desenvolvedores .NET que constroem sistemas de relatório, ferramentas de análise de dados e aplicativos empresariais. Este tutorial mostra como exportar dados SQL para Excel usando C# com IronXL, uma biblioteca Excel .NET que gerencia todo o processo sem exigir a instalação do Microsoft Office.
Comece seu teste gratuito para acompanhar os exemplos de código abaixo.
Antes de escrever qualquer código, você precisa adicionar o IronXL ao seu projeto. A maneira mais rápida é via o Console do Gerenciador de Pacotes NuGet no Visual Studio:
Alternativamente, use o .NET CLI:
Uma vez instalado, adicione os namespaces necessários no topo de seu arquivo. Com declarações de nível superior do .NET 10, sua configuração ficará assim:
using IronXL;
using System.Data;
using System.Data.SqlClient;Imports IronXL
Imports System.Data
Imports System.Data.SqlClientO IronXL tem como alvo o .NET Standard 2.0 e superior, portanto, funciona com projetos .NET 10, .NET Framework, ASP.NET Core e Blazor sem qualquer configuração adicional. Você pode encontrar o pacote no NuGet.
A abordagem mais eficiente para exportar dados do SQL Server para um arquivo Excel envolve três etapas: estabelecer uma conexão com o banco de dados, recuperar dados em um DataTable e escrever os dados em uma planilha Excel usando IronXL. Ao contrário das soluções Interoperabilidade Microsoft, IronXL opera de forma independente e lida com grandes conjuntos de dados sem gargalos de desempenho causados pelo overhead do COM interop.
O padrão básico é direto. SqlDataAdapter faz parte do framework de acesso a dados ADO.NET da Microsoft e tem sido a maneira padrão de preencher objetos DataTable de bancos de dados relacionais desde o .NET 1.0:
SqlConnection com sua string de conexãoSqlDataAdapter para preencher um DataTable ou DataSet.xlsx ou .xlsEssa abordagem é compatível com SQL Server 2012 e posterior, bem como com o Azure SQL Database, Amazon RDS para SQL Server e qualquer fonte de dados compatível com ADO.NET. O mesmo padrão se aplica, quer você esteja trabalhando com um aplicativo de console ou uma ferramenta de relatórios baseada na web.
Antes de poder exportar dados SQL, você precisa estabelecer uma conexão e executar uma consulta SQL para preencher um DataTable. A string de conexão contém as credenciais do banco de dados SQL Server e as informações do servidor necessárias para acessar seus dados.
O exemplo a seguir consulta a tabela Nãorthwind Customers e escreve cada linha em uma planilha Excel usando a API de escrita de células do IronXL:
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Data Source=localhost;Initial Catalog=Nãorthwind;Integrated Security=True";
string sql = "SELECT * FROM Customers";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);
DataTable dt = new DataTable();
adapter.Fill(dt);
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Customers");
// Write column headers
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].ToString());
}
}
workBook.SaveAs("CustomerExport.xlsx");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Nãorthwind;Integrated Security=True"
Dim sql As String = "SELECT * FROM Customers"
Using connection As New SqlConnection(connectionString)
connection.Open()
Dim adapter As New SqlDataAdapter(sql, connection)
Dim dt As New DataTable()
adapter.Fill(dt)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Customers")
' Write column headers
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).ToString())
Next
Next
workBook.SaveAs("CustomerExport.xlsx")
End Using
Este código cria um arquivo Excel com cabeçalhos de coluna formatados corretamente, derivados da estrutura da sua tabela SQL Server. O DataTable dt armazena os resultados da consulta, que são então escritos em cada célula sistematicamente usando índices de linha e coluna baseados em zero. IronXL suporta tanto os formatos .xls quanto .xlsx para ampla compatibilidade com aplicativos do Microsoft Office.
Se sua tabela SQL contém DateTime ou colunas numéricas, converta os valores das células adequadamente antes de chamar SetCellValue. Passar tipos numéricos diretamente preserva os tipos de dados do Excel e permite a ordenação e cálculos de fórmulas nas colunas exportadas.
Quando seu relatório precisa de dados de várias tabelas SQL -- por exemplo, Produtos e Categorias -- você pode carregá-los em um DataSet e permitir que o IronXL crie uma planilha por tabela automaticamente. Esta é a abordagem mais concisa para exportar um DataSet ou DataTable para Excel.
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Data Source=.;Initial Catalog=Inventory;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
SqlDataAdapter productsAdapter = new SqlDataAdapter("SELECT * FROM Products", connection);
SqlDataAdapter categoriesAdapter = new SqlDataAdapter("SELECT * FROM Categories", connection);
DataSet dataSet = new DataSet();
productsAdapter.Fill(dataSet, "Products");
categoriesAdapter.Fill(dataSet, "Categories");
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);
workBook.SaveAs("InventoryReport.xlsx");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Data Source=.;Initial Catalog=Inventory;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
connection.Open()
Dim productsAdapter As New SqlDataAdapter("SELECT * FROM Products", connection)
Dim categoriesAdapter As New SqlDataAdapter("SELECT * FROM Categories", connection)
Dim dataSet As New DataSet()
productsAdapter.Fill(dataSet, "Products")
categoriesAdapter.Fill(dataSet, "Categories")
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)
workBook.SaveAs("InventoryReport.xlsx")
End Using
LoadWorkSheetsFromDataSet lê a propriedade TableName de cada DataTable dentro do DataSet e cria uma guia de planilha correspondente. Os nomes das colunas do DataTable tornam-se a linha de cabeçalho em cada planilha. Este método é particularmente útil para procedimentos armazenados que retornam múltiplos conjuntos de resultados, pois você pode preencher o DataSet usando múltiplas chamadas SqlDataAdapter e então exportar tudo em uma única etapa.
Para aplicativos que precisam criar arquivos Excel programaticamente com formatação personalizada, você ainda pode acessar planilhas individuais após chamar LoadWorkSheetsFromDataSet e aplicar estilos, larguras de coluna ou fórmulas antes de salvar.
Para aplicativos web, você normalmente aciona a exportação quando um usuário clica em um botão. O seguinte exemplo de Web Forms ASP.NET mostra como lidar com o evento de clique do botão, construir o livro Excel a partir de uma consulta SQL e enviar o arquivo ao navegador como um download usando Response.AddHeader:
using IronXL;
using System;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Web.UI;
public partial class ExportPage : Page
{
private void ExportButton_Click(object sender, EventArgs e)
{
string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
SqlDataAdapter adapter = new SqlDataAdapter("SELECT * FROM Orders", connection);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);
byte[] fileBytes = workBook.ToByteArray();
string filename = "OrdersExport.xlsx";
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=" + filename);
Response.BinaryWrite(fileBytes);
Response.End();
}
}Imports IronXL
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports System.IO
Imports System.Web.UI
Public Partial Class ExportPage
Inherits Page
Private Sub ExportButton_Click(sender As Object, e As EventArgs)
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
Dim adapter As New SqlDataAdapter("SELECT * FROM Orders", connection)
Dim dataSet As New DataSet()
adapter.Fill(dataSet)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)
Dim fileBytes As Byte() = workBook.ToByteArray()
Dim filename As String = "OrdersExport.xlsx"
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=" & filename)
Response.BinaryWrite(fileBytes)
Response.End()
End Using
End Sub
End Class
O método ToByteArray() converte todo o livro em um array de bytes em memória, que você então escreve diretamente no fluxo de resposta HTTP. Isso evita escrever um arquivo temporário no disco. Diferentemente do Interop da Microsoft, que requer os placeholders object misValue e uma licença do Office instalada no servidor, o IronXL é executado totalmente em código gerenciado sem dependências externas.
Para projetos ASP.NET Core e Razor Pages, substitua Response.BinaryWrite por return File(fileBytes, contentType, filename) da sua ação do controlador. O padrão exportar para Excel no ASP.NET Core segue a mesma abordagem de workbook-para-array-de-bytes.
Exportações de SQL bruto muitas vezes precisam de melhorias na apresentação antes de serem compartilhadas com usuários finais. IronXL oferece controle sobre os estilos de célula, larguras de coluna e formatos numéricos após os dados terem sido escritos na planilha. O exemplo a seguir demonstra como negritar a linha de cabeçalho e ajustar automaticamente as larguras das colunas:
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
SqlDataAdapter adapter = new SqlDataAdapter("SELECT OrderID, CustomerID, OrderDate, Total FROM Orders", connection);
DataTable dt = new DataTable();
adapter.Fill(dt);
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Orders");
// Write and style header row
for (int col = 0; col < dt.Columns.Count; col++)
{
workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
workSheet[0, col].Style.Font.Bold = true;
workSheet[0, col].Style.Font.Height = 12;
}
// Write data rows with type-aware value assignment
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
object value = dt.Rows[row][col];
if (value is DateTime date)
workSheet.SetCellValue(row + 1, col, date.ToString("yyyy-MM-dd"));
else if (value is decimal || value is double || value is int)
workSheet.SetCellValue(row + 1, col, Convert.ToDouble(value));
else
workSheet.SetCellValue(row + 1, col, value.ToString());
}
}
workBook.SaveAs("FormattedOrdersExport.xlsx");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
connection.Open()
Dim adapter As New SqlDataAdapter("SELECT OrderID, CustomerID, OrderDate, Total FROM Orders", connection)
Dim dt As New DataTable()
adapter.Fill(dt)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Orders")
' Write and style header row
For col As Integer = 0 To dt.Columns.Count - 1
workSheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
workSheet(0, col).Style.Font.Bold = True
workSheet(0, col).Style.Font.Height = 12
Next
' Write data rows with type-aware value assignment
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
Dim value As Object = dt.Rows(row)(col)
If TypeOf value Is DateTime Then
Dim dateValue As DateTime = CType(value, DateTime)
workSheet.SetCellValue(row + 1, col, dateValue.ToString("yyyy-MM-dd"))
ElseIf TypeOf value Is Decimal OrElse TypeOf value Is Double OrElse TypeOf value Is Integer Then
workSheet.SetCellValue(row + 1, col, Convert.ToDouble(value))
Else
workSheet.SetCellValue(row + 1, col, value.ToString())
End If
Next
Next
workBook.SaveAs("FormattedOrdersExport.xlsx")
End UsingEstilizar a linha de cabeçalho com texto em negrito e uma fonte maior torna os relatórios exportados mais fáceis de ler no Excel. Para colunas numéricas como totais ou contagens, passar um valor double em vez de uma string permite que as funções nativas de ordenação e agregação do Excel funcionem corretamente nos dados exportados.
Você pode explorar toda a gama de opções de formatação -- incluindo bordas de células, cores de fundo e máscaras de formato numérico -- na documentação de formatação de célula do IronXL.
Para tabelas com dezenas de milhares de linhas, a gestão de memória torna-se importante. Carregar todo o conjunto de resultados em um DataTable antes de escrever para o Excel funciona bem para a maioria dos relatórios, mas para exportações muito grandes, você pode processar linhas em lotes ou usar SqlDataReader diretamente.
Ao trabalhar com exportações de alto volume, considere as seguintes estratégias:
workBook.SaveAs(filePath) após cada lote em vez de manter tudo na memória com ToByteArray().SELECT em vez de SELECT * para reduzir a quantidade de dados transferidos do SQL Server.Para obter orientações sobre a maneira mais rápida de exportar uma DataTable para Excel em C#, o blog do IronXL tem um artigo de referência dedicado comparando diferentes abordagens e seus perfis de memória.
O método WorkBook.LoadWorkSheetsFromDataSet é particularmente eficiente para objetos DataSet de tamanho moderado porque ele lida com a iteração de linhas internamente. Para o cenário específico de exportação de DataTable para Excel, este método reduz o código de template e é otimizado para gravações em massa.
O fluxo de exportação é apenas metade da história para muitas aplicações de relatórios. Você também pode precisar permitir que os usuários façam download de um modelo, preencham os dados e façam o upload novamente para o SQL Server. IronXL torna este fluxo de trabalho bidirecional direto.
Para importar dados do Excel para um banco de dados, carregue o arquivo enviado com WorkBook.Load(filePath), itere sobre as linhas da planilha e insira cada linha usando um SqlCommand parametrizado:
using IronXL;
using System.Data.SqlClient;
WorkBook workBook = WorkBook.Load("UploadedData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
string connectionString = "Data Source=localhost;Initial Catalog=Inventory;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
// Skip header row, start at row index 1
for (int row = 1; row <= sheet.RowCount; row++)
{
string productName = sheet[row, 0].StringValue;
int quantity = (int)sheet[row, 1].DoubleValue;
decimal price = (decimal)sheet[row, 2].DoubleValue;
using SqlCommand cmd = new SqlCommand(
"INSERT INTO Products (Name, Quantity, Price) VALUES (@name, @qty, @price)",
connection);
cmd.Parameters.AddWithValue("@name", productName);
cmd.Parameters.AddWithValue("@qty", quantity);
cmd.Parameters.AddWithValue("@price", price);
cmd.ExecuteNonQuery();
}Imports IronXL
Imports System.Data.SqlClient
Dim workBook As WorkBook = WorkBook.Load("UploadedData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Inventory;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
connection.Open()
' Skip header row, start at row index 1
For row As Integer = 1 To sheet.RowCount
Dim productName As String = sheet(row, 0).StringValue
Dim quantity As Integer = CInt(sheet(row, 1).DoubleValue)
Dim price As Decimal = CDec(sheet(row, 2).DoubleValue)
Using cmd As New SqlCommand("INSERT INTO Products (Name, Quantity, Price) VALUES (@name, @qty, @price)", connection)
cmd.Parameters.AddWithValue("@name", productName)
cmd.Parameters.AddWithValue("@qty", quantity)
cmd.Parameters.AddWithValue("@price", price)
cmd.ExecuteNonQuery()
End Using
Next
End UsingConsultas parametrizadas protegem contra injeção SQL ao ler dados do Excel fornecidos pelo usuário. A documentação SqlCommand no Microsoft Learn cobre todas as sobrecargas disponíveis e padrões de vinculação de parâmetros. Sempre valide os valores das células antes de inserir -- verifique por strings vazias, números fora do limite e tipos de dados inesperados que possam causar violações de restrição em sua tabela do SQL Server.
Para a direção inversa, o IronXL também suporta ler arquivos CSV em C# para cenários onde sua fonte de dados produz saída separada por vírgulas em vez de arquivos .xlsx.
Existem várias abordagens para exportar dados SQL para Excel em .NET. A tabela abaixo resume as principais vantagens e desvantagens:
| Abordagem | Escritório necessário | Suporte a DataSet | Formatação | Seguro para Servidor |
|---|---|---|---|---|
| IronXL | Não | Sim (integrado) | Estilos completos, fórmulas | Sim |
| Interoperabilidade Microsoft | Sim | Iteração manual | Completo via COM | Não (servidor COM) |
| EPPlus | Não | Iteração manual | Extenso | Sim |
| NPOI | Não | Iteração manual | Bom | Sim |
| Saída CSV | Não | Manual | Nãone | Sim |
O Interop da Microsoft requer que o Office esteja instalado no servidor e não é suportado em aplicações web do lado do servidor. IronXL, EPPlus e NPOI funcionam sem o Office. A vantagem do IronXL é seu suporte de primeira classe a DataSet e DataTable através de LoadWorkSheetsFromDataSet, o que reduz o código de exportação a algumas linhas em comparação com a iteração manual de linhas em outras bibliotecas.
Para uma comparação detalhada, veja o artigo sobre alternativas ao Microsoft Office Interop.
Exportar dados SQL para Excel usando C# torna-se direto com o IronXL. A biblioteca elimina dependências complexas de Interop, enquanto fornece suporte robusto para DataTable, DataSet e integração direta com o banco de dados. Seja construindo aplicações de console ou sistemas de relatório baseados na web com capacidades de download de arquivos, o IronXL oferece geração confiável de arquivos Excel para todos os tipos de projeto .NET 10.
Para continuar construindo sobre esta base, explore estes recursos relacionados:
LoadWorkSheetsFromDataSetCompre uma licença para implementação em produção, ou continue explorando com uma versão de teste gratuita para testar todas as capacidades desta biblioteca Excel em seus projetos .NET.
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.
