Ícone de mensagem
Ir para o conteúdo do rodapé
  1. Iron Software
  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

Jordi Bardia
Jordi Bardia
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 o IronXL, criando um WorkBook, iterando sobre as linhas do GridView, escrevendo cada valor de célula na posição correspondente da planilha e salvando o workbook 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 é fechar a lacuna entre o controle GridView do lado do servidor e um arquivo .xlsx devidamente estruturado -- sem introduzir dependências do Office Interop que quebram em ambientes de servidor web.

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

Como você instala oIronXLem um projeto ASP.NET?

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

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

Alternativamente, clique com o botão direito 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;
$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 correto do pacote é 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.

OIronXLFunciona 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 da planilha do Excel. Na marcação 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);
    }
}
$vbLabelText   $csharpLabel

A chamada WorkBook.Create(ExcelFileFormat.XLSX) inicializa um workbook na memória visando o formato moderno Open XML. CreateWorkSheet("Employees") adiciona a primeira planilha. 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 é utilizado para as células de dados para que o cabeçalho na linha 0 não seja sobreposto.

Por que UsarIronXLem 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.IronXLlê 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ê quiser que o navegador solicite um diálogo de salvamento de arquivo ao invés de servir os bytes inline, defina o tipo de conteúdo de resposta como application/vnd.openxmlformats-officedocument.spreadsheetml.sheet e adicione um cabeçalho Content-Disposition: attachment antes de escrever os bytes do workbook para o 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 ajustar 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);
}
$vbLabelText   $csharpLabel

AutoSizeColumn(col) instrui oIronXLa calcular a largura de coluna ideal com base no comprimento do conteúdo da célula, espelhando a ação Format > AutoFit Column Width na aplicação desktop do 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 estilização -- cabeçalhos em negrito, cores de fundo, formatos numéricos -- explore o tutorial de estilização de células do IronXL. Você também pode mesclar células para criar títulos de relatório abrangendo 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";
$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 paginação, ordenação e configurações de visibilidade de colunas. Exportar da DataTable subjacente armazenada 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);
}
$vbLabelText   $csharpLabel

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

Esse padrão é particularmente valioso quando o GridView usa paginação -- iterar gvEmployees.Rows só retorna 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 que excedem 100.000 linhas, considere agrupar chamadas SetCellValue dentro de uma única operação de planilha em vez de definir células individuais em um loop aninhado. Você também pode escrever o workbook para um MemoryStream e descarregá-lo para o fluxo Response de forma incremental para evitar manter o arquivo inteiro na RAM do servidor.

Como Lidar com Erros Durante a Exportação?

Manipuladores de exportação de produção devem envolver as operaçõesIronXLem um bloco catch e retornar uma mensagem descritiva ao usuário quando algo der errado. Os modos de falha comuns incluem diretório ~/Exports/ ausente, erros de permissão de arquivo, e ViewState sendo nulo após um tempo limite de 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}";
    }
}
$vbLabelText   $csharpLabel

Para aplicações web que entregam o arquivo como um download direto do navegador em vez de salvar no disco, use Response.BinaryWrite ou escreva para Response.OutputStream após definir os cabeçalhos de tipo de conteúdo e disposição. Certifique-se de que o diretório ~/Exports/ exista e a identidade do pool de aplicativos do IIS tenha permissão de escrita 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();
$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() descarrega a resposta e evita que marcações adicionais de página sejam anexadas após os dados binários.

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

Um único WorkBook pode conter várias planilhas, o que é útil quando você precisa exportar várias 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"));
$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,IronXLfornece suporte a fórmulas do Excel, formatação condicional, criação de gráficos e incorporação de imagens. Estas capacidades estão documentadas na seção de tutoriais do IronXL.

Como oIronXLse 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 oIronXLuma 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 que você precisa e se o suporte ao formato legado .xls é um requisito.

Quais formatos de Excel oIronXLsuporta?

OIronXLlê e escreve formatos .xlsx (Office Open XML), .xls (legado BIFF8), .csv, e .tsv. Você pode converter entre formatos de arquivo Excel com uma única chamada de API alterando o valor do enum ExcelFileFormat passado para WorkBook.Create ou carregando um arquivo existente e salvando-o 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 de iteração de linha -- o caminho mais rápido para uma exportação funcional 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 no servidor.
  2. Aplicar estilo de célula -- cabeçalhos em negrito, preenchimento de cor de fundo e formatos de número -- 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 do Excel de volta em objetos DataTable usando a API de leitura do IronXL para fluxos de trabalho de importação/exportação de round-trip.
  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 comIronXLpara exportar planilhas diretamente para PDF. O Iron Suite combinaIronXLcom 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.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados

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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me