Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Blog de exportación de Blazor a Excel
USANDO IRONXL

Cómo exportar archivos de Excel en Blazor usando IronXL

Jordi Bardia
Jordi Bardia
Actualizado:

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.

¿Cómo se configura IronXL en un proyecto de servidor Blazor ?

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.

Creación del proyecto de servidor Blazor

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 :

Install-Package IronXL.Excel

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 .

Agregar el asistente de descarga de JavaScript

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 su carpeta wwwroot, agregue 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);
}
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

Incluya este script en su archivo _Host.cshtml (o App.razor en .NET 8+):

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

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.

Empiece con IronXL ahora.
green arrow pointer

¿Cómo se crea un servicio de exportación de Excel en C#?

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.

Construyendo el ExcelExportService

Crear 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();
    }
}
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 Class
$vbLabelText   $csharpLabel

Registrando el Servicio

Agregue 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();
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()
$vbLabelText   $csharpLabel

Este servicio demuestra varias capacidades clave de IronXL . Puede crear nuevos libros y hojas de trabajo con una única llamada de método, aplicar encabezados con estilo, completar filas desde cualquier fuente de datos e incrustar fórmulas de Excel como =D2*0.15. La llamada AutoSizeColumn garantiza 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 .

¿Cómo activar una descarga de Excel desde un componente Blazor ?

Una vez que el servicio está en funcionamiento, necesita un componente Razor que lo llame y pase los bytes resultantes al navegador.

Escritura del componente Razor

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 }
        };
    }
}
@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
}
$vbLabelText   $csharpLabel

Qué hace el componente

La bandera isExporting deshabilita el botón durante la generación, evitando solicitudes duplicadas. El contenedor DotNetStreamReference gestiona la transmisión binaria eficiente desde el flujo de memoria .NET a la función JavaScript , evitando cadenas base64 extensas que inflarían el tamaño de la carga útil. Los nombres de archivo con marca de tiempo, como SalesReport_20260228.xlsx, mantienen las descargas organizadas sin necesidad de configuración adicional.

Cuando navega a /excel-export en el navegador, la página del panel se carga con un botón de exportación:

Exportación de Blazor a Excel: Guía completa con IronXL en C#: Imagen 1 - Página de muestra de Blazor

Al hacer clic en el botón se genera la hoja de cálculo y el navegador descarga automáticamente el archivo:

Exportación de Blazor a Excel: Guía completa sobre el uso de IronXL en C#: Imagen 2: Datos exportados a un archivo Excel

¿Qué formato avanzado puedes aplicar a las exportaciones de Excel?

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.

Formato condicional para informes de inventario

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();
    }
}
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 Class
$vbLabelText   $csharpLabel

IronXL 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.

Cómo agregar varias hojas de trabajo a una sola exportación

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 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 Function
$vbLabelText   $csharpLabel

Para 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 .

Exportación de Blazor a Excel: Guía completa sobre el uso de IronXL en C#: Imagen 3 - Ejemplo de salida de funciones avanzadas

¿Cómo gestionar errores y grandes conjuntos de datos de forma eficiente?

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.

Manejo de errores en la capa de servicio

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ó:

Coloque un bloque try/catch alrededor de la generación del libro de trabajo en GenerateSalesReport, capturando Exception y volviéndolo a generar como InvalidOperationException("Failed to generate sales report", ex). En el componente Blazor , capture el InvalidOperationException y muestre un mensaje fácil de usar sin exponer detalles internos. Registre la excepción interna utilizando ILogger<t> inyectado en el constructor del servicio, de modo que el equipo de desarrollo pueda rastrear las fallas hasta una operación específica del libro de trabajo. 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 obtener más orientación sobre cómo crear servicios comprobables en .NET, la documentación de inyección de dependencia de Microsoft explica cómo registrar y resolver servicios con alcance, que es exactamente el patrón utilizado aquí con ExcelExportService.

Consideraciones de rendimiento para grandes conjuntos de datos

Para conjuntos de datos que superen unos pocos miles de filas, considere estos enfoques:

Estrategias de rendimiento de exportación de Excel
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 primero todo el archivo en una matriz de bytes, lo que mantiene el uso de memoria bajo para libros de trabajo grandes. Para obtener orientación adicional sobre el rendimiento, consulte lectura y escritura de archivos grandes de Excel con IronXL.

¿Qué otras funciones de Excel admite 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.

Fórmulas, rangos con nombre y formato de números

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.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"
$vbLabelText   $csharpLabel

Para definir rangos con nombre y establecer el formato del número explícitamente, IronXL expone ambos como propiedades en el objeto de 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.

Formatos de archivo de Excel compatibles

IronXL puede leer y escribir múltiples formatos de Excel, incluidos .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 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 Using
$vbLabelText   $csharpLabel

Esta 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 proporciona una buena referencia para comprender los formatos de archivos OOXML si necesita comprender la estructura interna de los archivos .xlsx al depurar una salida inesperada. El paquete NuGet para IronXL también aparece en NuGet con el historial de versiones completo y notas de compatibilidad.

¿Cómo empezar a utilizar IronXL para proyectos Blazor ?

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.

Preguntas Frecuentes

¿Cómo puedo exportar datos a Excel en las aplicaciones de Blazor Server?

Puedes usar IronXL para exportar datos a Excel en aplicaciones de Blazor Server. IronXL te permite crear, formatear y descargar archivos de Excel directamente desde el servidor sin necesidad de Microsoft Office.

¿Necesito tener instalado Microsoft Office para utilizar IronXL en Blazor?

No, no necesita tener instalado Microsoft Office. IronXL le permite gestionar archivos de Excel en aplicaciones de Blazor Server independientemente de Microsoft Office.

¿Puedo formatear archivos Excel usando IronXL en aplicaciones Blazor ?

Sí, IronXL proporciona herramientas para formatear archivos Excel, lo que le permite personalizar la apariencia de sus datos directamente desde su aplicación Blazor Server.

¿ IronXL es compatible con las aplicaciones Blazor Server?

Sí, IronXL se integra perfectamente con las aplicaciones de Blazor Server, lo que permite exportar y manejar fácilmente archivos de Excel.

¿Cuáles son los beneficios de usar IronXL para exportar Excel en Blazor?

IronXL ofrece una forma sencilla de crear y manipular archivos de Excel sin necesidad de Office, lo que lo convierte en una solución eficiente para exportar datos en aplicaciones Blazor .

¿Puede IronXL manejar archivos Excel grandes en aplicaciones Blazor Server?

Sí, IronXL está diseñado para manejar archivos grandes de Excel de manera eficiente dentro de las aplicaciones de Blazor Server.

¿Qué tipos de archivos Excel puedo crear con IronXL en una aplicación Blazor ?

Con IronXL, puede crear varios tipos de archivos Excel, incluidos XLSX, XLS y CSV, directamente en su aplicación Blazor .

¿Es posible descargar archivos Excel desde una aplicación Blazor Server usando IronXL?

Sí, IronXL admite la descarga de archivos Excel directamente desde una aplicación Blazor Server, lo que proporciona una experiencia perfecta para los usuarios finales.

¿Cómo mejora IronXL la funcionalidad de exportación de Excel en Blazor en comparación con otras soluciones?

IronXL simplifica el proceso de exportación de archivos Excel en Blazor al eliminar la necesidad de Microsoft Office e integrarse directamente con su aplicación de servidor.

¿Qué hace que IronXL sea una buena opción para los desarrolladores de Blazor ?

IronXL es una buena opción para los desarrolladores de Blazor porque ofrece sólidas capacidades de manejo de Excel, no requiere instalación de Office y se integra fácilmente en las aplicaciones de Blazor Server.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame