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.
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 para .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):
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);
}Inclua este script no seu arquivo _Host.cshtml:
<script src="~/excelExport.js"></script>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.
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);
}
}
}Imports IronXL
Imports System.IO
Imports ExportExcel.Models
Public Class ExcelExportService
Public Function GenerateSalesReport(salesData As List(Of SalesData)) As Byte()
Try
Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
workbook.Metadata.Author = "Sales Department"
Dim 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"
Dim headerRange = worksheet("A1:E1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.Color = "#FFFFFF"
Dim row As Integer = 2
For Each sale In salesData
worksheet($"A{row}").Value = sale.Date.ToString("yyyy-MM-dd")
worksheet($"B{row}").Value = If(sale.Product, "Unknown")
worksheet($"C{row}").Value = sale.Quantity
worksheet($"D{row}").Value = sale.Revenue
worksheet($"E{row}").Value = $"=D{row}*0.15"
row += 1
Next
worksheet.AutoSizeColumn(0, True)
Using ms = workbook.ToStream()
Return ms.ToArray()
End Using
Catch ex As Exception
' If the program fails to return file
Throw New InvalidOperationException("Failed to generate sales report", ex)
End Try
End Function
End ClassEste 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.
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"
@Imports 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 Then
<span>Generating...</span>
Else
<span>Export Sales Report</span>
End If
</button>
@If Not String.IsNullOrEmpty(errorMessage) Then
<div class="alert alert-danger mt-2">@errorMessage</div>
End If
</div>
@code {
Private isExporting As Boolean = False
Private errorMessage As String = ""
Private Async Function ExportSalesReport() As Task
Try
isExporting = True
errorMessage = ""
' Generate sample data - replace with actual data source
Dim salesData = GetSalesData()
' Generate Excel file
Dim fileBytes = ExcelService.GenerateSalesReport(salesData)
' Trigger download using a memory stream to handle the file
Using stream As New MemoryStream(fileBytes)
Using streamRef As New DotNetStreamReference(stream)
Await JS.InvokeVoidAsync("downloadFileFromStream", $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef)
End Using
End Using
Catch ex As Exception
errorMessage = "Export failed. Please try again."
' Log exception details for debugging
Finally
isExporting = False
End Try
End Function
Private Function GetSalesData() As List(Of SalesData)
' Return your actual data here
Return New List(Of SalesData) From {
New SalesData With {.Date = DateTime.Now, .Product = "Widget A", .Quantity = 100, .Revenue = 5000},
New SalesData With {.Date = DateTime.Now.AddDays(-1), .Product = "Widget B", .Quantity = 75, .Revenue = 3750}
}
End Function
}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.
Quando executarmos nosso código, veremos nossa página carregada com o botão que será usado para gerenciar o processo de exportação.
Quando clicarmos no botão, os dados serão salvos em um novo documento Excel, e o arquivo exportado será baixado.
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();
}
}
}Imports IronXL
Imports ExportExcel.Models
Imports System.IO
Namespace ExportExcel.Services
Public Class InventoryExportService
Public Function GenerateInventoryReport(items As List(Of InventoryItem)) As Byte()
Dim workbook = WorkBook.Create()
Dim details = workbook.CreateWorkSheet("Inventory Details")
' Add headers
details("A1").Value = "SKU"
details("B1").Value = "Name"
details("C1").Value = "Quantity"
' Apply bold font for headers
Dim headerRange = details("A1:C1")
headerRange.Style.Font.Bold = True
For i As Integer = 0 To items.Count - 1
Dim row = i + 2 ' start from row 2
Dim 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 Then
details($"C{row}").Style.BackgroundColor = "#FFB6B6"
End If
Next
Using stream = workbook.ToStream()
Return stream.ToArray()
End Using
End Function
End Class
End NamespaceIronXL 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.
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.
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 bem estruturados e visualmente atraentes.
IronXL faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
A API do Excel que você precisa, sem as complicações do Office Interop.
