Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. Exportar para Excel usando Blazor
USANDO O IRONXL

Como exportar para o Excel em um projeto Blazor usando o IronXL

Jordi Bardia
Jordi Bardia
Atualizado:

Exportar dados para Excel é algo que quase todos os aplicativos web precisam, seja para gerar relatórios, listas de inventário ou faturas de clientes. Em uma aplicação Blazor Server, realizar isso de forma confiável sem exigir o Microsoft Office pode ser desafiador. É aí que IronXL entra. Ele permite criar, formatar e baixar arquivos Excel diretamente do seu servidor, sem a necessidade de instalação do Office, e se integra perfeitamente com o Blazor. Neste guia, você verá como é simples adicionar recursos de exportação de Excel profissionais ao seu aplicativo. Vamos começar.

Começando com IronXL para Exportar Dados para Excel

Configurar o IronXL em uma aplicação Blazor Server requer configuração mínima. Comece criando um novo projeto Blazor Server no Visual Studio 2022 ou posterior, direcionando for .NET 6 ou superior.

Instale o IronXL através do Console do Gerenciador de Pacotes NuGet (veja nosso guia de instalação completo para métodos alternativos):

Install-Package IronXl.Excel

Em seguida, crie uma função auxiliar em JavaScript para downloads de arquivos. Na sua pasta wwwroot, adicione um novo arquivo JavaScript 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:

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

Esta função JavaScript lida com o mecanismo de download pelo navegador, convertendo o fluxo de bytes da sua aplicação Blazor Server em um arquivo para download. A função cria uma URL blob temporária, aciona o download e limpa os recursos para evitar vazamentos de memória.

Como Exportar uma Fonte de Dados para Arquivos Excel com IronXL?

Crie um serviço de exportação Excel para lidar com sua lógica de negócio. Este serviço encapsula a funcionalidade IronXL e fornece métodos reutilizáveis para diferentes cenários de exportação na sua implementação Blazor de exportação Excel:

using IronXL;
using System.IO;
using ExportExcel.Models;
public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        try
        {
            var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            workbook.Metadata.Author = "Sales Department";
            var worksheet = workbook.CreateWorkSheet("Monthly Sales");
            worksheet["A1"].Value = "Date";
            worksheet["B1"].Value = "Product";
            worksheet["C1"].Value = "Quantity";
            worksheet["D1"].Value = "Revenue";
            worksheet["E1"].Value = "Profit Margin";
            var headerRange = worksheet["A1:E1"];
            headerRange.Style.Font.Bold = true;
            headerRange.Style.BackgroundColor = "#4472C4";
            headerRange.Style.Font.Color = "#FFFFFF";
            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();
        }
        catch (Exception ex)
        {
        // If the program fails to return file
            throw new InvalidOperationException("Failed to generate sales report", ex);
        }
    }
}
using IronXL;
using System.IO;
using ExportExcel.Models;
public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        try
        {
            var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            workbook.Metadata.Author = "Sales Department";
            var worksheet = workbook.CreateWorkSheet("Monthly Sales");
            worksheet["A1"].Value = "Date";
            worksheet["B1"].Value = "Product";
            worksheet["C1"].Value = "Quantity";
            worksheet["D1"].Value = "Revenue";
            worksheet["E1"].Value = "Profit Margin";
            var headerRange = worksheet["A1:E1"];
            headerRange.Style.Font.Bold = true;
            headerRange.Style.BackgroundColor = "#4472C4";
            headerRange.Style.Font.Color = "#FFFFFF";
            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();
        }
        catch (Exception ex)
        {
        // If the program fails to return file
            throw new InvalidOperationException("Failed to generate sales report", ex);
        }
    }
}
$vbLabelText   $csharpLabel

Este serviço demonstra recursos chave do IronXL, incluindo criação de novos livros e planilhas, adição de cabeçalhos formatados, preenchimento de linhas de dados com dados importados da sua fonte de dados, aplicação de fórmulas, e tratamento de possíveis erros. O método AutoSizeColumn garante que as colunas sejam exibidas corretamente, independentemente do comprimento do conteúdo. Para opções de formatação mais avançadas, explore nosso guia de estilo de células.

Como Implementar o Download de Arquivo no Blazor?

Crie um componente Razor que use o serviço de exportação e lide com a interação do usuário:

@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 = "";
            // Generate sample data - replace with actual data source
            var salesData = GetSalesData();
            // Generate Excel file
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            // Trigger download using a memory stream to handle the file
            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync("downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef);
        }
        catch (Exception ex)
        {
            errorMessage = "Export failed. Please try again.";
            // Log exception details for debugging
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        // Return your actual data here
        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 = "";
            // Generate sample data - replace with actual data source
            var salesData = GetSalesData();
            // Generate Excel file
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            // Trigger download using a memory stream to handle the file
            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync("downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef);
        }
        catch (Exception ex)
        {
            errorMessage = "Export failed. Please try again.";
            // Log exception details for debugging
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        // Return your actual data here
        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

Este componente fornece feedback ao usuário durante a exportação, trata erros graciosamente e gera nomes de arquivos com data e hora. O wrapper DotNetStreamReference permite a transmissão eficiente de dados binários para o JavaScript.

Saída

Quando executarmos nosso código, veremos nossa página carregada com o botão que será usado para gerenciar o processo de exportação.

Como Exportar para Excel em um Blazor Usando IronXL: Figura 1 - Página de exemplo Blazor

Quando clicarmos no botão, os dados serão salvos em um novo documento Excel, e o arquivo exportado será baixado.

Como Exportar para Excel em um Blazor Usando IronXL: Figura 2 - Dados exportados para um arquivo Excel

Quais Recursos Avançados o IronXL pode Adicionar à Sua Exportação Excel?

IronXL suporta recursos sofisticados do Excel para exportações com aparência profissional. Para um cenário de gerenciamento de inventário, você pode adicionar formatação condicional e múltiplas planilhas:

using IronXL;
using ExportExcel.Models;
using System.IO;
namespace ExportExcel.Services
{
    public class InventoryExportService
    {
        public byte[] GenerateInventoryReport(List<InventoryItem> items)
        {
            var workbook = WorkBook.Create();
            var details = workbook.CreateWorkSheet("Inventory Details");
            // Add headers
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            // Apply bold font for headers
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2; // start from row 2
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                // Highlight low stock items
                if (item.Quantity < item.ReorderLevel)
                {
                    details[$"C{row}"].Style.BackgroundColor = "#FFB6B6";
                }
            }
            using var stream = workbook.ToStream();
            return stream.ToArray();
        }
    }
}
using IronXL;
using ExportExcel.Models;
using System.IO;
namespace ExportExcel.Services
{
    public class InventoryExportService
    {
        public byte[] GenerateInventoryReport(List<InventoryItem> items)
        {
            var workbook = WorkBook.Create();
            var details = workbook.CreateWorkSheet("Inventory Details");
            // Add headers
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            // Apply bold font for headers
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2; // start from row 2
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                // Highlight low stock items
                if (item.Quantity < item.ReorderLevel)
                {
                    details[$"C{row}"].Style.BackgroundColor = "#FFB6B6";
                }
            }
            using var stream = workbook.ToStream();
            return stream.ToArray();
        }
    }
}
$vbLabelText   $csharpLabel

IronXL lida com múltiplas planilhas sem esforço, aplica formatação condicional com base em regras de negócio, e suporta recursos avançados do Excel, como tabelas dinâmicas e gráficos, quando necessário. Para documentação detalhada da API, visite nosso guia de referência abrangente.

Como Exportar para Excel em um Blazor Usando IronXL: Figura 3 - Exemplo de saída de recursos avançados

Conclusão

IronXL transforma a geração de arquivos Excel em aplicações Blazor Server de um desafio complexo em uma tarefa simples. Sua API intuitiva elimina a necessidade de instalações do Microsoft Office enquanto fornece acesso a recursos avançados do Excel. De exportações de dados simples a relatórios complexos com várias planilhas, fórmulas e formatação, IronXL lida com tudo com excelente desempenho e confiabilidade.

Pronto para aprimorar suas aplicações Blazor com capacidades de exportação de Excel profissional? Inicie seu teste gratuito para implantação em produção.

Perguntas frequentes

Como posso exportar arquivos do Excel em um aplicativo Blazor Server?

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

Preciso do Microsoft Office para trabalhar com arquivos do Excel no Blazor?

Não, o IronXL permite que você trabalhe com arquivos do Excel sem precisar do Microsoft Office. Ele oferece a funcionalidade de criar e manipular arquivos do Excel diretamente dentro do seu aplicativo Blazor.

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

O IronXL oferece integração perfeita com o Blazor, permitindo que você crie, formate e exporte arquivos do Excel com facilidade. Ele simplifica o processo, elimina a necessidade do Microsoft Office e oferece suporte a vários formatos do Excel.

O IronXL pode ser integrado com outros componentes do Blazor?

Sim, o IronXL integra-se perfeitamente com os componentes Blazor, permitindo que você adicione a funcionalidade de exportação para Excel aos seus aplicativos com facilidade.

É possível formatar arquivos do Excel usando o IronXL no Blazor?

Sim, o IronXL oferece recursos abrangentes para formatar arquivos do Excel, incluindo estilização de células, ajuste da largura das colunas e configuração de fórmulas complexas, tudo dentro do seu aplicativo Blazor Server.

Como lidar com grandes conjuntos de dados ao exportar para o Excel no Blazor?

O IronXL foi projetado para lidar com grandes conjuntos de dados de forma eficiente, garantindo um desempenho estável ao exportar grandes volumes de dados para arquivos do Excel em um ambiente Blazor Server.

Quais formatos de arquivo do Excel são suportados pelo IronXL?

O IronXL suporta vários formatos de arquivo do Excel, incluindo XLS, XLSX e CSV, permitindo flexibilidade na forma como você exporta e trabalha com dados do Excel em seus aplicativos Blazor.

O IronXL pode ser usado para gerar relatórios em Blazor?

Sem dúvida, o IronXL é ideal para gerar relatórios detalhados em aplicações Blazor. Ele oferece recursos robustos para compilar, formatar e exportar dados para relatórios profissionais em Excel.

Como o IronXL garante a integridade dos dados ao exportar arquivos do Excel?

O IronXL garante a integridade dos dados, preservando com precisão a estrutura e a formatação dos seus dados durante o processo de exportação, tornando-se uma solução confiável para aplicações Blazor.

Existe alguma maneira de automatizar a criação de arquivos Excel em um aplicativo Blazor Server usando o IronXL?

Sim, o IronXL pode ser usado para automatizar a criação e exportação de arquivos Excel em aplicativos Blazor Server, permitindo otimizar fluxos de trabalho e aumentar a eficiência.

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