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

Como exportar para o Excel a partir de um GridView em C# usando o IronXL

Curtis Chau
Curtis Chau
Atualizado:

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.

Por que a abordagem tradicional de exportação do GridView causa problemas?

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:

  • O Excel mostra um aviso "O formato e a extensão do arquivo não correspondem" a cada abertura
  • A formatação e os tipos de dados são perdidos porque os dados são armazenados como HTML bruto
  • Você deve implementar VerifyRenderingInServerForm como uma solução alternativa, adicionando dívida técnica ao seu projeto
  • O arquivo resultante não possui metadados de célula adequados, tornando-o inutilizável para ferramentas de automação ou relatórios subsequentes

O 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.

Como Instalar o IronXL em Seu Projeto ASP.NET?

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:

Install-Package IronXL.Excel

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 .

Como Configurar o ASP.NET GridView para Exportação?

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>
<%@ 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>
$vbLabelText   $csharpLabel

Essa 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.

Vinculação de Dados de Amostra ao GridView

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;
        }
    }
}
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 Namespace
$vbLabelText   $csharpLabel

Armazenar 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.

Exportar para Excel do GridView em ASP.NET C#: Uma solução limpa em C#: Imagem 1 - Interface mostrando os dados de exemplo do GridView

Como Exportar Dados do GridView para Excel Usando IronXL?

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();
}
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 Sub
$vbLabelText   $csharpLabel

Como a Exportação Funciona Passo a Passo

O processo é dividido em três etapas lógicas:

  1. Recupere o DataTable -- Session["GridData"] retorna o mesmo DataTable que foi vinculado à grade. Isso evita chamadas duplicadas ao banco de dados.
  2. Contrastrua o WorkBook -- WorkBook.LoadWorkSheetsFromDataSet cria automaticamente uma planilha por DataTable no DataSet, copiando cabeçalhos de colunas e valores de linhas nas células apropriadas.
  3. Transmita para o navegador -- Definir 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#.

Exportar para Excel do GridView em ASP.NET C#: Uma solução limpa em C#: Imagem 2 - Arquivo Excel exportado

Como Salvar o Arquivo Excel no Disco em Vez de Transmiti-lo?

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 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
$vbLabelText   $csharpLabel

Escolhendo Entre Transmissão e Salvamento no Disco

Comparação de estratégias de exportação de transmissão vs. salvamento no disco
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.

Como aplicar formatação avançada à planilha Excel exportada?

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 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 Sub
$vbLabelText   $csharpLabel

Opções de formatação disponíveis no IronXL

O IronXL expõe um conjunto rico de propriedades de formatação por meio do namespace IronXL.Styles:

  • Estilização de fonte -- negrito, itálico, sublinhado, família de fontes e tamanho
  • Cores de fundo da célula -- strings de cor hexadecimal aceitas diretamente
  • Formatos de número e data -- qualquer string de formato Excel, incluindo moeda, porcentagem e padrões de data
  • Largura da coluna -- largura em pixels manual ou AutoSizeColumn para ajuste automático
  • Congelar painéis -- trancar linhas ou colunas de cabeçalho durante a rolagem
  • Bordas de célula -- todas as quatro bordas com estilo e cor configuráveis
  • Mesclar células -- combinar células através de linhas ou colunas para cabeçalhos de relatório

Para a referência completa da API, consulte a documentação de estilo de célula do IronXL e formatação numérica do IronXL.

Exportar para Excel do GridView em ASP.NET C#: Uma solução limpa em C#: Imagem 3 - Documento Excel formatado exportado

Como lidar com grandes conjuntos de dados em exportações de GridView?

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:

Paginação e DataTable do lado do servidor

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.

Adicionando Múltiplas Planilhas

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();
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()
$vbLabelText   $csharpLabel

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:

Quais são os principais benefícios de usar o IronXL para exportação de GridView?

Usar IronXL para exportar dados de GridView oferece claras vantagens sobre a abordagem tradicional de encapsulamento HTML:

  • Arquivos Excel genuínos -- cria formato .xlsx válido que abre sem avisos ou mensagens de erro do navegador
  • Sem instalação do Office necessária -- funciona em qualquer servidor web sem o Microsoft Excel ou interop do Office
  • Sem substituição VerifyRenderingInServerForm -- elimina a solução de otimização que polui códigos tradicionais
  • Controle total de formatação -- estilize células, aplique formatos de número, congele painéis e crie planilhas profissionais programaticamente
  • Suporte a múltiplas planilhas -- exporte conjuntos de dados relacionados como abas separadas em um único workbook
  • Compatibilidade multiplataforma -- funciona corretamente em servidores Windows e Linux, incluindo contêineres Docker e Azure App Service

A 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.

Quais são os seus próximos passos?

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:

  • Experimente o teste gratuito -- comece um teste gratuito de 30 dias do IronXL sem necessidade de cartão de crédito e teste o código de exportação em seu próprio projeto
  • Explore mais tutoriais IronXL -- o blog IronXL cobre importação de dados, fórmulas de células, geração de gráficos e fluxos de trabalho de modelos Excel
  • Leia a referência da API -- a documentação da API IronXL cobre todos os métodos de WorkBook, WorkSheet e da API de estilo
  • Compare opções de licenciamento -- veja preços do IronXL para encontrar a licença certa para o tamanho da sua equipe e cenário de implantação Faça uma pergunta -- a equipe de suporte da Iron Software e os fóruns da comunidade estão disponíveis caso você encontre algo inesperado.

Perguntas frequentes

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

O IronXL permite criar arquivos XLSX genuínos a partir do GridView no ASP.NET C# sem os problemas comuns associados ao HtmlTextWriter e ao StringWriter, como avisos do navegador e erros de formatação.

Quais são as limitações do uso do HtmlTextWriter para exportar para o Excel?

O HtmlTextWriter frequentemente cria arquivos Excel falsos que podem causar avisos no navegador e problemas de formatação. O IronXL resolve esses problemas gerando arquivos Excel verdadeiros.

Como o IronXL melhora o processo de exportação de dados do GridView?

O IronXL simplifica a exportação de dados do GridView, permitindo que os desenvolvedores gerem arquivos Excel formatados corretamente diretamente de seus aplicativos ASP.NET, eliminando a necessidade de soluções alternativas baseadas em HTML.

Qual formato de arquivo o IronXL utiliza para arquivos Excel exportados?

O IronXL exporta dados para arquivos XLSX genuínos, garantindo compatibilidade e formatação adequada quando abertos no Excel.

O IronXL pode ajudar com problemas de formatação ao exportar para o Excel?

Sim, o IronXL elimina problemas de formatação criando arquivos Excel verdadeiros, o que garante que os dados sejam exibidos corretamente sem acionar avisos do navegador.

Existe algum exemplo de código para exportar dados do GridView com o IronXL?

Sim, o tutorial inclui exemplos de código que demonstram como usar o IronXL para exportar dados do GridView para o Excel de forma eficiente e eficaz.

O IronXL suporta a exportação de grandes conjuntos de dados do GridView?

O IronXL foi projetado para lidar com grandes conjuntos de dados de forma eficiente, tornando-o adequado para exportar grandes quantidades de dados do GridView para o Excel.

Quais são as vantagens de usar o IronXL em comparação com os métodos tradicionais de exportação para Excel?

IronXL oferece uma solução mais confiável e eficiente, eliminando avisos do navegador, garantindo a formatação correta dos arquivos e fornecendo uma implementação de código direta para exportar dados do GridView.

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