Como exportar GridView para o Excel com formatação em C#

Como Você Instala a Biblioteca em um Projeto .NET?

Instale IronXL do NuGet antes de escrever qualquer código de exportação. Abra o Console do Gerenciador de Pacotes e execute:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

IronXL suporta .NET 8, .NET 9, e .NET 10, assim como .NET Framework 4.6.2 e posteriores. Após a instalação, adicione as seguintes diretivas using a qualquer arquivo que execute operações do Excel:

using IronXL;
using IronXl.Styles;

using IronXL;
using IronXl.Styles;

Não é necessário nenhum runtime adicional ou Interop do Office. A biblioteca escreve arquivos binários nativos XLSX que abrem de forma limpa no Microsoft Excel, LibreOffice Calc e Google Sheets.

Como Você Exporta um DataGridView do Windows Forms para Excel com Formatação de Células?

Aplicações Windows Forms usam o controle DataGridView em vez do baseado na web GridView. O padrão de exportação é o mesmo em ambos os casos: extrair valores de linhas e células, criar um livro de trabalho IronXL, aplicar estilos e, em seguida, salvar ou transmitir o resultado.

A abordagem mais confiável lança a propriedade DataSource do controle para um DataTable para evitar iterar as linhas visuais, que podem ser filtradas ou paginadas:

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Windows.Forms;

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Windows.Forms;

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

WorkBook.Create inicializa um novo livro de trabalho em memória no formato XLSX. DefaultWorkSheet retorna a primeira planilha, que você pode renomear através de sua propriedade Name antes de salvar. SetCellValue aceita strings, inteiros, doubles e valores DateTime -- IronXL seleciona automaticamente o tipo de célula correto.

O padrão de cor de linha alternada -- row % 2 == 0 seleciona #D6DCE5, caso contrário #FFFFFF -- espelha o estilo de tabela de linha demarcada embutido no Excel. Você pode substituir qualquer cor hex de seis caracteres que coincida com o sistema de design do seu aplicativo.

Como Você Exporta um GridView ASP.NET para Excel e Transmite o Arquivo para o Navegador?

Aplicativos web requerem um mecanismo de entrega diferente. Em vez de escrever para o sistema de arquivos, você serializa o livro de trabalho para um MemoryStream e o escreve na resposta HTTP com os cabeçalhos corretos para que o navegador o trate como um download de arquivo.

O importante passo prévio para GridViews paginados: desabilitar a paginação (AllowPaging = false) e reatribuir a fonte de dados antes de exportar para que todos os registros -- não apenas a página atual -- sejam capturados.

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// 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]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// 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]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

Response.AddHeader com content-disposition: attachment força um diálogo de download de arquivo em todos os navegadores modernos. O tipo MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet é o tipo registrado para arquivos XLSX e impede que o navegador tente exibir o conteúdo binário inline.

Para aplicações ASP.NET Core substitua Response.BinaryWrite por File(fileBytes, contentType, fileName) em uma ação de controlador -- a lógica de criação do livro de trabalho é idêntica.

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

Como você define larguras de coluna e congela a linha de cabeçalho?

Uma exportação Excel formatada profissionalmente inclui larguras de coluna apropriadas e uma linha de cabeçalho congelada para que os nomes das colunas permaneçam visíveis quando os usuários percorrem grandes conjuntos de dados.

IronXL expõe a largura das colunas através do acessador de coluna WorkSheet e o congelamento de cabeçalho através do método FreezeRows:

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

Para uso em produção, considere calcular a largura com base na contagem máxima de caracteres em cada coluna em vez de usar um valor fixo. Itere os valores da coluna DataTable, meça o comprimento da string e multiplique por um fator de largura de caractere apropriado para o tamanho de fonte escolhido.

Você também pode aplicar cor de fundo às células do Excel usando C# independentemente da lógica de faixas de linha para uma abordagem de estilo mais detalhada.

Como você exporta um DataTable para Excel sem um controle GridView?

Muitas aplicações .NET preenchem dados através de chamadas de serviço ou consultas de banco de dados e os mantêm em um DataTable sem nunca vinculá-los a um controle de interface do usuário. Você pode exportar um DataTable diretamente para Excel sem instanciar um GridView.

Esse é o caminho mais eficiente para trabalhos em segundo plano, relatórios agendados e endpoints de API que precisam produzir arquivos Excel no servidor:

using IronXL;
using IronXl.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    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]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

using IronXL;
using IronXl.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    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]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

Este método retorna um byte[] que você pode gravar no disco, transmitir de um endpoint de API, anexar a um email ou armazenar em memória. Para técnicas relacionadas, veja o guia sobre exportação de um DataTable para Excel e o tutorial sobre a maneira mais rápida de exportar um DataTable para Excel.

Como você lida com grandes conjuntos de dados e desempenho?

Exportar dezenas de milhares de linhas para Excel exige atenção à alocação de memória. Criar um novo objeto de estilo de célula para cada célula em uma grade grande é o gargalo de desempenho mais comum. Reutilize definições de estilo sempre que possível definindo estilos em objetos de intervalo em vez de células individuais:

Para GridViews paginados, sempre defina AllowPaging = false e reatribua antes da exportação. A paginação limita o número de linhas visíveis no controle, então uma exportação paginada captura apenas a página atual em vez do conjunto de dados inteiro -- uma fonte frequente de bugs de exportação incompletos.

Você também pode revisar o guia sobre exportar uma lista de objetos para Excel em C# para padrões que funcionam com coleções fortemente tipadas em vez de linhas DataTable não tipadas.

Como você exporta um GridView em ASP.NET Core ou Blazor?

Aplicações ASP.NET Core e Blazor não têm um controle GridView de Web Forms, mas o desafio subjacente de exportação de dados é o mesmo: pegue uma coleção de objetos ou um DataTable, construa um livro de trabalho estilizado e entregue um arquivo. O código de criação do livro de trabalho é idêntico; somente o mecanismo de entrega muda.

Em uma aplicação Blazor, dispare um download de arquivo através da interoperabilidade JavaScript:

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    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]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    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]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

O tutorial completo do padrão de download Blazor está no tutorial de exportação Blazor para Excel. Para uma abordagem de controlador ASP.NET Core, veja o tutorial de exportação ASP.NET Core para Excel.

Por Que Uma Biblioteca Nativa de Excel Produz Exportações Mais Limpas Que HtmlTextWriter?

A técnica tradicional de exportação do ASP.NET -- sobrescrevendo VerifyRenderingInServerForm, criando um StringWriter e HtmlTextWriter, e escrevendo o controle renderizado para a resposta -- produz um documento HTML com uma extensão .xls. O Microsoft Excel abre esses arquivos com um aviso de compatibilidade porque o arquivo não está realmente no formato binário do Excel ou OOXML. Os estilos são limitados ao CSS embutido que o Excel interpreta parcialmente. Formatação condicional é impossível. Usuários em plataformas diferentes do Windows ou usando o LibreOffice veem uma saída degradada.

O IronXL escreve diretamente no formato Open XML Spreadsheet (OOXML). O resultado é um arquivo .xlsx adequado -- idêntico ao que o próprio Excel cria -- que abre sem avisos no Excel, LibreOffice, Google Sheets e Numbers no macOS. A formatação é codificada como estilos de planilha, não atributos HTML, portanto, sobrevive a idas e vindas e visualização entre plataformas.

A documentação oficial da Microsoft sobre o Open XML SDK explica o formato subjacente que o IronXL produz. A especificação OOXML mantida pela ECMA International define o padrão que garante a compatibilidade entre aplicativos. A documentação do controle ASP.NET GridView na Microsoft Docs descreve o modelo de controle do qual os padrões de exportação acima leem.

Quais são os seus próximos passos?

Agora você tem os padrões necessários para exportar dados do GridView e DataGridView para arquivos XLSX devidamente formatados usando IronXL -- cobrindo Windows Forms, ASP.NET Web Forms, ASP.NET Core, e Blazor.

Para avançar mais:

• Inicie uma avaliação gratuita do IronXL para testar as capacidades completas de formatação e exportação com seus próprios dados.
• Revise a documentação do IronXL para referência completa da API, incluindo tabelas dinâmicas, gráficos e validação de dados.
• Explore criar relatórios no Excel em C# para combinar os padrões de exportação acima com resumos e gráficos calculados.
• Veja ler arquivos Excel em C# para o fluxo de trabalho de importação complementar quando seu aplicativo também precisar consumir planilhas carregadas.
• Para exportações baseadas em CSV juntamente com XLSX, veja o tutorial de exportação para CSV em C#.
• Se você exportar dados de um DataGridView com cabeçalhos de coluna como a primeira linha, veja o guia de DataGridView para Excel com cabeçalho de coluna.