Ícono de mensaje
Saltar al pie de página
  1. IronXL
  2. Blog de IronXL
  3. Usando IronXL
  4. Exportar Excel en Blazor
USANDO IRONXL

Cómo exportar a Excel en un Blazor usando IronXL

Jordi Bardia
Jordi Bardia
Publicado:

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.

Introducción a IronXL para exportar datos a Excel

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

Install-Package IronXL.Excel

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);
}
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:

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

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.

¿Cómo exportar una fuente de datos a archivos Excel con IronXL?

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);
        }
    }
}
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);
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

¿Cómo implementar la descarga de archivos en Blazor?

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"
@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 }
        };
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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.

Resultado

Cuando ejecutemos nuestro código, veremos nuestra página cargada con el botón que se usará para manejar el proceso de exportación.

Cómo Exportar a Excel en Blazor Usando IronXL: Figura 1 - Página de ejemplo de Blazor

Cuando hacemos clic en el botón, los datos se guardarán en un nuevo documento de Excel, y el archivo exportado se descargará.

Cómo Exportar a Excel en Blazor Usando IronXL: Figura 2 - Datos exportados a un archivo Excel

¿Qué funciones avanzadas puede agregar IronXL a su exportación de Excel?

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();
        }
    }
}
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();
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Cómo Exportar a Excel en Blazor Usando IronXL: Figura 3 - Ejemplo de salida de funciones avanzadas

Conclusión

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.

Preguntas Frecuentes

¿Cómo puedo exportar archivos de Excel en una aplicación de servidor Blazor?

Puedes usar IronXL para exportar archivos de Excel en una aplicación de servidor Blazor. IronXL te permite crear, formatear y descargar archivos de Excel directamente desde tu servidor sin necesidad de Microsoft Office.

¿Necesito Microsoft Office para trabajar con archivos de Excel en Blazor?

No, IronXL te permite trabajar con archivos de Excel sin requerir Microsoft Office. Proporciona la funcionalidad para crear y manipular archivos de Excel directamente dentro de tu aplicación Blazor.

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

IronXL ofrece una integración perfecta con Blazor, permitiéndote crear, formatear y exportar fácilmente archivos de Excel. Simplifica el proceso, elimina la necesidad de Microsoft Office y admite varios formatos de Excel.

¿Puede integrarse IronXL con otros componentes de Blazor?

Sí, IronXL se integra perfectamente con componentes de Blazor, permitiéndote agregar funcionalidad de exportación de Excel a tus aplicaciones con facilidad.

¿Es posible formatear archivos de Excel usando IronXL en Blazor?

Sí, IronXL proporciona características completas para formatear archivos de Excel, incluyendo el estilo de celdas, el ajuste de anchos de columna y la configuración de fórmulas complejas, todo dentro de tu aplicación de servidor Blazor.

¿Cómo manejas grandes conjuntos de datos al exportar a Excel en Blazor?

IronXL está diseñado para manejar eficientemente grandes conjuntos de datos, asegurando un rendimiento fluido al exportar datos extensos a archivos de Excel en un entorno de servidor Blazor.

¿Qué formatos de archivo Excel son soportados por IronXL?

IronXL admite varios formatos de archivo de Excel, incluyendo XLS, XLSX y CSV, lo que permite flexibilidad en cómo exportas y trabajas con datos de Excel en tus aplicaciones Blazor.

¿Puede usarse IronXL para generar informes en Blazor?

Absolutamente, IronXL es ideal para generar informes detallados en aplicaciones Blazor. Ofrece características robustas para compilar, formatear y exportar datos en informes de Excel profesionales.

¿Cómo asegura IronXL la integridad de los datos al exportar archivos de Excel?

IronXL asegura la integridad de los datos preservando con precisión la estructura y el formato de tus datos durante el proceso de exportación, lo que hace que sea una solución confiable para aplicaciones Blazor.

¿Existe una manera de automatizar la creación de archivos de Excel en una aplicación de servidor Blazor usando IronXL?

Sí, IronXL se puede usar para automatizar la creación y exportación de archivos de Excel en aplicaciones de servidor Blazor, permitiéndote optimizar flujos de trabajo y mejorar la eficiencia.

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. Comenzar prueba gratuita