Exportar dados DataGridView para um arquivo Excel é uma das tarefas mais comuns no desenvolvimento de Windows Forms. Ao criar aplicativos de negócios que exibem dados tabulares - seja relatórios de vendas, registros de inventário ou listas de clientes - os usuários esperam clicar em um botão e receber um arquivo Excel devidamente formatado que podem compartilhar ou analisar mais. O desafio é fazer isso de forma limpa, sem depender de uma instalação do Microsoft Excel em cada máquina do usuário final e sem lutar com código de limpeza de interoperabilidade COM que vaza memória ou quebra silenciosamente. Este guia orienta você por todo o processo de exportação de DataGridView para Excel em C# usando IronXL, cobrindo tudo, desde a configuração do projeto até a formatação avançada de células, para que você acabe com um código pronto para produção.
Abordagens tradicionais para exportar dados DataGridView dependem do Interoperabilidade Microsoft -- você abriria Adicionar Referência, navegaria até a guia COM, selecionaria a Microsoft Excel Object Library e escreveria um código frágil que chamava Marshal.ReleaseComObject para evitar vazamentos de memória. Esse padrão exige que o Microsoft Excel esteja instalado em cada máquina onde o aplicativo é executado, funciona lentamente com grandes conjuntos de dados e frequentemente produz erros COMException em ambientes de implantação que não possuem licenças do Office. A própria orientação da Microsoft sobre Automação do Office recomenda explicitamente bibliotecas de terceiros para cenários automatizados e no lado do servidor.
IronXL remove todas essas dependências. É uma biblioteca pura do .NET que lê e escreve arquivos .xlsx, .xls, .csv e .ods sem Microsoft Office ou qualquer registro COM. Você a instala através do NuGet e começa a escrever código imediatamente.
Comece criando um novo projeto Windows Forms App no Visual Studio direcionado ao .NET 10. Adicione um controle DataGridView e um Button à superfície do formulário. Nãomeie o botão btnExport e dê a ele o rótulo 'Exportar para Excel'. Em seguida, abra o Console do Gerenciador de Pacotes NuGet e execute:
Adicione os namespaces necessários ao topo do seu arquivo de formulário:
using IronXL;
using System.Data;Imports IronXL
Imports System.DataEsses dois namespaces cobrem todos os tipos de IronXL que você precisa para ler e escrever livros do Excel, e os tipos padrão System.Data para trabalhar com objetos DataTable que conectam seu DataGridView ao pipeline de exportação.
Antes de construir a lógica de exportação, preencha seu DataGridView com dados representativos. O evento Form1_Load é o local certo para vincular um DataTable como fonte de dados. Em um aplicativo real, você consultaria um banco de dados ou chamaria um serviço; aqui, um DataTable codificado ilustra claramente a estrutura. A visão geral do controle DataGridView na Microsoft Docs fornece contexto adicional sobre como o controle gerencia as fontes de dados.
void Form1_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add("ProductID", typeof(int));
dt.Columns.Add("ProductName", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));
dt.Rows.Add(1, "Laptop", 999.99m, 50);
dt.Rows.Add(2, "Mouse", 29.99m, 200);
dt.Rows.Add(3, "Keyboard", 79.99m, 150);
dt.Rows.Add(4, "Monitor", 349.99m, 75);
dt.Rows.Add(5, "Webcam", 89.99m, 120);
dataGridView1.DataSource = dt;
}Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Dim dt As New DataTable()
dt.Columns.Add("ProductID", GetType(Integer))
dt.Columns.Add("ProductName", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("Stock", GetType(Integer))
dt.Rows.Add(1, "Laptop", 999.99D, 50)
dt.Rows.Add(2, "Mouse", 29.99D, 200)
dt.Rows.Add(3, "Keyboard", 79.99D, 150)
dt.Rows.Add(4, "Monitor", 349.99D, 75)
dt.Rows.Add(5, "Webcam", 89.99D, 120)
dataGridView1.DataSource = dt
End SubEste código usa estilo de declaração de nível superior para a assinatura do manipulador de eventos. O DataTable tem quatro colunas tipadas - inteiro, string, decimal e inteiro - que o IronXL preservará ao escrever no livro do Excel. Colunas tipadas são importantes porque o IronXL escreve colunas numéricas como células numéricas em vez de texto, o que permite aos usuários classificar e somar valores no Excel sem reformatar.
O DataGridView renderiza automaticamente uma linha de cabeçalho de coluna a partir dos nomes de coluna DataTable. Quando você exporta, deseja que essa linha de cabeçalho seja preservada no arquivo Excel, o que significa que o seu código de exportação deve tratar cabeçalhos separadamente das linhas de dados - a próxima seção cobre exatamente isso.
Para uso em produção, o mesmo padrão se aplica, quer o DataTable venha do Entity Framework, Dapper, ADO.NET ou qualquer outra camada de acesso a dados. A vinculação DataGridView é desacoplada do código de exportação, para que você possa trocar a fonte de dados sem tocar na lógica de exportação.
A lógica principal de exportação é executada dentro do manipulador de clique do botão. O IronXL fornece um método LoadFromDataTable no WorkSheet que lida automaticamente com o mapeamento de coluna para célula. A abordagem mais limpa extrai um DataTable do DataGridView e o passa diretamente. O Open XML SDK, que está na base do formato .xlsx, é documentado pela Microsoft e confirma porque soluções puras .NET como IronXL superam o Interop para geração programática.
void btnExport_Click(object sender, EventArgs e)
{
try
{
DataTable dt = new DataTable();
foreach (DataGridViewColumn column in dataGridView1.Columns)
dt.Columns.Add(column.HeaderText);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
DataRow dataRow = dt.NewRow();
for (int i = 0; i < dataGridView1.Columns.Count; i++)
dataRow[i] = row.Cells[i].Value ?? DBNull.Value;
dt.Rows.Add(dataRow);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Product Data";
worksheet.LoadFromDataTable(dt, true);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show($"Exported successfully to:\n{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms
Public Sub btnExport_Click(sender As Object, e As EventArgs)
Try
Dim dt As New DataTable()
For Each column As DataGridViewColumn In dataGridView1.Columns
dt.Columns.Add(column.HeaderText)
Next
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
Dim dataRow As DataRow = dt.NewRow()
For i As Integer = 0 To dataGridView1.Columns.Count - 1
dataRow(i) = If(row.Cells(i).Value, DBNull.Value)
Next
dt.Rows.Add(dataRow)
Next
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Product Data"
worksheet.LoadFromDataTable(dt, True)
Dim outputPath As String = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
)
workbook.SaveAs(outputPath)
MessageBox.Show($"Exported successfully to:{Environment.NewLine}{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information)
Catch ex As Exception
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
End Sub
A chamada LoadFromDataTable(dt, true) leva o DataTable e uma flag booleana que informa ao IronXL para escrever os nomes das colunas como a primeira linha do Excel - esses se tornam suas células de cabeçalho. O livro é salvo na área de trabalho do usuário usando Environment.SpecialFolder.Desktop em vez de um caminho codificado, o que torna o código portátil entre contas de usuário.
A verificação null (?? DBNull.Value) prevents a NullReferenceException quando uma célula não contém valor. Isso é importante para dados do mundo real onde campos opcionais podem estar vazios. O IronXL escreve DBNull como uma célula vazia em vez da string 'DBNull', então o resultado permanece limpo.
Para mais detalhes sobre como ler dados de volta de arquivos Excel em um DataGridView, veja a documentação IronXL DataTable, que cobre a operação inversa e como converter Excel para DataSet para livros de várias planilhas.
Dados simples em um arquivo Excel são funcionais, mas uma saída formatada profissionalmente -- cabeçalhos em negrito, larguras de coluna ajustadas ao conteúdo, cores alternadas de fundo para as linhas -- faz a diferença entre uma ferramenta que os usuários confiam e uma que eles exportam e imediatamente reformata manualmente. IronXL expõe uma rica API de estilo de célula que abrange fontes, cores, bordas, formatos de números e alinhamento. A especificação OOXML para estilos de planilha define o formato subjacente que o IronXL escreve, garantindo que a saída abra corretamente em qualquer aplicativo compatível.
void ExportWithFormatting(object sender, EventArgs e)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Formatted Export";
string[] headers = { "ID", "Product Name", "Price", "Stock" };
// Write and style header row
for (int col = 0; col < headers.Length; col++)
{
char colLetter = (char)('A' + col);
string cellAddress = $"{colLetter}1";
worksheet.SetCellValue(0, col, headers[col]);
worksheet[cellAddress].Style.Font.Bold = true;
worksheet[cellAddress].Style.Font.Height = 12;
worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
worksheet[cellAddress].Style.Font.Color = "#FFFFFF";
worksheet[cellAddress].Style.HorizontalAlignment =
IronXL.Styles.HorizontalAlignment.Center;
}
// Write data rows with alternating background colors
int rowIndex = 1;
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
worksheet.SetCellValue(rowIndex, col,
row.Cells[col].Value?.ToString() ?? string.Empty);
}
if (rowIndex % 2 == 0)
{
string rangeAddress = $"A{rowIndex + 1}:D{rowIndex + 1}";
worksheet[rangeAddress].Style.SetBackgroundColor("#D6DCE5");
}
rowIndex++;
}
// Format the Price column as currency
worksheet["C2:C100"].Style.Format = "$#,##0.00";
// Auto-fit column widths
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
worksheet.AutoSizeColumn(3);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"FormattedExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show("Formatted export complete.", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}Option Strict On
Option Infer On
Sub ExportWithFormatting(sender As Object, e As EventArgs)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Formatted Export"
Dim headers As String() = {"ID", "Product Name", "Price", "Stock"}
' Write and style header row
For col As Integer = 0 To headers.Length - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
Dim cellAddress As String = $"{colLetter}1"
worksheet.SetCellValue(0, col, headers(col))
worksheet(cellAddress).Style.Font.Bold = True
worksheet(cellAddress).Style.Font.Height = 12
worksheet(cellAddress).Style.SetBackgroundColor("#4472C4")
worksheet(cellAddress).Style.Font.Color = "#FFFFFF"
worksheet(cellAddress).Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
Next
' Write data rows with alternating background colors
Dim rowIndex As Integer = 1
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
For col As Integer = 0 To dataGridView1.Columns.Count - 1
worksheet.SetCellValue(rowIndex, col, If(row.Cells(col).Value?.ToString(), String.Empty))
Next
If rowIndex Mod 2 = 0 Then
Dim rangeAddress As String = $"A{rowIndex + 1}:D{rowIndex + 1}"
worksheet(rangeAddress).Style.SetBackgroundColor("#D6DCE5")
End If
rowIndex += 1
Next
' Format the Price column as currency
worksheet("C2:C100").Style.Format = "$#,##0.00"
' Auto-fit column widths
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)
worksheet.AutoSizeColumn(3)
Dim outputPath As String = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "FormattedExport.xlsx")
workbook.SaveAs(outputPath)
MessageBox.Show("Formatted export complete.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information)
End Sub
O código de formatação aplica várias técnicas. A linha de cabeçalho recebe um fundo azul (#4472C4) com texto branco, fonte negrito de 12 pontos e alinhamento centralizado - um estilo padrão de planilha de negócios. As linhas de dados alternam entre branco e cinza claro (#D6DCE5) a cada linha par, o que facilita para os usuários lerem tabelas largas sem perder o lugar. A coluna de Preço usa o formato de moeda integrado do Excel ($#,##0.00), então os valores são exibidos com sinais de dólar e duas casas decimais na planilha sem alterar os dados numéricos subjacentes. AutoSizeColumn ajusta cada coluna ao seu maior valor, para que nenhum conteúdo seja truncado.
Você pode estender este padrão ainda mais com estilização de borda de célula, formatação condicional, e regras de validação de dados. Para relatórios que devem corresponder a um modelo corporativo, você também pode definir o layout da página e a área de impressão para que o arquivo exportado esteja pronto para impressão sem ajustes.
Quando um DataGridView está vinculado a milhares de linhas, iterar célula por célula torna-se visivelmente lento. Duas otimizações melhoram significativamente o desempenho. Primeiro, use LoadFromDataTable em vez de chamadas SetCellValue por célula. Em segundo lugar, se sua fonte de dados é um DataTable, passe-o diretamente ao IronXL em vez de extrair valores pelas linhas DataGridView:
void ExportLargeDataset(DataTable sourceTable)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, true);
// Apply header styling after load
int colCount = sourceTable.Columns.Count;
for (int col = 0; col < colCount; col++)
{
char colLetter = (char)('A' + col);
worksheet[$"{colLetter}1"].Style.Font.Bold = true;
worksheet[$"{colLetter}1"].Style.SetBackgroundColor("#4472C4");
worksheet[$"{colLetter}1"].Style.Font.Color = "#FFFFFF";
}
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
));
}Option Strict On
Option Infer On
Sub ExportLargeDataset(sourceTable As DataTable)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, True)
' Apply header styling after load
Dim colCount As Integer = sourceTable.Columns.Count
For col As Integer = 0 To colCount - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
worksheet($"{colLetter}1").Style.Font.Bold = True
worksheet($"{colLetter}1").Style.SetBackgroundColor("#4472C4")
worksheet($"{colLetter}1").Style.Font.Color = "#FFFFFF"
Next
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
))
End SubPara conjuntos de dados com mais de 10.000 linhas, executar a exportação em um thread em segundo plano mantém a UI responsiva. Envolva a lógica de exportação em Task.Run e commande a chamada MessageBox.Show de volta ao thread da UI usando Invoke. O IronXL é thread-safe para operações de escrita em instâncias WorkBook separadas, para que você possa executar várias exportações simultaneamente, se necessário.
Recursos adicionais de desempenho:
Muitos desenvolvedores começam com Microsoft Excel Interop porque vem com o Office e não requer pacotes adicionais. Não entanto, Interop tem custos reais que aparecem rapidamente em ambientes de produção. A tabela a seguir resume as principais diferenças:
| Capacidade | IronXL | Interoperabilidade Microsoft |
|---|---|---|
| Requer instalação do Microsoft Excel | Não | Sim |
| Funciona em ambientes de servidor / nuvem | Sim | Não (não suportado pela Microsoft) |
| É necessária limpeza de objetos COM | Não | Sim (Marshal.ReleaseComObject) |
| Desempenho com grandes conjuntos de dados | Rápido (puro .NET) | Lento (sobrecarga de marshalling COM) |
| Método de instalação | NuGet | Referência COM / instalação do Office |
| .NET versões suportadas | .NET 4.6.2 -- .NET 10 | Somente .NET Framework (limitado) |
| Suporte para XLSX, CSV, ODS | Sim | Somente XLSX/XLS via Excel |
A própria documentação da Microsoft adverte contra o uso do Office Interop em servidores ou em contas de serviço, citando preocupações de estabilidade e licenciamento. IronXL funciona corretamente no Azure App Service, hosts de Serviço do Windows, contêineres Docker e qualquer outro ambiente sem interface gráfica onde a execução de um aplicativo de desktop como o Excel não é viável.
Para equipes que já usam Interop e desejam migrar, a API do IronXL mapeia tão de perto que a maioria das operações WorkBook e WorkSheet são traduzidas diretamente. O Guia de migração do IronXL cobre padrões comuns do Interop e seus equivalentes no IronXL.
Exportar dados DataGridView para Excel usando IronXL requer apenas a instalação de um pacote NuGet e algumas linhas de código, substituindo a abordagem frágil do COM interop por uma solução limpa e fácil de manter que funciona em qualquer ambiente de implantação. As técnicas abordadas aqui -- exportação básica, saída formatada, otimização para grandes conjuntos de dados e uma tabela de comparação -- dão a você tudo o que precisa para implementar esse recurso em um aplicativo de produção Windows Forms.
A partir daqui, explore essas capacidades relacionadas:
.xlsxInicie um teste gratuito do IronXL para testar o conjunto completo de recursos no seu projeto, ou revise as opções de licenciamento do IronXL quando estiver pronto para a implantação em produção.
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.
