Como posso exportar dados do GridView para o Excel em C#?

Você pode exportar dados do GridView para o Excel em C# usando a biblioteca IronXL. Ela permite criar arquivos do Excel programaticamente e exportar dados com facilidade, incluindo formatação e estilos.

Por que devo usar o IronXL para exportar dados do GridView?

O IronXL simplifica o processo de exportação de dados do GridView com sua API intuitiva, permitindo que você mantenha a formatação e aplique estilos sem esforço, o que pode ser difícil com os métodos tradicionais.

O IronXL suporta formatação ao exportar GridView para o Excel?

Sim, o IronXL oferece suporte a várias opções de formatação, incluindo fontes, cores e estilos de células, garantindo que seus arquivos Excel exportados tenham uma aparência profissional e mantenham o design pretendido.

Posso personalizar a aparência dos arquivos do Excel gerados a partir dos dados do GridView?

O IronXL oferece uma variedade de opções de personalização para arquivos do Excel, permitindo ajustar estilos de células, fontes, cores e muito mais para atender às suas necessidades específicas ao exportar do GridView.

É possível exportar grandes conjuntos de dados GridView para o Excel usando o IronXL?

O IronXL é capaz de lidar com grandes conjuntos de dados de forma eficiente, garantindo que você possa exportar dados extensos do GridView para o Excel sem problemas de desempenho.

Quais são as vantagens de exportar dados do GridView para o Excel usando o IronXL em comparação com outros métodos?

O IronXL oferece uma abordagem mais simplificada e flexível para exportar dados do GridView, fornecendo suporte robusto para formatação, personalização e manipulação de grandes conjuntos de dados, tornando-o superior a muitos outros métodos.

Como posso manter a integridade dos dados ao exportar um GridView para o Excel?

A IronXL garante a integridade dos dados convertendo e preservando com precisão os tipos e formatos de dados durante o processo de exportação do GridView para o Excel.

O IronXL consegue exportar dados de controles GridView com estruturas complexas?

Sim, o IronXL consegue manipular e exportar dados de controles GridView com estruturas complexas de forma eficaz, mantendo a hierarquia e a formatação no arquivo Excel resultante.

Em quais formatos de arquivo o IronXL pode exportar dados do GridView?

O IronXL exporta dados principalmente para formatos do Excel, como XLSX, mas também suporta outros formatos, como CSV, proporcionando flexibilidade de acordo com suas necessidades.

Existe suporte para exportar GridView com formatação condicional usando o IronXL?

O IronXL oferece suporte à formatação condicional, permitindo que você defina regras e estilos que se ajustam dinamicamente com base nos valores das células ao exportar dados do GridView para o Excel.

A biblioteca C# Excel

Explore Biblioteca IronXL para planilhas Excel em C# .NET Comece seu teste gratuito

Ler arquivos do Excel sem interoperabilidade

Veja todos os exemplos de código %s

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

USANDO O IRONXL

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

Curtis Chau

Updated: 28 de junho de 2026

Exportar dados do GridView para Excel preservando cores, fontes, planos de fundo alternados em linhas e bordas é um requisito que aparece em quase todos os aplicativos baseados em dados ASP.NET ou Windows Forms. A abordagem tradicional -- usando HtmlTextWriter e StringWriter para renderizar o controle como HTML -- produz arquivos que trazem avisos de formato no Excel e falham silenciosamente para os usuários. IronXL resolve isso gerando arquivos XLSX nativos inteiramente em C# sem dependência do Microsoft Office, dando controle preciso sobre o estilo de cada célula.

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:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

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;

Imports IronXL
Imports IronXL.Styles

Imports IronXL
Imports 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 workbook IronXL, aplicar estilos e, em seguida, salvar ou transmitir o resultado.

A abordagem mais confiável é converter 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);
}

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms

Dim dt As DataTable = DirectCast(dataGridView1.DataSource, DataTable)

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

' Header row -- bold, blue background, white text
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows -- alternating row color
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        Dim value As String = If(dt.Rows(row)(col)?.ToString(), String.Empty)
        sheet.SetCellValue(row + 1, col, value)

        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#D6DCE5", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
    Next
Next

' Save via dialog
Using saveDialog As New SaveFileDialog With {
    .Filter = "Excel Files|*.xlsx",
    .FileName = "GridViewExport.xlsx"
}
    If saveDialog.ShowDialog() = DialogResult.OK Then
        workBook.SaveAs(saveDialog.FileName)
        MessageBox.Show("Export successful.", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information)
    End If
End Using

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms

Dim dt As DataTable = DirectCast(dataGridView1.DataSource, DataTable)

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

' Header row -- bold, blue background, white text
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows -- alternating row color
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        Dim value As String = If(dt.Rows(row)(col)?.ToString(), String.Empty)
        sheet.SetCellValue(row + 1, col, value)

        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#D6DCE5", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
    Next
Next

' Save via dialog
Using saveDialog As New SaveFileDialog With {
    .Filter = "Excel Files|*.xlsx",
    .FileName = "GridViewExport.xlsx"
}
    If saveDialog.ShowDialog() = DialogResult.OK Then
        workBook.SaveAs(saveDialog.FileName)
        MessageBox.Show("Export successful.", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information)
    End If
End Using

WorkBook.Create inicializa um novo workbook na memória no formato XLSX. DefaultWorkSheet retorna a primeira folha, 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 linhas intercaladas embutido no Excel. Você pode substituir qualquer cor hex de seis caracteres que coincida com o sistema de design do seu aplicativo.

Imagens de Saída

Export GridView to Excel with Formatting C# Using IronXL: Image 1 - GridView Output

Export GridView to Excel with Formatting C# Using IronXL: Image 2 - Excel Output

Export GridView to Excel with Formatting C# Using IronXL: Image 3 - Message Output

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 gravar no sistema de arquivos, você serializa o workbook 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 passo importante de pré-voo para GridViews paginados: desative a paginação (AllowPaging = false) e reative 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();

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Web.UI

' Disable paging so all rows are captured
GridView1.AllowPaging = False
GridView1.DataBind()

Dim dt As DataTable = CType(GridView1.DataSource, DataTable)

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

' Header row
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#DEEAF1", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
        cell.Style.LeftBorder.Type = BorderType.Thin
        cell.Style.RightBorder.Type = BorderType.Thin
    Next
Next

' Stream to browser
Dim fileBytes As Byte() = 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()

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Web.UI

' Disable paging so all rows are captured
GridView1.AllowPaging = False
GridView1.DataBind()

Dim dt As DataTable = CType(GridView1.DataSource, DataTable)

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

' Header row
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#DEEAF1", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
        cell.Style.LeftBorder.Type = BorderType.Thin
        cell.Style.RightBorder.Type = BorderType.Thin
    Next
Next

' Stream to browser
Dim fileBytes As Byte() = 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 em linha.

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

Como você aplica formatação condicional com base nos valores das células?

A formatação condicional destaca células que atendem a critérios específicos -- por exemplo, marcando datas vencidas em vermelho ou sinalizando valores abaixo de um limite em laranja. IronXL aplica formatação condicional no nível da célula durante a construção da planilha:

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

Imports System

' Assume "DueDate" is column index 3 and "Amount" is column index 4
Dim today As DateTime = DateTime.Today

For row As Integer = 0 To dt.Rows.Count - 1
    ' Highlight past-due dates
    If dt.Columns.Contains("DueDate") AndAlso dt.Rows(row)("DueDate") IsNot DBNull.Value Then
        Dim dueDate As DateTime = Convert.ToDateTime(dt.Rows(row)("DueDate"))
        Dim dueDateCell = sheet.GetCellAt(row + 1, 3)
        If dueDate < today Then
            dueDateCell.Style.SetBackgroundColor("#FF0000")
            dueDateCell.Style.Font.Color = "#FFFFFF"
            dueDateCell.Style.Font.Bold = True
        End If
    End If

    ' Highlight amounts below threshold
    If dt.Columns.Contains("Amount") AndAlso dt.Rows(row)("Amount") IsNot DBNull.Value Then
        Dim amount As Decimal = Convert.ToDecimal(dt.Rows(row)("Amount"))
        Dim amountCell = sheet.GetCellAt(row + 1, 4)
        If amount < 100D Then
            amountCell.Style.SetBackgroundColor("#FFC000")
        End If
    End If
Next row

Imports System

' Assume "DueDate" is column index 3 and "Amount" is column index 4
Dim today As DateTime = DateTime.Today

For row As Integer = 0 To dt.Rows.Count - 1
    ' Highlight past-due dates
    If dt.Columns.Contains("DueDate") AndAlso dt.Rows(row)("DueDate") IsNot DBNull.Value Then
        Dim dueDate As DateTime = Convert.ToDateTime(dt.Rows(row)("DueDate"))
        Dim dueDateCell = sheet.GetCellAt(row + 1, 3)
        If dueDate < today Then
            dueDateCell.Style.SetBackgroundColor("#FF0000")
            dueDateCell.Style.Font.Color = "#FFFFFF"
            dueDateCell.Style.Font.Bold = True
        End If
    End If

    ' Highlight amounts below threshold
    If dt.Columns.Contains("Amount") AndAlso dt.Rows(row)("Amount") IsNot DBNull.Value Then
        Dim amount As Decimal = Convert.ToDecimal(dt.Rows(row)("Amount"))
        Dim amountCell = sheet.GetCellAt(row + 1, 4)
        If amount < 100D Then
            amountCell.Style.SetBackgroundColor("#FFC000")
        End If
    End If
Next row

Esse padrão é composicional -- adicione quantas verificações condicionais forem necessárias pelas suas exigências de relatório. Como IronXL opera em uma base célula por célula, você pode misturar formatação condicional com a lógica de cor de linha alternante aplicando o estilo condicional após o estilo base da linha.

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 da coluna através do acessador de colunas 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);

' Auto-size columns 0 through the last column index
For col As Integer = 0 To dt.Columns.Count - 1
    ' Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20)
Next

' 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 col As Integer = 0 To dt.Columns.Count - 1
    ' Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20)
Next

' 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 UI. Você pode exportar um DataTable diretamente para o 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();
}

Imports IronXL
Imports IronXL.Styles
Imports System.Data

Public Shared Function DataTableToExcelBytes(dt As DataTable, Optional sheetName As String = "Report") As Byte()
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.CreateWorkSheet(sheetName)

    ' Header
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    ' Data
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Return workBook.ToByteArray()
End Function

Imports IronXL
Imports IronXL.Styles
Imports System.Data

Public Shared Function DataTableToExcelBytes(dt As DataTable, Optional sheetName As String = "Report") As Byte()
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.CreateWorkSheet(sheetName)

    ' Header
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    ' Data
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Return workBook.ToByteArray()
End Function

Este método retorna um byte[] que você pode escrever em disco, transmitir a partir de um ponto de extremidade API, anexar a um e-mail ou armazenar em cache na 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:

Abordagens de Exportação do IronXL por Tamanho do Conjunto de Dados
Tamanho do Conjunto de Dados	Abordagem recomendada	Consideração fundamental
Até 5.000 linhas	Loop de estilo célula por célula	Código simples, sobrecarga insignificante
5.000 -- 50.000 linhas	Aplicação de estilo ao nível de intervalo	Reduz significativamente as alocações de objetos
50.000+ linhas	Exportação direta de DataTable, estilização mínima	Minimize operações por célula; use streaming, se disponível

Para GridViews paginados, sempre configure AllowPaging = false e reative antes de exportar. 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 sem tipo.

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: pegar uma coleção de objetos ou um DataTable, criar um workbook estilizado e entregar um arquivo. O código de criação do workbook é 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");
}

Imports IronXL
Imports System.Data
Imports Microsoft.JSInterop

Public Async Function ExportToExcelAsync(dt As DataTable, js As IJSRuntime) As Task
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.DefaultWorkSheet

    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Dim fileBytes As Byte() = workBook.ToByteArray()
    Dim base64 As String = Convert.ToBase64String(fileBytes)
    Await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
End Function

Imports IronXL
Imports System.Data
Imports Microsoft.JSInterop

Public Async Function ExportToExcelAsync(dt As DataTable, js As IJSRuntime) As Task
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.DefaultWorkSheet

    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Dim fileBytes As Byte() = workBook.ToByteArray()
    Dim base64 As String = Convert.ToBase64String(fileBytes)
    Await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
End Function

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.

Estilos de Fonte e Opções de Bordas

IronXL expõe controles granulares de fonte e borda através do objeto Style em cada célula. A gama completa de estilos de fonte do Excel em C# inclui negrito, itálico, sublinhado, tamanho e cor. Os tipos de borda disponíveis através de BorderType cobrem variantes fina, média, grossa, tracejada, pontilhada, dupla e várias variantes de linha fina.

Para linhas de cabeçalho mescladas ou rodapés de resumo, o IronXL também suporta mesclar células no Excel usando C# -- útil quando se deseja uma única célula de título abrangendo várias colunas acima de sua tabela de dados.

Para ajustar automaticamente a largura das colunas após preencher os dados, consulte o guia ajustar células no Excel usando C# para a abordagem recomendada.

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

A técnica tradicional de exportação ASP.NET -- sobrescrevendo VerifyRenderingInServerForm, criando um StringWriter e HtmlTextWriter, e escrevendo o controle renderizado na 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 apropriado -- idêntico ao que o próprio Excel cria -- que é aberto 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.

Comparação dos Métodos de Exportação para ASP.NET GridView
Método	Formato de Arquivo	Avisos de Formato	Suporte Completo a Estilos	Escritório necessário
HtmlTextWriter + StringWriter	HTML disfarçado como XLS	Sim	Não	Não
Interop de Escritório (COM)	XLS/XLSX Nativo	Não	Sim	Sim
IronXL	XLSX/XLS Nativo	Não	Sim	Não

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.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

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.

...