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

Exportação do Blazor para o Excel: Guia completo usando IronXL em C#

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 o 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
Install-Package IronXL
SHELL

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)
        {
            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)
        {
            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 = "";
            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 ex)
        {
            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 }
        };
    }
}

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 um streaming eficiente de dados binários for 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.

Blazor Exportar para Excel: Guia Completo Usando IronXL em C#: Imagem 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.

Blazor Exportar para Excel: Guia Completo Usando IronXL em C#: Imagem 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");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var 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;
                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");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var 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;
                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.

Blazor Exportar para Excel: Guia Completo Usando IronXL em C#: Imagem 3 - Exemplo de saída com 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? Comece seu teste gratuito do IronXL hoje, ou explore nossas opções de licença para implantação em produção.

Perguntas frequentes

Como posso exportar arquivos do Excel em aplicativos Blazor Server?

Você pode usar o IronXL para exportar arquivos do Excel em aplicativos Blazor Server, criando, formatando e baixando arquivos XLSX diretamente do seu servidor, sem precisar do Microsoft Office.

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

Não, o IronXL não exige que o Microsoft Office esteja instalado no seu servidor para criar, formatar e exportar arquivos do Excel em aplicativos Blazor.

O IronXL pode ser integrado com aplicativos Blazor?

Sim, o IronXL integra-se perfeitamente com aplicativos Blazor, permitindo que você adicione recursos de exportação para Excel com facilidade.

Quais são alguns usos comuns para exportar arquivos do Excel em aplicativos da web?

Os usos comuns incluem a geração de relatórios, a criação de listas de inventário e a produção de faturas para clientes em formato Excel.

Existem exemplos de código disponíveis para exportar arquivos do Excel usando o IronXL?

Sim, o guia fornece exemplos de código para ajudar você a implementar recursos de exportação para Excel em seu aplicativo Blazor Server usando o IronXL.

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

Sim, o IronXL permite formatar arquivos do Excel, incluindo definir estilos, adicionar fórmulas e muito mais, diretamente em aplicativos Blazor.

Que tipos de arquivos do Excel posso criar com o IronXL?

Você pode criar arquivos XLSX usando o IronXL, que é um formato de arquivo Excel amplamente utilizado e compatível com a maioria dos aplicativos de planilha.

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