Exportar dados de GridView para um arquivo Excel genuíno é um dos requisitos mais comuns em aplicações web ASP.NET. Abordagens tradicionais usando HtmlTextWriter e StringWriter criam arquivos Excel falsos que acionam avisos do navegador e erros de formato quando os usuários tentam abri-los. Este guia mostra como exportar dados do GridView para arquivos .xlsx devidamente formatados usando o IronXL -- eliminando as dores de cabeça que os desenvolvedores enfrentam com métodos legados.
O método clássico para exportar para Excel a partir do GridView em ASP.NET C# envolve renderizar HTML e definir cabeçalhos Response com valores de nome de arquivo de anexo Content-Disposition. Essa abordagem requer substituir public override void VerifyRenderingInServerForm para evitar erros de tempo de execução. O arquivo resultante não é um verdadeiro arquivo Excel -- é HTML mascarando com uma extensão .xls, fazendo com que o Excel exiba mensagens de aviso quando os usuários o abrem.
Especificamente, a técnica tradicional tem estas desvantagens:
VerifyRenderingInServerForm como uma solução alternativa, adicionando dívida técnica ao seu projetoO IronXL resolve esses problemas criando arquivos Excel .xlsx genuínos sem exigir a instalação do Microsoft Office no servidor. Você obtém um arquivo que qualquer aplicativo de planilha pode abrir corretamente, com os tipos de dados apropriados, estilo e estrutura OOXML preservados.
Antes de escrever qualquer lógica de exportação, adicione IronXL ao seu projeto usando o Gerenciador de Pacotes NuGet. Abra o Contrasole do Gerenciador de Pacotes no Visual Studio e execute:
Alternativamente, procure por IronXL.Excel na interface do Gerenciador de Pacotes NuGet e instale a partir de lá. Uma vez instalado, você pode referenciar o namespace IronXL em qualquer arquivo code-behind.
IronXL é compatível com .NET Standard 2.0 e acima, funcionando em projetos modernos do ASP.NET Core, bem como em aplicativos clássicos do ASP.NET Framework. Não é necessário interop COM, instalação do Office ou dependências nativas adicionais no seu servidor web.
Para obter mais detalhes, consulte o guia de instalação do IronXL e a página do pacote NuGet do IronXL .
Crie sua página Default.aspx com um controle GridView e um botão de exportação. A marcação é padrão do Web Forms:
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
<title>Export GridView to Excel</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<h2>IronXL GridView Export Demo</h2>
<asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
</asp:GridView>
<br />
<asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
OnClick="btnExport_Click" />
</div>
</form>
</body>
</html>netEssa marcação cria uma página simples com um GridView vinculado e um botão que aciona a exportação. O atributo AutoGenerateColumns="true" significa que a grade lê os nomes das colunas diretamente do DataTable vinculado.
No seu code-behind, vincule um DataTable à grade e armazene em Session para uso posterior durante o postback da exportação:
using System;
using System.Data;
using System.Web.UI;
using IronXL;
namespace GridViewExport
{
public partial class Default : Page
{
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
BindGridView();
}
}
private void BindGridView()
{
DataTable dt = new DataTable("Employees");
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, "Mike Wilson", "Sales", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);
GridView1.DataSource = dt;
GridView1.DataBind();
// Store DataTable in Session for export postback
Session["GridData"] = dt;
}
}
}Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL
Namespace GridViewExport
Partial Public Class [Default]
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("Employees")
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, "Mike Wilson", "Sales", 70000)
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)
GridView1.DataSource = dt
GridView1.DataBind()
' Store DataTable in Session for export postback
Session("GridData") = dt
End Sub
End Class
End NamespaceArmazenar o DataTable em Session evita nova consulta ao banco de dados ou reconstrução dos dados durante o postback acionado pelo botão de exportação. Para aplicativos reais, substitua as linhas codificadas por uma consulta de banco de dados usando Entity Framework ou ADO.NET.
A abordagem limpa para exportação do GridView converte seu DataTable para um WorkBook do IronXL e transmite o resultado diretamente para o navegador. Aqui está o método completo de exportação:
protected void btnExport_Click(object sender, EventArgs e)
{
ExportGridViewToExcel();
}
private void ExportGridViewToExcel()
{
DataTable dt = (DataTable)Session["GridData"];
// Create a workbook and load data from the DataTable
WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Apply header row formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Size = 12;
headerRange.Style.SetBackgroundColor("#3AC0F2");
// Stream the file to the browser
string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=" + filename);
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();
}Imports System
Imports System.Data
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
ExportGridViewToExcel()
End Sub
Private Sub ExportGridViewToExcel()
Dim dt As DataTable = DirectCast(Session("GridData"), DataTable)
' Create a workbook and load data from the DataTable
Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Apply header row formatting
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.Font.Size = 12
headerRange.Style.SetBackgroundColor("#3AC0F2")
' Stream the file to the browser
Dim filename As String = "GridViewExport_" & DateTime.Now.ToString("yyyyMMdd") & ".xlsx"
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=" & filename)
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
Response.Flush()
Response.End()
End SubO processo é dividido em três etapas lógicas:
Session["GridData"] retorna o mesmo DataTable que foi vinculado à grade. Isso evita chamadas duplicadas ao banco de dados.WorkBook.LoadWorkSheetsFromDataSet cria automaticamente uma planilha por DataTable no DataSet, copiando cabeçalhos de colunas e valores de linhas nas células apropriadas.Content-Type para o tipo MIME OOXML e escrever em Response.OutputStream aciona um download no navegador com a extensão correta .xlsx. Nenhum arquivo temporário é escrito no disco.Isso é fundamentalmente diferente da abordagem legada HtmlTextWriter. O arquivo exportado utiliza o formato Open XML -- o mesmo formato que o Microsoft Excel utiliza nativamente -- então ele abre sem avisos.
Para mais informações sobre carregar dados programaticamente, consulte a documentação do IronXL WorkBook e como exportar DataTable para Excel em C#.
Se sua aplicação precisar arquivar exportações no servidor antes de entregar um link de download ao usuário, salve o workbook em um caminho de arquivo em vez de transmiti-lo para Response.OutputStream:
private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
// Ensure the exports directory exists
if (!System.IO.Directory.Exists(exportFolder))
{
System.IO.Directory.CreateDirectory(exportFolder);
}
string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");
workbook.SaveAs(filename);
// Return the relative path for generating a download link
string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}Private Sub SaveExcelToDisk(workbook As WorkBook, exportFolder As String)
' Ensure the exports directory exists
If Not System.IO.Directory.Exists(exportFolder) Then
System.IO.Directory.CreateDirectory(exportFolder)
End If
Dim timestamp As String = DateTime.Now.ToString("yyyyMMdd_HHmmss")
Dim filename As String = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx")
workbook.SaveAs(filename)
' Return the relative path for generating a download link
Dim relativePath As String = "~/Exports/Report_" & timestamp & ".xlsx"
Response.Write($"<script>alert('File saved to {relativePath}');</script>")
End Sub| Estratégia | Prós | Contras | Ideal para |
|---|---|---|---|
| Transmissão para navegador | Sem uso de disco, entrega imediata | Não pode arquivar ou reenviar | Exportações de usuário sob demanda |
| Salvar no disco | Arquivo persiste para auditoria, re-download ou e-mail | Requer trabalho de limpeza, gestão de espaço em disco | Relatórios agendados, trilhas de auditoria |
Para a maioria das aplicações web interativas, transmitir diretamente para o navegador é a escolha certa. Salve no disco quando precisar enviar o arquivo por e-mail, armazená-lo para conformidade ou permitir re-downloads de uma página de gestão de arquivos.
IronXL oferece controle detalhado sobre estilos de célula, larguras de coluna, formatos de número e mais. O exemplo a seguir mostra como construir uma exportação com estilo profissional:
private void ExportWithFormatting()
{
DataTable dt = new DataTable("Products");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Category", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("InStock", typeof(bool));
dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
dt.Rows.Add("Service Plan", "Support", 199.00m, true);
WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
WorkSheet sheet = workbook.WorkSheets[0];
// Style the header row
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.Font.Size = 13;
sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";
// Apply currency format to the Price column (column C, rows 2 onwards)
sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";
// Auto-size all columns for readability
for (int col = 0; col < 4; col++)
{
sheet.AutoSizeColumn(col);
}
// Freeze the header row so it stays visible when scrolling
sheet.FreezePanes(0, 0, 1, 0);
workbook.SaveAs("FormattedExport.xlsx");
}Private Sub ExportWithFormatting()
Dim dt As New DataTable("Products")
dt.Columns.Add("Product", GetType(String))
dt.Columns.Add("Category", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("InStock", GetType(Boolean))
dt.Rows.Add("Widget A", "Hardware", 29.99D, True)
dt.Rows.Add("Widget B", "Hardware", 49.99D, False)
dt.Rows.Add("Service Plan", "Support", 199.0D, True)
Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
Dim sheet As WorkSheet = workbook.WorkSheets(0)
' Style the header row
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.Font.Size = 13
sheet("A1:D1").Style.SetBackgroundColor("#2196F3")
sheet("A1:D1").Style.Font.Color = "#FFFFFF"
' Apply currency format to the Price column (column C, rows 2 onwards)
sheet("C2:C4").Style.NumberFormat.Format = "$#,##0.00"
' Auto-size all columns for readability
For col As Integer = 0 To 3
sheet.AutoSizeColumn(col)
Next
' Freeze the header row so it stays visible when scrolling
sheet.FreezePanes(0, 0, 1, 0)
workbook.SaveAs("FormattedExport.xlsx")
End SubO IronXL expõe um conjunto rico de propriedades de formatação por meio do namespace IronXL.Styles:
AutoSizeColumn para ajuste automáticoPara a referência completa da API, consulte a documentação de estilo de célula do IronXL e formatação numérica do IronXL.
Quando o GridView está vinculado a milhares de linhas, algumas técnicas mantêm a exportação rápida e eficiente em termos de memória:
Não exporte apenas a página visível do GridView. Recupere o conjunto completo de dados da sua fonte de dados em um DataTable antes de chamar WorkBook.LoadWorkSheetsFromDataSet. IronXL escreve linhas em uma única passada sem carregar o workbook inteiro na memória várias vezes, tornando-o adequado para dezenas de milhares de linhas.
Você pode incluir vários objetos DataTable no DataSet para produzir um workbook com abas separadas:
DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData()); // Sheet 1
exportSet.Tables.Add(GetDepartmentData()); // Sheet 2
exportSet.Tables.Add(GetSalaryReport()); // Sheet 3
WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();Imports System.Data
Imports IronXL
Dim exportSet As New DataSet()
exportSet.Tables.Add(GetEmployeeData()) ' Sheet 1
exportSet.Tables.Add(GetDepartmentData()) ' Sheet 2
exportSet.Tables.Add(GetSalaryReport()) ' Sheet 3
Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook)
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx")
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
Response.Flush()
Response.End()Cada DataTable.TableName se torna o nome da aba da planilha no Excel. Este padrão funciona bem para relatórios de gestão que combinam dados relacionados em várias visualizações.
Guias relacionadas:
Usar IronXL para exportar dados de GridView oferece claras vantagens sobre a abordagem tradicional de encapsulamento HTML:
.xlsx válido que abre sem avisos ou mensagens de erro do navegadorVerifyRenderingInServerForm -- elimina a solução de otimização que polui códigos tradicionaisA biblioteca está disponível no NuGet e suporta todos os targets modernos do .NET, incluindo .NET 10. Também suporta leitura e escrita de outros formatos, como CSV e ODS, o que a torna uma única dependência para todas as necessidades de planilhas em sua aplicação.
Para uma comparação lado a lado com outras bibliotecas Excel, veja IronXL vs ClosedXML e a visão geral dos recursos do IronXL.
Agora você tem tudo o que precisa para substituir a exportação legada do GridView HtmlTextWriter por uma implementação limpa e sem avisos do IronXL. Aqui está como avançar:
WorkBook, WorkSheet e da API de estilo
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.
