Exportar datos a Excel es algo que casi todas las aplicaciones web de Blazor necesitan, ya sea para generar informes de ventas, listas de inventario o facturas de clientes. En una aplicación de Blazor Server, lograr esto de forma fiable sin necesidad de Microsoft Office puede resultar abrumador. IronXL lo hace sencillo: puedes crear, formatear y descargar archivos Excel directamente desde el servidor, sin necesidad de instalar Office. Esta guía lo guiará en el proceso de creación de una función de exportación de Excel lista para producción en Blazor usando IronXL , desde la configuración del proyecto y el diseño del servicio hasta el formato avanzado y los informes de varias hojas.
Antes de escribir cualquier lógica de exportación, debe agregar IronXL a un proyecto de Blazor Server y configurar un asistente de descarga del lado del navegador.
Comience creando un nuevo proyecto de Blazor Server en Visual Studio 2022 o posterior, orientado a .NET 10. Una vez que el proyecto esté listo, instale IronXL a través de la consola del Administrador de paquetes NuGet :
IronXL funciona con .NET 6 y versiones posteriores, por lo que los proyectos Blazor existentes pueden adoptarlo sin actualizar el marco. Para conocer métodos de instalación alternativos, como la interfaz de usuario o CLI de NuGet , consulte la guía de instalación de IronXL .
Blazor Server se ejecuta en el lado del servidor, por lo que activar la descarga de un archivo requiere un pequeño puente de JavaScript . En tu carpeta wwwroot, añade un archivo 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);
}Incluye este script en tu archivo _Host.cshtml (o App.razor en .NET 8+):
<script src="~/excelExport.js"></script>Esta función convierte el flujo de bytes de Blazor en una URL de blob temporal, activa la descarga del navegador y luego limpia el objeto URL para evitar pérdidas de memoria. Es intencionalmente mínimo: el trabajo pesado se realiza en C# en el servidor.
Separar la generación de Excel de los componentes de Razor permite que el código se pueda probar y reutilizar en varias páginas. El patrón a continuación envuelve IronXL dentro de una clase de servicio dedicada.
Crea un nuevo archivo 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();
}
}Imports IronXL
Imports System.IO
Imports ExportExcel.Models
Public Class ExcelExportService
Public Function GenerateSalesReport(salesData As List(Of SalesData)) As Byte()
Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
workbook.Metadata.Author = "Sales Department"
Dim 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
Dim headerRange = worksheet("A1:E1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.Color = "#FFFFFF"
' Populate data rows
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
End Function
End ClassAñade el servicio al contenedor DI en 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();Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddRazorPages()
builder.Services.AddServerSideBlazor()
builder.Services.AddScoped(Of ExcelExportService)()
Dim app = builder.Build()
app.MapBlazorHub()
app.MapFallbackToPage("/_Host")
app.Run()Este servicio demuestra varias capacidades clave de IronXL . Puedes crear nuevos libros y hojas de trabajo con una sola llamada de método, aplicar encabezados con estilo, llenar filas desde cualquier fuente de datos y incrustar fórmulas de Excel como =D2*0.15. La llamada AutoSizeColumn asegura que las columnas sean lo suficientemente anchas para mostrar su contenido correctamente, independientemente de la longitud de los datos. Para obtener más opciones de formato, consulte la guía de estilo de celda .
Una vez que el servicio está en funcionamiento, necesita un componente Razor que lo llame y pase los bytes resultantes al navegador.
Crea una página en 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 }
};
}
}Imports ExportExcel.Models
Imports Microsoft.JSInterop
@page "/excel-export"
@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 = ""
Dim salesData = GetSalesData()
Dim fileBytes = ExcelService.GenerateSalesReport(salesData)
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."
Finally
isExporting = False
End Try
End Function
Private Function GetSalesData() As List(Of SalesData)
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
}El indicador isExporting desactiva el botón durante la generación, evitando solicitudes duplicadas. El envoltorio DotNetStreamReference maneja la transmisión binaria eficiente desde la memoria de .NET a la función de JavaScript, evitando grandes cadenas base64 que aumentarían el tamaño de la carga útil. Nombres de archivo con marca de tiempo como SalesReport_20260228.xlsx mantienen las descargas organizadas sin configuración adicional.
Cuando navegas a /excel-export en el navegador, la página del tablero se carga con un botón de exportación:
Al hacer clic en el botón se genera la hoja de cálculo y el navegador descarga automáticamente el archivo:
Las exportaciones de datos básicos satisfacen muchos casos de uso, pero las aplicaciones de producción a menudo necesitan formato condicional, múltiples hojas de trabajo o validación de datos. IronXL admite todos estos de forma nativa.
El siguiente servicio resalta los artículos con poco stock en rojo, un requisito común para aplicaciones de gestión de inventario o almacén:
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();
}
}Imports IronXL
Imports ExportExcel.Models
Imports System.IO
Public Class InventoryExportService
Public Function GenerateInventoryReport(items As List(Of InventoryItem)) As Byte()
Dim workbook = WorkBook.Create()
Dim 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"
Dim headerRange = details("A1:E1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#2E75B6"
headerRange.Style.Font.Color = "#FFFFFF"
For i As Integer = 0 To items.Count - 1
Dim row As Integer = i + 2
Dim 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 = If(item.Quantity < item.ReorderLevel, "Reorder Required", "OK")
If item.Quantity < item.ReorderLevel Then
' Highlight the entire row for low-stock items
details($"A{row}:E{row}").Style.BackgroundColor = "#FFB6B6"
details($"C{row}").Style.Font.Bold = True
End If
Next
details.AutoSizeColumn(0, True)
details.AutoSizeColumn(1, True)
Using stream = workbook.ToStream()
Return stream.ToArray()
End Using
End Function
End ClassIronXL aplica formato a nivel de celda según los valores de los datos en el momento de la generación. También puede aplicar reglas de formato condicional de forma declarativa o administrar varias hojas de cálculo dentro del mismo libro; por ejemplo, una hoja para el inventario actual y otra para los pedidos históricos.
Separar los datos en hojas lógicas mejora la legibilidad sin necesidad de descargas independientes:
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 Function GenerateMultiSheetReport( _
sales As List(Of SalesData), _
inventory As List(Of InventoryItem)) As Byte()
Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
' Sheet 1 -- Sales summary
Dim salesSheet = workbook.CreateWorkSheet("Sales")
salesSheet("A1").Value = "Date"
salesSheet("B1").Value = "Revenue"
salesSheet("A1:B1").Style.Font.Bold = True
For i As Integer = 0 To sales.Count - 1
salesSheet($"A{i + 2}").Value = sales(i).Date.ToString("yyyy-MM-dd")
salesSheet($"B{i + 2}").Value = sales(i).Revenue
Next
' Sheet 2 -- Inventory snapshot
Dim invSheet = workbook.CreateWorkSheet("Inventory")
invSheet("A1").Value = "SKU"
invSheet("B1").Value = "Name"
invSheet("C1").Value = "Quantity"
invSheet("A1:C1").Style.Font.Bold = True
For i As Integer = 0 To inventory.Count - 1
invSheet($"A{i + 2}").Value = inventory(i).SKU
invSheet($"B{i + 2}").Value = inventory(i).Name
invSheet($"C{i + 2}").Value = inventory(i).Quantity
Next
Using stream = workbook.ToStream()
Return stream.ToArray()
End Using
End FunctionPara obtener una referencia completa de la API que cubra las propiedades del libro de trabajo, las operaciones de rango y la compatibilidad con gráficos, visita la documentación de la API de IronXL .
Las operaciones de exportación de Excel pueden fallar silenciosamente o degradar el rendimiento cuando los conjuntos de datos son grandes. Los patrones a continuación abordan ambas preocupaciones.
Envolver la lógica de generación en el servicio (en lugar de en el componente) mantiene el manejo de errores consistente entre todos los que llaman. El patrón recomendado es permitir que las excepciones de IronXL se propaguen y luego envolverlas en una excepción específica del dominio con el contexto sobre qué informe falló:
Coloca un bloque try/catch alrededor de la generación del libro en GenerateSalesReport, capturando Exception y lanzándolo nuevamente como InvalidOperationException("Failed to generate sales report", ex). En el componente Blazor, captura InvalidOperationException y muestra un mensaje amigable para el usuario sin exponer detalles internos. Registra la excepción interna usando ILogger<t> inyectado en el constructor del servicio, para que el equipo de desarrollo pueda rastrear fallos hasta una operación específica del libro. Nunca muestre mensajes de excepción sin procesar a los usuarios finales: las rutas de archivos, las direcciones de memoria o los seguimientos de la pila pueden revelar información interna del servidor.
Consulte las mejores prácticas de manejo de errores en la documentación oficial de Microsoft para obtener orientación sobre el registro de errores estructurado en Blazor. Para más orientación sobre la construcción de servicios testeables en .NET, la documentación de inyección de dependencias de Microsoft explica cómo registrar y resolver servicios de ámbito, que es exactamente el patrón usado aquí con ExcelExportService.
Para conjuntos de datos que superen unos pocos miles de filas, considere estos enfoques:
| Estrategia | Cuándo usarlo | Soporte de IronXL |
|---|---|---|
| Transmitir directamente a la respuesta | Files >10 MB | workbook.ToStream() |
| Paginar datos antes de exportar | Exportaciones basadas en la interfaz de usuario con filtros | Aplicar en servicio antes de crear el libro de trabajo |
| Trabajo en segundo plano + enlace de descarga | Reports taking >5 seconds | Combinar con SignalR o sondeo |
| Deshabilitar AutoSizeColumn en hojas grandes | Sheets with >500 rows | En su lugar, establezca anchos de columna fijos |
El método ToStream() de IronXL escribe directamente en un flujo de salida sin cargar todo el archivo en un array de bytes primero, lo que mantiene el uso de memoria más bajo para libros grandes. Para más orientación sobre el rendimiento, vea leer y escribir archivos Excel grandes con IronXL.
Más allá de la exportación básica, IronXL ofrece una amplia gama de funciones de Excel que cubren los requisitos de informes del mundo real.
Puede incrustar cualquier fórmula de Excel utilizando la misma sintaxis que escribiría directamente en una celda. IronXL evalúa las fórmulas en el momento de la lectura, por lo que los consumidores del archivo generado ven los resultados calculados tan pronto como abren la hoja de cálculo. Los rangos con nombre hacen que las fórmulas sean más legibles y fáciles de mantener a lo largo del tiempo:
// 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.67D
worksheet("D2").FormatString = "#,##0.00"
worksheet("A2").Value = DateTime.Now
worksheet("A2").FormatString = "dd/MM/yyyy"Para definir rangos nombrados y establecer el formato de número explícitamente, IronXL expone ambos como propiedades en el objeto del rango. Esto evita que Excel trate los valores de moneda como texto simple, un problema común al exportar datos financieros desde bases de datos que almacenan valores como cadenas.
IronXL puede leer y escribir múltiples formatos de Excel incluyendo .xlsx, .xls, .csv y .tsv. El formato se determina en el momento de guardar, por lo que la misma clase de servicio puede admitir exportaciones tanto de Excel como de CSV con un pequeño cambio 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 ms As Stream = workbook.ToStream(ExcelFileFormat.CSV)
End UsingEsta flexibilidad es importante en integraciones donde los sistemas posteriores (como plataformas ERP o almacenes de datos) esperan un formato de archivo específico. Para obtener una comparación completa de las características de IronXL y otras bibliotecas de Excel, visite la página de características de IronXL .
Microsoft provee una buena referencia para entender los formatos de archivo OOXML si necesitas comprender la estructura interna de los archivos .xlsx al depurar salidas inesperadas. El paquete NuGet para IronXL también aparece en NuGet con el historial de versiones completo y notas de compatibilidad.
IronXL está disponible bajo una licencia de desarrollo gratuita que le permite construir y probar sin límite de tiempo. Para aplicaciones de producción, se requiere una licencia de implementación.
Puede descargar una versión de prueba gratuita directamente desde NuGet : no es necesario registrarse para comenzar. Cuando esté listo para implementar, revise las opciones de licencia de IronXL para encontrar el plan que se ajuste a la escala de la aplicación.
IronXL funciona con los principales tipos de aplicaciones .NET : Blazor Server, Blazor WebAssembly (renderizado en servidor), ASP.NET Core MVC, aplicaciones de consola y aplicaciones de escritorio de Windows. La biblioteca está orientada a .NET Standard 2.0, por lo que es compatible con todas las versiones de .NET compatibles, desde .NET Framework 4.6.2 hasta .NET 10. Si el proyecto también requiere la generación de PDF, IronPDF se integra con IronXL sin problemas, lo que permite exportar datos como Excel o PDF desde la misma capa de servicio.
Para explorar más ejemplos específicos de Blazor, consulte el tutorial de exportación de Blazor a Excel y la guía de exportación de ASP.NET Core . Para leer hojas de cálculo existentes, el tutorial del lector de Excel en C# cubre escenarios de importación comunes. También puede revisarcómo crear un nuevo libro de Excel desde cero para proyectos que necesitan crear archivos mediante programación en lugar de hacerlo a partir de plantillas.
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.
