Ícone de mensagem
Ir para o conteúdo do rodapé
  1. Recursos do IronPDF
  2. Blog IronXL
  3. Usando o IronXL
  4. Exportar GridView para Excel (XLSX)
USANDO O IRONXL

Como exportar GridView para Excel XLSX em C# usando IronXL

Curtis Chau
Curtis Chau
Atualizado:

Exportando Dados de um GridView ASP.NET para um Arquivo Excel

Você pode exportar um GridView do ASP.NET para um arquivo Excel XLSX em C# instalando IronXL, criando um WorkBook, iterando sobre as linhas do GridView, escrevendo cada valor de célula na posição correspondente na planilha e salvando o livro no disco ou no fluxo de resposta HTTP. Essa abordagem não requer instalação do Microsoft Office no servidor e funciona de forma confiável em todo o .NET Framework, .NET Core e .NET 5 até .NET 10 em aplicações web.

Exportar dados do GridView para Excel é um requisito padrão em projetos empresariais ASP.NET Web Forms. Os usuários precisam extrair dados tabulares do navegador e colocá-los em planilhas para relatórios, análise offline e arquivamento. O desafio é preencher a lacuna entre o controle GridView do lado do servidor e um arquivo .xlsx corretamente estruturado -- sem introduzir dependências do Office Interop que quebram em ambientes de servidor web.

Este guia orienta você através de três padrões de exportação progressivamente mais ricos: uma exportação mínima linha a linha, uma exportação de cabeçalho e dados com ajuste automático de colunas, e uma exportação DataTable que ignora o HTML renderizado por completo. Cada exemplo usa código compatível com instruções de nível superior em C# e a API do IronXL.

Como você instala o IronXL em um projeto ASP.NET?

Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:

Install-Package IronXL.Excel

Alternativamente, clique com o botão direito do mouse no projeto no Solution Explorer, escolha Manage NuGet Packages, procure por IronXL e clique em Install. O NuGet resolve automaticamente todas as dependências transitivas.

Após a instalação do pacote, adicione as seguintes diretivas using ao seu arquivo de code-behind:

using System;
using System.Data;
using System.Web.UI;
using IronXL;
using System;
using System.Data;
using System.Web.UI;
using IronXL;
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL
$vbLabelText   $csharpLabel

IronXL suporta .NET Framework 4.6.2 e posteriores, assim como .NET Core 3.1 e .NET 5 até .NET 10. Não é necessário instalar o Office ou registrar COM no servidor. Documentação completa da API está disponível na referência de objeto IronXL.

Qual ID de Pacote NuGet Devo Usar?

O ID do pacote correto é IronXL (não IronXL.Excel, que é um alias legado). Após a instalação, o assembly IronXL.dll é referenciado automaticamente. Você pode verificar a versão instalada checando o nó Packages no Solution Explorer ou executando dotnet list package no diretório do projeto.

O IronXL Funciona em Aplicações Web ASP.NET Core?

Sim. A mesma API funciona em projetos de ASP.NET Web Forms e ASP.NET Core (MVC ou Razor Pages). Em projetos Core, substitua Server.MapPath por IWebHostEnvironment.WebRootPath ou Path.Combine(Directory.GetCurrentDirectory(), "Exports") ao construir caminhos de arquivo do lado do servidor.

Como Exportar um GridView para um Arquivo Excel?

O padrão de exportação mais simples itera sobre cada linha renderizada no GridView e copia o texto de cada célula para a célula correspondente na planilha do Excel. Não markup ASPX, adicione um controle <asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true" /> e um botão <asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />. O atributo runat="server" torna ambos os controles acessíveis no code-behind.

O code-behind vincula dados de exemplo na primeira carga e exporta na clique do botão:

using System;
using System.Data;
using System.Web.UI;
using IronXL;

public partial class GridViewExport : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            BindGridView();
        }
    }

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));

        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

public partial class GridViewExport : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            BindGridView();
        }
    }

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));

        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Public Partial Class GridViewExport
    Inherits Page

    Protected Sub Page_Load(sender As Object, e As EventArgs)
        If Not IsPostBack Then
            BindGridView()
        End If
    End Sub

    Private Sub BindGridView()
        Dim dt As New DataTable()
        dt.Columns.Add("EmployeeID", GetType(Integer))
        dt.Columns.Add("Name", GetType(String))
        dt.Columns.Add("Department", GetType(String))
        dt.Columns.Add("Salary", GetType(Decimal))

        dt.Rows.Add(1, "John Smith", "Engineering", 75000)
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000)

        ViewState("EmployeeData") = dt
        gvEmployees.DataSource = dt
        gvEmployees.DataBind()
    End Sub

    Protected Sub btnExport_Click(sender As Object, e As EventArgs)
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

        ' Write header row
        For j As Integer = 0 To gvEmployees.HeaderRow.Cells.Count - 1
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells(j).Text)
        Next

        ' Write data rows
        For i As Integer = 0 To gvEmployees.Rows.Count - 1
            For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/EmployeeData.xlsx")
        workbook.SaveAs(filePath)
    End Sub
End Class
$vbLabelText   $csharpLabel

A chamada WorkBook.Create(ExcelFileFormat.XLSX) inicializa um livro de memórias visando o formato moderno Open XML. CreateWorkSheet("Employees") adiciona a primeira folha. O loop externo (i) avança através das linhas de dados; o loop interno (j) avança através das colunas. O índice de linha i + 1 é usado para células de dados para que o cabeçalho na linha 0 não seja sobrescrito.

Por que Usar IronXL em Vez do Excel Interop?

Excel Interop requer uma cópia licenciada do Microsoft Excel instalada no servidor e cria objetos COM que devem ser liberados explicitamente para evitar vazamentos de memória.IronXL lê e escreve arquivos .xlsx diretamente como pacotes Open XML -- sem COM, sem Office, sem boilerplate Marshal.ReleaseComObject. Isso o torna confiável em IIS, Azure App Service, Docker e outros ambientes de servidor onde o Office não está disponível.

Qual é o Tipo MIME Correto para Downloads de XLSX?

Quando você quer que o navegador apresente um diálogo de salvamento de arquivo em vez de servir os bytes de forma embutida, defina o tipo de conteúdo da resposta para application/vnd.openxmlformats-officedocument.spreadsheetml.sheet e adicione um cabeçalho Content-Disposition: attachment antes de escrever os bytes do livro no fluxo de resposta.

Como Adicionar Cabeçalhos de Coluna e Auto-Ajustar Colunas?

O exemplo básico escreve cabeçalhos extraídos de HeaderRow.Cells, mas uma exportação de produção também deve dimensionar automaticamente cada coluna para que os dados sejam legíveis sem ajustes manuais no Excel:

protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

    ' Write column headers
    Dim colCount As Integer = gvEmployees.HeaderRow.Cells.Count
    For i As Integer = 0 To colCount - 1
        Dim header As String = gvEmployees.HeaderRow.Cells(i).Text
        worksheet.SetCellValue(0, i, header)
    Next

    ' Write data rows
    For i As Integer = 0 To gvEmployees.Rows.Count - 1
        For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
        Next
    Next

    ' Auto-size each column for readability
    For col As Integer = 0 To colCount - 1
        worksheet.AutoSizeColumn(col)
    Next

    Dim filePath As String = Server.MapPath("~/Exports/EmployeeReport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

AutoSizeColumn(col) instrui o IronXL a calcular a largura ideal da coluna com base no comprimento do conteúdo da célula, espelhando a ação Formatar > Ajuste automático da largura da coluna no aplicativo de desktop Excel. Chamando isso em um loop após escrever todos os dados é mais eficiente do que chamá-lo após cada linha porque o conteúdo final é conhecido nesse ponto.

Para opções adicionais de estilo -- cabeçalhos em negrito, cores de fundo, formatos de número -- explore o tutorial de estilo de célula do IronXL. Você também pode mesclar células para criar títulos de relatórios que abrangem várias colunas.

Como Aplicar Formatação em Negrito a Células de Cabeçalho?

Use o objeto IStyle retornado por worksheet["A1"].Style (ou um intervalo). Defina Font.Bold = true antes ou depois de escrever os valores -- o estilo é desacoplado do conteúdo da célula:

// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
' Bold the entire header row (columns A through D)
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.FontColor = "#FFFFFF"
$vbLabelText   $csharpLabel

Este padrão se aplica uniformemente a intervalos de qualquer tamanho. Para uma lista completa de propriedades de estilo, veja a referência de API de estilização do IronXL.

Como Exportar Dados Diretamente de um DataTable?

Iterar sobre as linhas renderizadas GridView vincula sua exportação ao estado visual atual do controle, que pode ser afetado por configurações de paginação, ordenação e visibilidade de colunas. Exportar do DataTable subjacente armazenado em ViewState produz um resultado determinístico, independentemente de como a grade está configurada:

protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
    If sourceData Is Nothing Then
        Response.Write("No data available to export.")
        Return
    End If

    Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Report")

    ' Column headers from DataTable schema
    For i As Integer = 0 To sourceData.Columns.Count - 1
        worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
    Next

    ' Data rows from DataRow objects
    For i As Integer = 0 To sourceData.Rows.Count - 1
        For j As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
        Next
    Next

    Dim filePath As String = Server.MapPath("~/Exports/DataExport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

Os nomes das colunas vêm de DataTable.Columns[i].ColumnName, que reflete o esquema de dados original, em vez de quaisquer substituições de nome de exibição aplicadas no modelo GridView. Os valores das células são recuperados de objetos DataRow usando o índice da coluna, lançando cada valor para string para satisfazer SetCellValue.

Esse padrão é particularmente valioso quando o GridView usa paginação -- iterar gvEmployees.Rows retorna apenas as linhas na página atualmente visível, enquanto ler do DataTable completo exporta todos os registros.

O Que Acontece com Exportações de DataTable Grandes?

IronXL transmite dados de workbook de forma eficiente para grandes conjuntos de dados Excel. Para exportações superiores a 100.000 linhas, considere agrupar chamadas SetCellValue dentro de uma única operação de planilha, em vez de definir células individualmente em um loop aninhado. Você também pode escrever o livro em um MemoryStream e liberá-lo para o fluxo Response de forma incremental, evitando manter o arquivo inteiro na memória RAM do servidor.

Como Lidar com Erros Durante a Exportação?

Os manipuladores de exportação de produção devem envolver as operações do IronXL em um bloco catch e retornar uma mensagem descritiva ao usuário quando algo der errado. Modos comuns de falha incluem diretório ~/Exports/ ausente, erros de permissão de arquivo e ViewState sendo nulo após um tempo limite da sessão:

protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Try
        Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
        If sourceData Is Nothing Then
            Throw New InvalidOperationException("Session data has expired. Please reload the page.")
        End If

        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

        For i As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
        Next

        For i As Integer = 0 To sourceData.Rows.Count - 1
            For j As Integer = 0 To sourceData.Columns.Count - 1
                worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/SafeExport.xlsx")
        workbook.SaveAs(filePath)

        lblStatus.Text = "Export successful. File saved to server."
    Catch ex As Exception
        lblStatus.Text = $"Export failed: {ex.Message}"
    End Try
End Sub
$vbLabelText   $csharpLabel

Para aplicativos web que entregam o arquivo como um download direto do navegador em vez de salvá-lo no disco, use Response.BinaryWrite ou escreva em Response.OutputStream depois de definir os cabeçalhos de tipo de conteúdo e disposição. Certifique-se de que o diretório ~/Exports/ exista e que a identidade do pool de aplicativos IIS tenha permissão de gravação nele.

Como enviar o arquivo XLSX como um download do navegador?

Substitua workbook.SaveAs(filePath) por uma resposta baseada em fluxo:

using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
Imports System.IO

' ... inside btnExport_Click after populating the worksheet ...

Dim fileBytes As Byte()
Using ms As New MemoryStream()
    workbook.SaveAs(ms)
    fileBytes = ms.ToArray()
End Using

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()
$vbLabelText   $csharpLabel

Este padrão evita a escrita de um arquivo temporário no disco. O MemoryStream é alocado no servidor, serializado para byte[] e enviado diretamente para o cliente. A chamada Response.End() libera a resposta e impede que a marcação adicional de página seja anexada após os dados binários.

Como exportar múltiplas planilhas ou livros avançados?

Um único WorkBook pode conter várias folhas, o que é útil quando você precisa exportar vários GridViews -- ou o mesmo conjunto de dados em diferentes granularidades -- em um único arquivo. Chame workbook.CreateWorkSheet(name) uma vez para cada guia:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

Dim summary As WorkSheet = workbook.CreateWorkSheet("Summary")
Dim detail As WorkSheet = workbook.CreateWorkSheet("Detail")

' Populate summary sheet ...
' Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"))
$vbLabelText   $csharpLabel

IronXL também suporta ler arquivos Excel existentes, para que você possa carregar um modelo pré-construído com marca e formatação, injetar dados em células específicas e salvar o resultado -- preservando gráficos, imagens e estilos já presentes no modelo.

Para uma saída ainda mais rica, o IronXL oferece suporte a fórmulas do Excel, formatação condicional, criação de gráficos e inclusão de imagens. Estas capacidades estão documentadas na seção de tutoriais do IronXL.

Como o IronXL se compara aoEPPluse ClosedXML?

Recurso IronXL EPPlus ClosedXML
Instalação do Office necessária Não Não Não
Leitura e escrita de XLSX Sim Sim Sim
Suporte a XLS (legado) Sim Não Não
Exportação CSV / TSV Sim Não Parcial
API de criação de gráfico Sim Sim Limitado
Modelo de licença Perpétua + SaaS Polyform não comercial MIT
Suporte a .NET 10 Sim Sim Sim

EPPlus mudou para uma licença comercial na versão 5, tornando o IronXL uma alternativa natural para equipes já investindo em um ecossistema de bibliotecas comerciais .NET. ClosedXML permanece com licença MIT, mas tem suporte limitado a gráficos. A escolha certa depende das restrições de licenciamento do seu projeto, dos recursos do Excel de que você precisa e se o suporte ao formato legado .xls é um requisito.

Quais formatos de Excel o IronXL suporta?

IronXL lê e escreve .xlsx (Office Open XML), .xls (legado BIFF8), .csv e formatos .tsv. Você pode converter entre formatos de arquivo Excel com uma única chamada de API alterando o valor enum ExcelFileFormat passado para WorkBook.Create ou carregando um arquivo existente e salvando em um formato diferente.

Quais são os seus próximos passos?

Agora você tem três padrões prontos para produção para exportar dados do ASP.NET GridView para arquivos Excel XLSX usando IronXL:

  • Exportação por iteração de linha -- o caminho mais rápido para uma exportação funcional a partir de um GridView vinculado
  • Exportação de cabeçalhos e formatação -- adiciona redimensionamento automático de colunas e cabeçalhos em negrito para relatórios apresentáveis
  • Exportação baseada em DataTable -- ignora completamente o controle renderizado para grades paginadas ou filtradas

Os próximos passos lógicos são:

  1. Adicione uma resposta de download do navegador usando MemoryStream e Response.BinaryWrite para que os usuários recebam o arquivo imediatamente, sem um caminho de salvamento do lado do servidor.
  2. Aplicar estilo às células -- cabeçalhos em negrito, preenchimentos de cor de fundo e formatos numéricos -- usando a API de formatação do IronXL.
  3. Explorar livros com múltiplas folhas para combinar dados de resumo e detalhamento em um único arquivo entregue aos interessados.
  4. Leia arquivos Excel de volta em objetos DataTable usando a API de leitura do IronXL para fluxos de trabalho de importação/exportação de ida e volta.
  5. Comece um teste gratuito em ironsoftware.com/csharp/excel/ para testar todas as funcionalidades em seu projeto com uma licença de teste de capacidade total.

Para equipes construindo pipelines de geração de documentos, IronPDF integra-se com IronXL para exportar planilhas diretamente para PDF. O Iron Suite combina IronXL com IronPDF, IronOCR, IronBarcode e IronZIP a um preço reduzido.

Perguntas frequentes

Qual é o principal objetivo de usar o IronXL para exportar um GridView para o Excel?

O IronXL é usado principalmente para facilitar a exportação de dados de um GridView do ASP.NET para formatos do Excel, como XLSX, garantindo alto desempenho e facilidade de integração em aplicativos C#.

O IronXL consegue lidar com grandes conjuntos de dados ao exportar do GridView?

Sim, o IronXL é otimizado para lidar de forma eficiente com grandes conjuntos de dados durante o processo de exportação do GridView para o Excel, mantendo a velocidade e o desempenho.

É possível personalizar a saída do Excel ao usar o IronXL?

Com o IronXL, você pode personalizar vários aspectos da saída do Excel, como formatação, estilo e inclusão de dados ou fórmulas adicionais no arquivo exportado.

Como o IronXL se compara a outras bibliotecas para exportar GridView para o Excel?

Em comparação com outras bibliotecas, a IronXL oferece uma abordagem mais direta e flexível, fornecendo suporte para formatos modernos do Excel e integração direta com aplicativos C#.

O IronXL suporta a exportação para formatos diferentes de XLSX?

Sim, o IronXL suporta a exportação para vários formatos do Excel, incluindo XLS, CSV e TSV, proporcionando versatilidade para diferentes requisitos de projeto.

Quais são os pré-requisitos para usar o IronXL em um projeto?

Para usar o IronXL, você precisa de um ambiente .NET e pode instalá IronXL via NuGet em seu projeto C#.

O IronXL consegue exportar dados do GridView de forma assíncrona?

O IronXL suporta operações assíncronas, permitindo que os desenvolvedores exportem dados do GridView para arquivos do Excel sem bloquear a thread principal do aplicativo.

Como posso começar a usar o IronXL para exportar GridView para o Excel?

Para começar, consulte a documentação e os exemplos do IronXL, que fornecem orientações passo a passo sobre como configurar e executar exportações de dados do GridView para o Excel.

Curtis Chau
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 ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de Suporte Iron

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim