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.
Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:
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;Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXLIronXL 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.
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.
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.
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);
}
}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 ClassA 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.
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.
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.
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 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 SubAutoSizeColumn(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.
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)
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.FontColor = "#FFFFFF"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.
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 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 SubOs 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.
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.
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 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 SubPara 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.
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();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()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.
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"));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"))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.
| 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.
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.
Agora você tem três padrões prontos para produção para exportar dados do ASP.NET GridView para arquivos Excel XLSX usando IronXL:
GridView vinculadoOs próximos passos lógicos são:
MemoryStream e Response.BinaryWrite para que os usuários recebam o arquivo imediatamente, sem um caminho de salvamento do lado do servidor.DataTable usando a API de leitura do IronXL para fluxos de trabalho de importação/exportação de ida e volta.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.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronXL faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
A API do Excel que você precisa, sem as complicações do Office Interop.
