Como exportar um DataGridView para o Excel em C# com IronXL

Como Configurar um Projeto Windows Forms para Exportação para Excel?

Windows Forms é uma biblioteca GUI fundamental no ecossistema .NET, amplamente usada para construir aplicativos de desktop. O controle DataGridView é um dos componentes mais usados: ele exibe, edita e gerencia dados tabulares de qualquer fonte vinculável, como um DataTable, um resultado de consulta de banco de dados ou uma lista na 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.

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Como Preencher um DataGridView com Dados de Exemplo?

Para este passo a passo, o formulário contém um DataGridView chamado DataGridView1 e um botão chamado btnExport. A grade é preenchida 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;
}

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



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 Sub

Cada 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 a grade 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.

Como Exportar Dados do DataGridView para um Arquivo Excel com Cabeçalhos de Coluna?

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 das colunas na primeira linha e depois escreve cada linha de dados abaixo delas:

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");
}

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 Sub

O objeto WorkBook representa o arquivo Excel inteiro na memória. DefaultWorkSheet retorna a primeira folha sem a necessidade de você criar 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 desloca os dados abaixo da linha do cabeçalho. SaveAs escreve o livro de trabalho concluído como um arquivo Open XML XLSX para o 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.

Como Aplicar Formatação de Célula ao Arquivo Excel Exportado?

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");
}

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



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 Sub

O método GetRange aceita notação padrão do Excel (A1:D1) para selecionar um bloco contíguo de células. Definindo 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 formatar números como $#,##0 corretamente. Células armazenadas como strings não respondem a códigos de formato numérico.

Você pode estender esse padrão para aplicar sombreamento de linha alternado, ajuste automático da largura da coluna ou congelar painéis consultando a documentação de estilo do IronXL.

Como Exportar Dados do DataGridView para CSV em vez de XLSX?

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");
}

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 Sub

A única mudança da exportação 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.

Como você lida com conjuntos de dados grandes do DataGridView de forma eficiente?

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:

Quando o DataGridView é vinculado a um DataTable, você pode carregar a tabela diretamente no IronXL usando o método WorkSheet.LoadDataTable, ignorando a iteração célula a célula inteiramente. Essa abordagem é mais rápida e preserva todos os tipos de coluna automaticamente.

Para grades não suportadas por um DataTable, o padrão célula a célula mostrado anteriormente continua sendo a abordagem padrão. Se você precisar exportar de forma assíncrona para manter a interface responsiva durante grandes exportações, envolva a lógica de exportação em uma chamada Task.Run e await o resultado em um thread de 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.

Por que o IronXL é melhor do que o Interoperação com o Office para exportação de DataGridView?

Soluções tradicionais .NET usavam Microsoft.Office.Interop.Excel para dirigir um processo Excel em execução. Essa abordagem cria vários problemas de implantação e confiabilidade:

• Cada máquina que executa o aplicativo precisa de uma cópia licenciada do Microsoft Excel instalada
• Ambientes de servidor e contêineres em nuvem geralmente não podem instalar o Office
• O COM Interop requer liberação explícita de cada objeto para evitar vazamentos de memória e processos zombie do Excel
• O tratamento de erros através da fronteira COM é verboso e frágil
• O desempenho degrada rapidamente à medida que as contagens de linha aumentam

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 a coleta de lixo gerencia a 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 de recursos mais amplo, incluindo conversão em PDF, geração de gráficos, e suporte comercial, que podem ser fatores em 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.

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.

Quais são os seus próximos passos?

Agora você tem o código C# funcional para exportar um DataGridView para um arquivo Excel formatado usando IronXL. A partir daqui, considere as seguintes direções:

• Adicione tratamento de erros: Envolva o código de exportação em um bloco try/catch e exiba uma mensagem amigável ao usuário se o arquivo estiver bloqueado ou o caminho for inválido
• Suporte à seleção de caminho de arquivo: Use SaveFileDialog para permitir que os usuários escolham a localização e o nome do arquivo de saída em tempo de execução
• Carregar dados reais: Substitua o exemplar DataTable por uma consulta de banco de dados usando ADO.NET ou Entity Framework
• Ler arquivos existentes: Use WorkBook.Load para abrir uma planilha existente e atualizá-la em vez de sempre criar uma nova
• Exportar para várias planilhas: Crie objetos WorkSheet adicionais no mesmo WorkBook para organizar conjuntos de dados relacionados
• Aplicar formatação condicional: Destaque células que excedem limites usando a API de formatação condicional do IronXL
• Revisar as opções de licenciamento: Um teste gratuito está disponível; Os níveis de licenciamento cobrem desenvolvedores individuais até implantações empresariais
• Navegar na referência completa da API: A referência de objeto do IronXL documenta cada classe e método disponível