Exportar dados de um DataGridView para um arquivo Excel requer apenas algumas linhas de código C# quando você usa IronXL. Crie um WorkBook, iterar através das colunas e linhas do grid, escreva cada valor de célula na planilha e, em seguida, chame SaveAs para produzir um arquivo .xlsx totalmente formatado -- sem necessidade de instalação do Microsoft Office.
Windows Forms é uma biblioteca GUI fundamental no ecossistema .NET, amplamente usada para construir aplicativos de desktop. O controle DataGridView é um de seus componentes mais utilizados: ele exibe, edita e gerencia dados tabulares de qualquer fonte vinculável, como um DataTable, resultado de uma consulta de banco de dados ou uma lista em memória.
Exportar esses dados da grade para Excel atende a várias necessidades diárias -- enviar relatórios para stakeholders, arquivar instantâneos para auditoria ou alimentar ferramentas analíticas downstream. As duas abordagens tradicionais são Microsoft Interoperação com o Office e bibliotecas de terceiros. O Interop exige uma cópia do Excel instalada em cada máquina que executa o aplicativo, cria problemas de ciclo de vida de objetos COM e tem desempenho ruim em implantações em servidor ou nuvem. Bibliotecas como IronXL, ClosedXML e Syncfusion evitam esses problemas ao escrever diretamente no formato de arquivo Open XML sem qualquer dependência do Office.
Este guia demonstra a abordagem do IronXL em C# visando .NET 10, embora o IronXL suporte .NET Framework 4.6.2 e todas as versões .NET modernas.
Antes de escrever qualquer código de exportação, confirme que os seguintes itens estão no lugar:
DataGridViewAbra o Console do Gerenciador de Pacotes no Visual Studio e execute um dos comandos:
Como alternativa, clique com o botão direito no projeto no Solution Explorer, escolha Gerenciar Pacotes NuGet, pesquise IronXL.Excel e clique em Instalar.
Uma vez instalado, adicione a diretiva using do IronXL no topo de qualquer arquivo que utilize a funcionalidade do Excel:
using IronXL;
using System.Data;Imports IronXL
Imports System.DataO IronXL suporta todos os formatos de planilhas comuns: XLSX, XLS, CSV e TSV. Este guia utiliza o formato XLSX ao longo, pois é o formato padrão para as versões modernas do Excel.
Para este passo a passo, o formulário contém um DataGridView chamado DataGridView1 e um botão chamado btnExport. O grid é populado no evento Load do formulário com registros de funcionários armazenados em um DataTable:
void Form1_Load(object sender, EventArgs e)
{
var dt = new DataTable();
// Define columns with the appropriate .NET type
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));
// Add sample rows
dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);
DataGridView1.DataSource = dt;
}Option Strict On
Option Infer On
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Dim dt As New DataTable()
' Define columns with the appropriate .NET type
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))
' Add sample rows
dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000D)
dt.Rows.Add(102, "Michael Chen", "Marketing", 72000D)
dt.Rows.Add(103, "Emily Davis", "Finance", 91000D)
dt.Rows.Add(104, "James Wilson", "Engineering", 78000D)
DataGridView1.DataSource = dt
End SubCada coluna é definida com um tipo .NET específico para que comparações numéricas e formatação funcionem corretamente posteriormente. A propriedade DataSource vincula o DataTable diretamente ao DataGridView, e o grid renderiza automaticamente todas as linhas quando o formulário é aberto. Em produção, esses dados viriam tipicamente de uma consulta de banco de dados, um conjunto de resultados de ORM, ou uma resposta de API REST, em vez de valores codificados.
Um DataGridView expõe seu conteúdo através de duas coleções: Columns (para metadados como HeaderText e índice de coluna) e Rows (para as células de dados reais). Cada DataGridViewRow contém uma coleção Cells indexada pela posição da coluna. A propriedade Value de cada célula retorna um objeto encapsulado que você deve converter ou transformar antes de escrevê-lo em uma célula do Excel. Compreender essa hierarquia é essencial para escrever um loop de exportação confiável.
O DataTable atua nos bastidores armazenando valores tipados, então um salário decimal não precisa de conversão de string antes de ser escrito em uma planilha IronXL. O método SetCellValue do IronXL aceita sobrecargas string, double, decimal, int, bool e DateTime, permitindo que você preserve o tipo de dado original no arquivo de saída.
A lógica de exportação reside dentro do manipulador de clique do botão. O código cria um novo WorkBook, recupera a planilha padrão, escreve os cabeçalhos de coluna na primeira linha e, em seguida, escreve cada linha de dados abaixo deles:
void btnExport_Click(object sender, EventArgs e)
{
var workbook = WorkBook.Create();
var sheet = workbook.DefaultWorkSheet;
// Write column headers to row index 0
for (int col = 0; col < DataGridView1.Columns.Count; col++)
{
sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
}
// Write data rows starting at row index 1
for (int row = 0; row < DataGridView1.Rows.Count; row++)
{
for (int col = 0; col < DataGridView1.Columns.Count; col++)
{
object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
if (cellValue is not null)
{
sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
}
}
}
string outputPath = "EmployeeData.xlsx";
workbook.SaveAs(outputPath);
MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}Private Sub btnExport_Click(sender As Object, e As EventArgs)
Dim workbook = WorkBook.Create()
Dim sheet = workbook.DefaultWorkSheet
' Write column headers to row index 0
For col As Integer = 0 To DataGridView1.Columns.Count - 1
sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
Next
' Write data rows starting at row index 1
For row As Integer = 0 To DataGridView1.Rows.Count - 1
For col As Integer = 0 To DataGridView1.Columns.Count - 1
Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
If cellValue IsNot Nothing Then
sheet.SetCellValue(row + 1, col, cellValue.ToString())
End If
Next
Next
Dim outputPath As String = "EmployeeData.xlsx"
workbook.SaveAs(outputPath)
MessageBox.Show("Export complete. File saved to: " & outputPath, "Success")
End SubO objeto WorkBook representa o arquivo Excel inteiro na memória. DefaultWorkSheet retorna a primeira planilha sem exigir que você crie uma explicitamente. O loop externo escreve o texto do cabeçalho de HeaderText na linha zero. O loop aninhado itera então cada linha de dados, verificando se há nulos antes de converter o valor da célula para uma string. O deslocamento row + 1 move os dados abaixo da linha de cabeçalho. SaveAs grava o workbook finalizado como um arquivo Open XML XLSX no caminho especificado.
O arquivo resultante abre no Excel, Google Sheets ou qualquer aplicativo que leia o formato XLSX. Os cabeçalhos das colunas aparecem na primeira linha e todas as linhas de dados seguem na mesma ordem em que apareceram no DataGridView.
Uma transferência de dados simples é funcional, mas não está pronta para apresentação. A API de estilo do IronXL permite aplicar fontes em negrito, cores de fundo, cores de texto e formatos numéricos a qualquer intervalo de células antes de salvar:
void ExportWithFormatting()
{
var workbook = WorkBook.Create();
var sheet = workbook.DefaultWorkSheet;
// Write column headers
for (int col = 0; col < DataGridView1.Columns.Count; col++)
{
sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
}
// Style the header row: bold white text on blue background
var headerRange = sheet.GetRange("A1:D1");
headerRange.Style.Font.Bold = true;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.SetColor("#FFFFFF");
// Locate the Salary column index
int salaryColIndex = -1;
for (int i = 0; i < DataGridView1.Columns.Count; i++)
{
if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
StringComparison.OrdinalIgnoreCase))
{
salaryColIndex = i;
break;
}
}
// Write data rows, preserving numeric types
for (int row = 0; row < DataGridView1.Rows.Count; row++)
{
if (DataGridView1.Rows[row].IsNewRow) continue;
for (int col = 0; col < DataGridView1.Columns.Count; col++)
{
object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
if (cellValue is null) continue;
int targetRow = row + 1;
if (col == salaryColIndex)
{
// Write salary as a true numeric decimal
if (decimal.TryParse(cellValue.ToString(),
System.Globalization.NumberStyles.Number,
System.Globalization.CultureInfo.InvariantCulture,
out decimal decValue))
{
sheet.SetCellValue(targetRow, col, decValue);
}
else
{
sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
}
}
else
{
sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
}
}
}
// Apply currency format to the salary column data range
var salaryRange = sheet.GetRange("D2:D5");
salaryRange.FormatString = "$#,##0";
workbook.SaveAs("FormattedEmployeeData.xlsx");
}Option Strict On
Option Infer On
Sub ExportWithFormatting()
Dim workbook = WorkBook.Create()
Dim sheet = workbook.DefaultWorkSheet
' Write column headers
For col As Integer = 0 To DataGridView1.Columns.Count - 1
sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
Next
' Style the header row: bold white text on blue background
Dim headerRange = sheet.GetRange("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.SetBackgroundColor("#4472C4")
headerRange.Style.Font.SetColor("#FFFFFF")
' Locate the Salary column index
Dim salaryColIndex As Integer = -1
For i As Integer = 0 To DataGridView1.Columns.Count - 1
If String.Equals(DataGridView1.Columns(i).HeaderText, "Salary", StringComparison.OrdinalIgnoreCase) Then
salaryColIndex = i
Exit For
End If
Next
' Write data rows, preserving numeric types
For row As Integer = 0 To DataGridView1.Rows.Count - 1
If DataGridView1.Rows(row).IsNewRow Then Continue For
For col As Integer = 0 To DataGridView1.Columns.Count - 1
Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
If cellValue Is Nothing Then Continue For
Dim targetRow As Integer = row + 1
If col = salaryColIndex Then
' Write salary as a true numeric decimal
Dim decValue As Decimal
If Decimal.TryParse(cellValue.ToString(), Globalization.NumberStyles.Number, Globalization.CultureInfo.InvariantCulture, decValue) Then
sheet.SetCellValue(targetRow, col, decValue)
Else
sheet.SetCellValue(targetRow, col, cellValue.ToString())
End If
Else
sheet.SetCellValue(targetRow, col, cellValue.ToString())
End If
Next
Next
' Apply currency format to the salary column data range
Dim salaryRange = sheet.GetRange("D2:D5")
salaryRange.FormatString = "$#,##0"
workbook.SaveAs("FormattedEmployeeData.xlsx")
End SubO método GetRange aceita notação padrão do Excel (A1:D1) para selecionar um bloco contínuo de células. Configurar Style.Font.Bold, Style.SetBackgroundColor, e Style.Font.SetColor aplica esses formatos a cada célula no intervalo selecionado. Para colunas numéricas, escrever o valor como um decimal em vez de uma string mantém o tipo de dado intacto, o que significa que o Excel pode aplicar formatação numérica como $#,##0 corretamente. Células armazenadas como strings não respondem a códigos de formato numérico.
Você pode estender este padrão para aplicar sombreamento de linha alternado, autoajuste de largura de coluna ou painéis congelados consultando a documentação de estilo do IronXL.
Alguns fluxos de trabalho requerem saída CSV para compatibilidade com sistemas legados ou pipelines de dados leves. O IronXL lida com a exportação CSV sem necessidade de alteração adicional na configuração principal do código:
void ExportToCsv()
{
var workbook = WorkBook.Create();
var sheet = workbook.DefaultWorkSheet;
for (int col = 0; col < DataGridView1.Columns.Count; col++)
{
sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
}
for (int row = 0; row < DataGridView1.Rows.Count; row++)
{
if (DataGridView1.Rows[row].IsNewRow) continue;
for (int col = 0; col < DataGridView1.Columns.Count; col++)
{
object? cell = DataGridView1.Rows[row].Cells[col].Value;
if (cell is not null)
sheet.SetCellValue(row + 1, col, cell.ToString()!);
}
}
// Saving with a .csv extension produces a comma-separated file
workbook.SaveAs("EmployeeData.csv");
}Sub ExportToCsv()
Dim workbook = WorkBook.Create()
Dim sheet = workbook.DefaultWorkSheet
For col As Integer = 0 To DataGridView1.Columns.Count - 1
sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
Next
For row As Integer = 0 To DataGridView1.Rows.Count - 1
If DataGridView1.Rows(row).IsNewRow Then Continue For
For col As Integer = 0 To DataGridView1.Columns.Count - 1
Dim cell As Object = DataGridView1.Rows(row).Cells(col).Value
If cell IsNot Nothing Then
sheet.SetCellValue(row + 1, col, cell.ToString())
End If
Next
Next
' Saving with a .csv extension produces a comma-separated file
workbook.SaveAs("EmployeeData.csv")
End SubA única mudança da exportação para XLSX é a extensão do arquivo passada para SaveAs. O IronXL detecta a extensão e serializa o livro de trabalho no formato correto automaticamente. Essa consistência significa que sua lógica de escrita de dados permanece idêntica, independentemente do formato de saída - uma vantagem significativa sobre bibliotecas que requerem caminhos de código separados para cada formato.
A exportação de CSV é especialmente útil quando o consumidor downstream é um script Python pandas, uma ferramenta de importação em massa de banco de dados, ou uma plataforma de análise que não consegue ler arquivos binários XLSX.
Para grades contendo dezenas de milhares de linhas, o desempenho se torna uma consideração. O padrão a seguir reduz a pressão de memória construindo o conjunto de dados completo em uma única passagem:
| Abordagem | Linhas processadas | Office necessário | Preservação de tipo |
|---|---|---|---|
| Microsoft.Office.Interop.Excel | Até ~65k (lento) | Sim | Parcial |
| IronXL (células de string) | 1M+ linhas | Não | Não (todo o texto) |
| IronXL (células tipadas) | 1M+ linhas | Não | Sim |
| IronXL a partir de DataTable | 1M+ linhas | Não | Sim (automático) |
Quando o DataGridView está vinculado a um DataTable, você pode carregar a tabela diretamente no IronXL usando o método WorkSheet.LoadDataTable, ignorando completamente a iteração célula a célula. Essa abordagem é mais rápida e preserva todos os tipos de coluna automaticamente.
Para grids que não são baseados em um DataTable, o padrão célula a célula mostrado anteriormente permanece como a abordagem padrão. Se você precisar exportar de forma assíncrona para manter a interface de usuário responsiva durante grandes exportações, envolva a lógica de exportação em uma chamada Task.Run e await o resultado em um thread em segundo plano. Veja a documentação de operações de arquivo assíncronas para padrões sobre como remeter os resultados de volta para o thread de UI.
Soluções tradicionais .NET usaram Microsoft.Office.Interop.Excel para dirigir um processo Excel em execução. Essa abordagem cria vários problemas de implantação e confiabilidade:
O IronXL escreve diretamente no formato de arquivo OOXML sem iniciar qualquer processo externo. Os aplicativos são implantados como unidades auto-suficientes. A API da biblioteca é totalmente gerenciada por .NET, então o coletor de lixo lida com memória automaticamente sem chamadas Marshal.ReleaseComObject. A velocidade é substancialmente maior porque não ocorre comunicação entre processos.
Para equipes avaliando alternativas, ClosedXML é uma opção popular de código aberto. O IronXL oferece um conjunto mais amplo de recursos, incluindo conversão para PDF, geração de gráficos, e suporte comercial, que podem ser fatores nas decisões de aquisição empresarial. Revise as opções de licenciamento do IronXL para corresponder o nível certo ao tamanho da sua equipe e cenário de implantação.
| Recurso | IronXL | Interoperação com o Office |
|---|---|---|
| Instalação do Office necessária | Não | Sim |
| Implantação em servidor / nuvem | Sim | Não (não suportado) |
| Modelo de memória gerida | Sim | Não (limpeza de COM necessária) |
| Formatos XLSX / CSV / XLS | Todos os três | Depende do Excel instalado |
| Exportação em PDF de planilha | Sim | Requer biblioteca adicional |
A seção de tutoriais do IronXL cobre leitura de arquivos Excel existentes, modificação de modelos, geração de gráficos e aplicação de formatação condicional - todas as capacidades que se estendem naturalmente a partir do padrão de exportação de DataGridView mostrado aqui.
Agora você tem código C# funcional para exportar um DataGridView para um arquivo Excel formatado usando o IronXL. A partir daqui, considere as seguintes direções:
try/catch e exiba uma mensagem amigável ao usuário se o arquivo estiver bloqueado ou o caminho for inválidoSaveFileDialog para permitir que os usuários escolham a localização e o nome do arquivo de saída em tempo de execuçãoDataTable de exemplo por uma consulta a banco de dados usando ADO.NET ou Entity FrameworkWorkSheet adicionais no mesmo WorkBook para organizar conjuntos de dados relacionados
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.
