Exportar datos a Excel es algo que casi todas las aplicaciones web necesitan, ya sea para generar informes, listas de inventario o facturas de clientes. En una aplicación Blazor Server, lograr esto de manera confiable sin requerir Microsoft Office puede ser un desafío. Ahí es donde entra IronXL. Permite crear, formatear y descargar archivos de Excel directamente desde su servidor, sin necesidad de instalación de Office, y se integra perfectamente con Blazor. En esta guía, verá lo simple que es añadir funciones de exportación de Excel profesional a su aplicación. Comencemos.
Configurar IronXL en una aplicación Blazor Server requiere una configuración mínima. Comience creando un nuevo proyecto Blazor Server en Visual Studio 2022 o posterior, dirigido a .NET 6 o superior.
Instale IronXL a través de la Consola del Administrador de Paquetes NuGet (vea nuestra guía completa de instalación para métodos alternativos):
A continuación, cree una función auxiliar de JavaScript para descargas de archivos. En su carpeta wwwroot, agregue un nuevo archivo JavaScript llamado 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);
}Incluya este script en su archivo _Host.cshtml:
<script src="~/excelExport.js"></script>Esta función de JavaScript maneja el mecanismo de descarga del lado del navegador, convirtiendo el flujo de bytes de su aplicación Blazor Server en un archivo descargable. La función crea una URL de blob temporal, desencadena la descarga y limpia los recursos para prevenir filtraciones de memoria.
Cree un servicio de exportación a Excel para manejar su lógica de negocio. Este servicio encapsula la funcionalidad de IronXL y proporciona métodos reutilizables para diferentes escenarios de exportación en su implementación de exportación a Excel en Blazor:
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 servicio demuestra las características clave de IronXL, incluidas crear nuevos libros de trabajo y hojas de trabajo, añadir encabezados formateados, poblar filas de datos con datos importados de su fuente de datos, aplicando fórmulas y manejando errores potenciales. El método AutoSizeColumn asegura que las columnas se muestren correctamente, independientemente de la longitud del contenido. Para opciones de formato más avanzadas, explore nuestra guía de estilo de celdas.
Cree un componente Razor que use el servicio de exportación y maneje la interacción del usuario:
@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 proporciona retroalimentación al usuario durante la exportación, maneja errores de manera elegante y genera nombres de archivo con marcas de tiempo. La envoltura DotNetStreamReference permite una transmisión eficiente de datos binarios a JavaScript.
Cuando ejecutemos nuestro código, veremos nuestra página cargada con el botón que se usará para manejar el proceso de exportación.
Cuando hacemos clic en el botón, los datos se guardarán en un nuevo documento de Excel, y el archivo exportado se descargará.
IronXL soporta características sofisticadas de Excel para exportaciones de aspecto profesional. Para un escenario de gestión de inventario, podría añadir formato condicional y múltiples hojas de trabajo:
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 maneja múltiples hojas de trabajo sin esfuerzo, aplica formato condicional basado en reglas de negocio y soporta características avanzadas de Excel, como tablas dinámicas y gráficos, cuando sea necesario. Para documentación de API detallada, visite nuestra guía de referencia completa.
IronXL transforma la generación de archivos Excel en aplicaciones Blazor Server de un desafío complejo a una tarea sencilla. Su API intuitiva elimina la necesidad de instalaciones de Microsoft Office mientras proporciona acceso a características avanzadas de Excel. Desde exportaciones de datos simples hasta informes complejos de varias hojas con fórmulas y formatos, IronXL maneja todo con excelente rendimiento y fiabilidad.
¿Listo para mejorar sus aplicaciones Blazor con capacidades de exportación a Excel profesional? Comience su prueba gratuita para despliegue en producción.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronXL es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
La API de Excel que necesita, sin la molestia de Office Interop.
