Ícone de mensagem
Ir para o conteúdo do rodapé
  1. Iron Software
  2. Blog IronXL
  3. Usando o IronXL
  4. Blog de exportação do Blazor para Excel
USANDO O IRONXL

Como exportar arquivos do Excel no Blazor usando o IronXL

Jordi Bardia
Jordi Bardia
Atualizado:

Exportar dados para Excel é algo que quase toda aplicação web Blazor precisa -- seja gerando relatórios de vendas, listas de inventário ou faturas para clientes. Em uma aplicação Blazor Server, realizar isso de maneira confiável sem exigir o Microsoft Office pode parecer intimidador. IronXL torna isso simples: você pode criar, formatar e baixar arquivos Excel diretamente do servidor, sem necessidade de instalação do Office. Este guia conduz você através da construção de uma funcionalidade de exportação para Excel pronta para produção em Blazor usando o IronXL -- desde a configuração do projeto e design do serviço a formatação avançada e relatórios multi-planilhas.

Como Configurar o IronXL em um Projeto Blazor Server?

Antes de escrever qualquer lógica de exportação, você precisa adicionar o IronXL a um projeto Blazor Server e configurar um auxiliador de download do lado do navegador.

Criando o Projeto Blazor Server

Comece criando um novo projeto Blazor Server no Visual Studio 2022 ou posterior, direcionando for .NET 10. Uma vez que o projeto esteja pronto, instale o IronXL através do Console do Gerenciador de Pacotes NuGet:

Install-Package IronXl.Excel

O IronXL funciona com o .NET 6 e posteriores, então projetos Blazor existentes podem adotá-lo sem atualizar o framework. Para métodos de instalação alternativos -- como a interface do NuGet ou CLI -- consulte o guia de instalação IronXL.

Adicionando o Auxiliar de Download em JavaScript

O Blazor Server roda no lado do servidor, portanto disparar um download de arquivo requer uma pequena ponte em JavaScript. Na sua pasta wwwroot, adicione um arquivo chamado excelExport.js:

window.downloadFileFromStream = async (fileName, contentStreamReference) => {
    const arrayBuffer = await contentStreamReference.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);
    const anchorElement = document.createElement('a');
    anchorElement.href = url;
    anchorElement.download = fileName ?? 'export.xlsx';
    anchorElement.click();
    anchorElement.remove();
    URL.revokeObjectURL(url);
}
window.downloadFileFromStream = async (fileName, contentStreamReference) => {
    const arrayBuffer = await contentStreamReference.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);
    const anchorElement = document.createElement('a');
    anchorElement.href = url;
    anchorElement.download = fileName ?? 'export.xlsx';
    anchorElement.click();
    anchorElement.remove();
    URL.revokeObjectURL(url);
}
JAVASCRIPT

Inclua este script no seu arquivo _Host.cshtml (ou App.razor em .NET 8+):

<script src="~/excelExport.js"></script>
<script src="~/excelExport.js"></script>
HTML

Esta função converte o fluxo de bytes do Blazor em uma URL de blob temporária, dispara o download no navegador, e então limpa o objeto URL para prevenir vazamentos de memória. É intencionalmente minimalista -- o processamento intenso acontece em C# no servidor.

!{--010011000100100101000010010100100100000101010010010110010101111101000111010001010101010100010111110101001101010100010000010101001001010100010001010100010001011111010101110100100 101010100010010000101111101010000010100100111101000100010101010100001101010100010111110101010001010010010010010010010100000101001100010111110100001001001100010011110100001101001011--}

Como Criar um Serviço de Exportação para Excel em C#?

Separar a geração de Excel de seus componentes Razor mantém o código testável e reutilizável em múltiplas páginas. O padrão abaixo encapsula o IronXL dentro de uma classe de serviço dedicada.

Construindo o ExcelExportService

Crie um novo arquivo Services/ExcelExportService.cs:

using IronXL;
using System.IO;
using ExportExcel.Models;

public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        workbook.Metadata.Author = "Sales Department";

        var worksheet = workbook.CreateWorkSheet("Monthly Sales");

        // Add column headers
        worksheet["A1"].Value = "Date";
        worksheet["B1"].Value = "Product";
        worksheet["C1"].Value = "Quantity";
        worksheet["D1"].Value = "Revenue";
        worksheet["E1"].Value = "Profit Margin";

        // Style the header row
        var headerRange = worksheet["A1:E1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.BackgroundColor = "#4472C4";
        headerRange.Style.Font.Color = "#FFFFFF";

        // Populate data rows
        int row = 2;
        foreach (var sale in salesData)
        {
            worksheet[$"A{row}"].Value = sale.Date.ToString("yyyy-MM-dd");
            worksheet[$"B{row}"].Value = sale.Product ?? "Unknown";
            worksheet[$"C{row}"].Value = sale.Quantity;
            worksheet[$"D{row}"].Value = sale.Revenue;
            worksheet[$"E{row}"].Value = $"=D{row}*0.15";
            row++;
        }

        worksheet.AutoSizeColumn(0, true);

        using var ms = workbook.ToStream();
        return ms.ToArray();
    }
}
using IronXL;
using System.IO;
using ExportExcel.Models;

public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        workbook.Metadata.Author = "Sales Department";

        var worksheet = workbook.CreateWorkSheet("Monthly Sales");

        // Add column headers
        worksheet["A1"].Value = "Date";
        worksheet["B1"].Value = "Product";
        worksheet["C1"].Value = "Quantity";
        worksheet["D1"].Value = "Revenue";
        worksheet["E1"].Value = "Profit Margin";

        // Style the header row
        var headerRange = worksheet["A1:E1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.BackgroundColor = "#4472C4";
        headerRange.Style.Font.Color = "#FFFFFF";

        // Populate data rows
        int row = 2;
        foreach (var sale in salesData)
        {
            worksheet[$"A{row}"].Value = sale.Date.ToString("yyyy-MM-dd");
            worksheet[$"B{row}"].Value = sale.Product ?? "Unknown";
            worksheet[$"C{row}"].Value = sale.Quantity;
            worksheet[$"D{row}"].Value = sale.Revenue;
            worksheet[$"E{row}"].Value = $"=D{row}*0.15";
            row++;
        }

        worksheet.AutoSizeColumn(0, true);

        using var ms = workbook.ToStream();
        return ms.ToArray();
    }
}
$vbLabelText   $csharpLabel

Registrando o Serviço

Adicione o serviço ao contêiner DI em Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();
builder.Services.AddScoped<ExcelExportService>();

var app = builder.Build();
app.MapBlazorHub();
app.MapFallbackToPage("/_Host");
app.Run();
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();
builder.Services.AddScoped<ExcelExportService>();

var app = builder.Build();
app.MapBlazorHub();
app.MapFallbackToPage("/_Host");
app.Run();
$vbLabelText   $csharpLabel

Este serviço demonstra várias capacidades chave do IronXL. Você pode criar novas pastas de trabalho e planilhas com uma única chamada de método, aplicar cabeçalhos estilizados, preencher linhas a partir de qualquer fonte de dados e incorporar fórmulas do Excel, tais como =D2*0.15. A chamada AutoSizeColumn garante que as colunas sejam largas o suficiente para exibir seu conteúdo corretamente, independentemente do comprimento dos dados. Para outras opções de formatação, veja o guia de estilo de células.

Como Disparar um Download de Excel de um Componente Blazor?

Uma vez que o serviço está no lugar, você precisa de um componente Razor que o chame e passe os bytes resultantes para o navegador.

Escrevendo o Componente Razor

Crie uma página em Pages/ExcelExportDashboard.razor:

@page "/excel-export"
@using ExportExcel.Models
@inject ExcelExportService ExcelService
@inject IJSRuntime JS

<h3>Excel Export Dashboard</h3>

<div class="export-section">
    <button class="btn btn-primary" @onclick="ExportSalesReport" disabled="@isExporting">
        @if (isExporting)
        {
            <span>Generating...</span>
        }
        else
        {
            <span>Export Sales Report</span>
        }
    </button>

    @if (!string.IsNullOrEmpty(errorMessage))
    {
        <div class="alert alert-danger mt-2">@errorMessage</div>
    }
</div>

@code {
    private bool isExporting = false;
    private string errorMessage = "";

    private async Task ExportSalesReport()
    {
        try
        {
            isExporting = true;
            errorMessage = "";

            var salesData = GetSalesData();
            var fileBytes = ExcelService.GenerateSalesReport(salesData);

            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync(
                "downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx",
                streamRef
            );
        }
        catch (Exception)
        {
            errorMessage = "Export failed. Please try again.";
        }
        finally
        {
            isExporting = false;
        }
    }

    private List<SalesData> GetSalesData()
    {
        return new List<SalesData>
        {
            new() { Date = DateTime.Now, Product = "Widget A", Quantity = 100, Revenue = 5000 },
            new() { Date = DateTime.Now.AddDays(-1), Product = "Widget B", Quantity = 75, Revenue = 3750 }
        };
    }
}
@page "/excel-export"
@using ExportExcel.Models
@inject ExcelExportService ExcelService
@inject IJSRuntime JS

<h3>Excel Export Dashboard</h3>

<div class="export-section">
    <button class="btn btn-primary" @onclick="ExportSalesReport" disabled="@isExporting">
        @if (isExporting)
        {
            <span>Generating...</span>
        }
        else
        {
            <span>Export Sales Report</span>
        }
    </button>

    @if (!string.IsNullOrEmpty(errorMessage))
    {
        <div class="alert alert-danger mt-2">@errorMessage</div>
    }
</div>

@code {
    private bool isExporting = false;
    private string errorMessage = "";

    private async Task ExportSalesReport()
    {
        try
        {
            isExporting = true;
            errorMessage = "";

            var salesData = GetSalesData();
            var fileBytes = ExcelService.GenerateSalesReport(salesData);

            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync(
                "downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx",
                streamRef
            );
        }
        catch (Exception)
        {
            errorMessage = "Export failed. Please try again.";
        }
        finally
        {
            isExporting = false;
        }
    }

    private List<SalesData> GetSalesData()
    {
        return new List<SalesData>
        {
            new() { Date = DateTime.Now, Product = "Widget A", Quantity = 100, Revenue = 5000 },
            new() { Date = DateTime.Now.AddDays(-1), Product = "Widget B", Quantity = 75, Revenue = 3750 }
        };
    }
}
$vbLabelText   $csharpLabel

O Que o Componente Faz

A flag isExporting desativa o botão durante a geração, evitando pedidos duplicados. O wrapper DotNetStreamReference lida com streaming binário eficiente do stream de memória .NET para a função JavaScript -- evitando grandes strings base64 que aumentariam o tamanho do payload. Nomes de arquivo com carimbo de data/hora, como SalesReport_20260228.xlsx, mantêm downloads organizados sem configuração adicional.

Quando você navega para /excel-export no navegador, a página do painel é carregada com um botão de exportação:

Blazor Export to Excel: Complete Guide Using IronXL in C#: Imagem 1 - Página de exemplo Blazor

Clicar no botão gera a planilha e o navegador baixa automaticamente o arquivo:

Blazor Export to Excel: Complete Guide Using IronXL in C#: Imagem 2 - Dados exportados para um arquivo Excel

Que Formatação Avançada Você Pode Aplicar às Exportações de Excel?

Exportações básicas de dados satisfazem muitos casos de uso, mas aplicativos de produção frequentemente precisam de formatação condicional, várias planilhas ou validação de dados. IronXL suporta tudo isso nativamente.

Formatação Condicional para Relatórios de Inventário

O serviço a seguir destaca itens com baixo estoque em vermelho -- um requisito comum para aplicativos de gerenciamento de armazéns ou inventário:

using IronXL;
using ExportExcel.Models;
using System.IO;

public class InventoryExportService
{
    public byte[] GenerateInventoryReport(List<InventoryItem> items)
    {
        var workbook = WorkBook.Create();
        var details = workbook.CreateWorkSheet("Inventory Details");

        // Column headers
        details["A1"].Value = "SKU";
        details["B1"].Value = "Name";
        details["C1"].Value = "Quantity";
        details["D1"].Value = "Reorder Level";
        details["E1"].Value = "Status";

        var headerRange = details["A1:E1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.BackgroundColor = "#2E75B6";
        headerRange.Style.Font.Color = "#FFFFFF";

        for (int i = 0; i < items.Count; i++)
        {
            int row = i + 2;
            var item = items[i];

            details[$"A{row}"].Value = item.SKU;
            details[$"B{row}"].Value = item.Name;
            details[$"C{row}"].Value = item.Quantity;
            details[$"D{row}"].Value = item.ReorderLevel;
            details[$"E{row}"].Value = item.Quantity < item.ReorderLevel
                ? "Reorder Required"
                : "OK";

            if (item.Quantity < item.ReorderLevel)
            {
                // Highlight the entire row for low-stock items
                details[$"A{row}:E{row}"].Style.BackgroundColor = "#FFB6B6";
                details[$"C{row}"].Style.Font.Bold = true;
            }
        }

        details.AutoSizeColumn(0, true);
        details.AutoSizeColumn(1, true);

        using var stream = workbook.ToStream();
        return stream.ToArray();
    }
}
using IronXL;
using ExportExcel.Models;
using System.IO;

public class InventoryExportService
{
    public byte[] GenerateInventoryReport(List<InventoryItem> items)
    {
        var workbook = WorkBook.Create();
        var details = workbook.CreateWorkSheet("Inventory Details");

        // Column headers
        details["A1"].Value = "SKU";
        details["B1"].Value = "Name";
        details["C1"].Value = "Quantity";
        details["D1"].Value = "Reorder Level";
        details["E1"].Value = "Status";

        var headerRange = details["A1:E1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.BackgroundColor = "#2E75B6";
        headerRange.Style.Font.Color = "#FFFFFF";

        for (int i = 0; i < items.Count; i++)
        {
            int row = i + 2;
            var item = items[i];

            details[$"A{row}"].Value = item.SKU;
            details[$"B{row}"].Value = item.Name;
            details[$"C{row}"].Value = item.Quantity;
            details[$"D{row}"].Value = item.ReorderLevel;
            details[$"E{row}"].Value = item.Quantity < item.ReorderLevel
                ? "Reorder Required"
                : "OK";

            if (item.Quantity < item.ReorderLevel)
            {
                // Highlight the entire row for low-stock items
                details[$"A{row}:E{row}"].Style.BackgroundColor = "#FFB6B6";
                details[$"C{row}"].Style.Font.Bold = true;
            }
        }

        details.AutoSizeColumn(0, true);
        details.AutoSizeColumn(1, true);

        using var stream = workbook.ToStream();
        return stream.ToArray();
    }
}
$vbLabelText   $csharpLabel

IronXL aplica formatação a nível de célula com base nos valores dos dados no momento da geração. Você também pode aplicar regras de formatação condicional de forma declarativa, ou gerenciar várias planilhas dentro do mesmo livro -- por exemplo, uma planilha para o estoque atual e outra para pedidos históricos.

Adicionando Várias Planilhas a Uma Única Exportação

Separar dados em planilhas lógicas melhora a legibilidade sem exigir downloads separados:

public byte[] GenerateMultiSheetReport(
    List<SalesData> sales,
    List<InventoryItem> inventory)
{
    var workbook = WorkBook.Create(ExcelFileFormat.XLSX);

    // Sheet 1 -- Sales summary
    var salesSheet = workbook.CreateWorkSheet("Sales");
    salesSheet["A1"].Value = "Date";
    salesSheet["B1"].Value = "Revenue";
    salesSheet["A1:B1"].Style.Font.Bold = true;

    for (int i = 0; i < sales.Count; i++)
    {
        salesSheet[$"A{i + 2}"].Value = sales[i].Date.ToString("yyyy-MM-dd");
        salesSheet[$"B{i + 2}"].Value = sales[i].Revenue;
    }

    // Sheet 2 -- Inventory snapshot
    var invSheet = workbook.CreateWorkSheet("Inventory");
    invSheet["A1"].Value = "SKU";
    invSheet["B1"].Value = "Name";
    invSheet["C1"].Value = "Quantity";
    invSheet["A1:C1"].Style.Font.Bold = true;

    for (int i = 0; i < inventory.Count; i++)
    {
        invSheet[$"A{i + 2}"].Value = inventory[i].SKU;
        invSheet[$"B{i + 2}"].Value = inventory[i].Name;
        invSheet[$"C{i + 2}"].Value = inventory[i].Quantity;
    }

    using var stream = workbook.ToStream();
    return stream.ToArray();
}
public byte[] GenerateMultiSheetReport(
    List<SalesData> sales,
    List<InventoryItem> inventory)
{
    var workbook = WorkBook.Create(ExcelFileFormat.XLSX);

    // Sheet 1 -- Sales summary
    var salesSheet = workbook.CreateWorkSheet("Sales");
    salesSheet["A1"].Value = "Date";
    salesSheet["B1"].Value = "Revenue";
    salesSheet["A1:B1"].Style.Font.Bold = true;

    for (int i = 0; i < sales.Count; i++)
    {
        salesSheet[$"A{i + 2}"].Value = sales[i].Date.ToString("yyyy-MM-dd");
        salesSheet[$"B{i + 2}"].Value = sales[i].Revenue;
    }

    // Sheet 2 -- Inventory snapshot
    var invSheet = workbook.CreateWorkSheet("Inventory");
    invSheet["A1"].Value = "SKU";
    invSheet["B1"].Value = "Name";
    invSheet["C1"].Value = "Quantity";
    invSheet["A1:C1"].Style.Font.Bold = true;

    for (int i = 0; i < inventory.Count; i++)
    {
        invSheet[$"A{i + 2}"].Value = inventory[i].SKU;
        invSheet[$"B{i + 2}"].Value = inventory[i].Name;
        invSheet[$"C{i + 2}"].Value = inventory[i].Quantity;
    }

    using var stream = workbook.ToStream();
    return stream.ToArray();
}
$vbLabelText   $csharpLabel

Para uma referência completa da API cobrindo propriedades de livros, operações de intervalo, e suporte a gráficos, visite a documentação da API do IronXL.

Blazor Export to Excel: Complete Guide Using IronXL in C#: Imagem 3 - Exemplo de saída de recursos avançados

Como Você Lida com Erros e Grandes Conjuntos de Dados de Forma Eficiente?

Operações de exportação de Excel podem falhar silenciosamente ou degradar o desempenho quando os conjuntos de dados são grandes. Os padrões abaixo abordam ambas as preocupações.

Tratamento de Erros na Camada de Serviço

Envolver a lógica de geração no serviço (em vez do componente) mantém o tratamento de erros consistente em todas as chamadas. O padrão recomendado é permitir que exceções do IronXL se propaguem, depois envolvê-las em uma exceção específica do domínio com o contexto sobre qual relatório falhou:

Coloque um bloco try/catch em torno da geração de pastas de trabalho em GenerateSalesReport, capturando Exception e lançando novamente como InvalidOperationException("Failed to generate sales report", ex). No componente Blazor, capture InvalidOperationException e exiba uma mensagem amigável ao usuário sem expor detalhes internos. Registre a exceção interna usando ILogger<t> injetado no construtor do serviço, de modo que a equipe de desenvolvimento possa rastrear falhas até uma operação específica de pasta de trabalho. Nunca exiba mensagens de exceção brutas para os usuários finais -- caminhos de arquivos, endereços de memória ou rastreamentos de pilha podem revelar detalhes internos do servidor.

Veja práticas recomendadas de tratamento de erros na documentação oficial da Microsoft para orientação sobre registro de erros estruturado no Blazor. Para obter mais orientações sobre como construir serviços testáveis em .NET, a documentação de injeção de dependência da Microsoft explica como registrar e resolver serviços com escopo, que é exatamente o padrão usado aqui com ExcelExportService.

Considerações de Desempenho para Grandes Conjuntos de Dados

Para conjuntos de dados que excedem algumas milhares de linhas, considere estas abordagens:

Estratégias de Desempenho de Exportação para Excel
Estratégia Quando Usar Suporte do IronXL
Transmita diretamente para a resposta Files >10 MB `workbook.ToStream()`
Paginar dados antes de exportar Exportações baseadas em UI com filtros Aplique no serviço antes de criar o livro
Trabalho em segundo plano + link de download Reports taking >5 seconds Combine com SignalR ou polling
Desabilitar AutoSizeColumn em planilhas grandes Sheets with >500 rows Defina larguras de coluna fixas em vez disso

O método ToStream() do IronXL grava diretamente em um stream de saída sem carregar o arquivo inteiro em um array de bytes primeiro, o que mantém o uso de memória mais baixo para pastas de trabalho grandes. Para orientações adicionais de desempenho, veja leitura e escrita de grandes arquivos Excel com IronXL.

Quais Outros Recursos do Excel o IronXL Suporta?

Além da exportação básica, o IronXL fornece uma ampla gama de recursos do Excel que cobre requisitos de relatórios do mundo real.

Fórmulas, Intervalos Nomeados e Formatação de Números

Você pode incorporar qualquer fórmula do Excel usando a mesma sintaxe que você digitaria diretamente em uma célula. IronXL avalia fórmulas no momento da leitura, para que os consumidores do arquivo gerado vejam resultados calculados assim que abrirem a planilha. Intervalos nomeados tornam as fórmulas mais legíveis e fáceis de manter ao longo do tempo:

// Aggregate formulas on a summary row
worksheet["E2"].Value = "=SUM(D2:D100)";
worksheet["F2"].Value = "=AVERAGE(C2:C100)";
worksheet["G2"].Value = "=COUNTIF(B2:B100,\"Widget A\")";

// Named ranges improve formula readability
worksheet["D2:D100"].Name = "RevenueColumn";
worksheet["E2"].Value = "=SUM(RevenueColumn)";

// Number and date formatting prevents type misinterpretation
worksheet["D2"].Value = 12345.67m;
worksheet["D2"].FormatString = "#,##0.00";
worksheet["A2"].Value = DateTime.Now;
worksheet["A2"].FormatString = "dd/MM/yyyy";
// Aggregate formulas on a summary row
worksheet["E2"].Value = "=SUM(D2:D100)";
worksheet["F2"].Value = "=AVERAGE(C2:C100)";
worksheet["G2"].Value = "=COUNTIF(B2:B100,\"Widget A\")";

// Named ranges improve formula readability
worksheet["D2:D100"].Name = "RevenueColumn";
worksheet["E2"].Value = "=SUM(RevenueColumn)";

// Number and date formatting prevents type misinterpretation
worksheet["D2"].Value = 12345.67m;
worksheet["D2"].FormatString = "#,##0.00";
worksheet["A2"].Value = DateTime.Now;
worksheet["A2"].FormatString = "dd/MM/yyyy";
$vbLabelText   $csharpLabel

Para definir intervalos nomeados e definir o formato do número explicitamente, IronXL expõe ambos como propriedades no objeto de intervalo. Isso impede o Excel de tratar valores monetários como texto simples -- um problema comum ao exportar dados financeiros de bancos de dados que armazenam valores como strings.

Formatos de Arquivos Excel Suportados

IronXL pode ler e escrever múltiplos formatos do Excel incluindo .xlsx, .xls, .csv e .tsv. O formato é determinado no momento da gravação, então a mesma classe de serviço pode suportar exportações Excel e CSV com uma pequena alteração de parâmetro:

// Export as CSV for systems that consume flat files
workbook.SaveAs("report.csv");

// Or stream as CSV for download
using var ms = workbook.ToStream(ExcelFileFormat.CSV);
// Export as CSV for systems that consume flat files
workbook.SaveAs("report.csv");

// Or stream as CSV for download
using var ms = workbook.ToStream(ExcelFileFormat.CSV);
$vbLabelText   $csharpLabel

Essa flexibilidade é importante em integrações onde sistemas a jusante -- como plataformas ERP ou armazéns de dados -- esperam um formato de arquivo específico. Para uma comparação completa de recursos entre IronXL e outras bibliotecas Excel, visite o página de recursos do IronXL.

A Microsoft fornece uma boa referência para compreender os formatos de arquivo OOXML se você precisar entender a estrutura interna de arquivos .xlsx ao depurar uma saída inesperada. O pacote NuGet para IronXL também está listado no NuGet.org com histórico completo de versões e notas de compatibilidade.

Como começar com o IronXL para projetos Blazor?

IronXL está disponível sob uma licença de desenvolvimento gratuita que permite criar e testar sem limite de tempo. Para aplicações de produção, é necessária uma licença de implantação.

Você pode baixar uma avaliação gratuita diretamente do NuGet -- não é necessário registro para começar. Quando estiver pronto para implantar, revise as opções de licenciamento do IronXL para encontrar o plano que se adequa à escala da aplicação.

O IronXL funciona em todos os principais tipos de aplicações .NET -- Blazor Server, Blazor WebAssembly (renderizado no servidor), ASP.NET Core MVC, aplicações de console e aplicativos de desktop Windows. A biblioteca visa o .NET Standard 2.0, por isso é compatível com todas as versões .NET suportadas desde o .NET Framework 4.6.2 até o .NET 10. Se o projeto também exigir geração de PDF, o IronPDF integra-se ao IronXL sem conflitos, permitindo exportar dados como Excel ou PDF a partir do mesmo nível de serviço.

Para explorar mais exemplos específicos de Blazor, veja o tutorial de exportação Excel com Blazor e o guia de exportação ASP.NET Core. Para ler planilhas existentes, o tutorial do leitor de Excel em C# cobre cenários comuns de importação. Você também pode revisar como criar um novo livro de Excel do zero para projetos que precisam criar arquivos programaticamente em vez de usar modelos.

Perguntas frequentes

Como posso exportar dados para o Excel em aplicativos Blazor Server?

Você pode usar o IronXL para exportar dados para o Excel em aplicativos Blazor Server. O IronXL permite criar, formatar e baixar arquivos do Excel diretamente do servidor, sem a necessidade do Microsoft Office.

Preciso ter o Microsoft Office instalado para usar o IronXL no Blazor?

Não, você não precisa ter o Microsoft Office instalado. O IronXL permite que você manipule arquivos do Excel em aplicativos Blazor Server independentemente do Microsoft Office.

Posso formatar arquivos do Excel usando o IronXL em aplicativos Blazor?

Sim, o IronXL fornece ferramentas para formatar arquivos do Excel, permitindo que você personalize a aparência dos seus dados diretamente do seu aplicativo Blazor Server.

O IronXL é compatível com aplicações Blazor Server?

Sim, o IronXL integra-se perfeitamente com aplicativos Blazor Server, permitindo a fácil exportação e manipulação de arquivos Excel.

Quais são os benefícios de usar o IronXL para exportar para Excel no Blazor?

O IronXL oferece uma maneira simples de criar e manipular arquivos do Excel sem a necessidade do Office, tornando-se uma solução eficiente para exportar dados em aplicativos Blazor.

O IronXL consegue lidar com arquivos Excel grandes em aplicativos Blazor Server?

Sim, o IronXL foi projetado para lidar com arquivos Excel grandes de forma eficiente em aplicativos Blazor Server.

Que tipos de arquivos do Excel posso criar com o IronXL em um aplicativo Blazor?

Com o IronXL, você pode criar vários tipos de arquivos Excel, incluindo XLSX, XLS e CSV, diretamente em seu aplicativo Blazor.

É possível baixar arquivos do Excel de um aplicativo Blazor Server usando o IronXL?

Sim, o IronXL permite o download de arquivos Excel diretamente de um aplicativo Blazor Server, proporcionando uma experiência perfeita para os usuários finais.

Como o IronXL melhora a funcionalidade de exportação para Excel no Blazor em comparação com outras soluções?

O IronXL simplifica o processo de exportação de arquivos Excel no Blazor, eliminando a necessidade do Microsoft Office e integrando-se diretamente ao seu aplicativo de servidor.

O que torna o IronXL uma boa escolha para desenvolvedores Blazor?

IronXL é uma boa opção para desenvolvedores Blazor porque oferece recursos robustos de manipulação do Excel, não requer a instalação do Office e se integra facilmente a aplicativos Blazor Server.

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