Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Exportation Excel Blazor
UTILISATION D'IRONXL

Comment exporter vers Excel dans un Blazor en utilisant IronXL

Jordi Bardia
Jordi Bardia
Publié:

L'exportation de données vers Excel est une fonctionnalité dont presque toutes les applications web ont besoin, que ce soit pour générer des rapports, des listes d'inventaire ou des factures client. Dans une application Blazor Server, réaliser cela de manière fiable sans nécessiter Microsoft Office peut être un défi. C'est là qu'intervient IronXL. Il vous permet de créer, formater et télécharger des fichiers Excel directement depuis votre serveur, sans installation d'Office requise, et s'intègre parfaitement à Blazor. Dans ce guide, vous verrez à quel point il est simple d'ajouter des fonctionnalités d'exportation Excel professionnelles à votre application. Commençons.

Commencer avec IronXL pour exporter des données vers Excel

Configurer IronXL dans une application Blazor Server nécessite une configuration minimale. Commencez par créer un nouveau projet Blazor Server dans Visual Studio 2022 ou une version ultérieure, ciblant .NET 6 ou supérieur.

Installez IronXL via la console du gestionnaire de package NuGet (voir notre guide d'installation complet pour des méthodes alternatives) :

Install-Package IronXL.Excel

Ensuite, créez une fonction d'assistance JavaScript pour le téléchargement de fichiers. Dans votre dossier wwwroot, ajoutez un nouveau fichier JavaScript appelé 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

Incluez ce script dans votre fichier _Host.cshtml :

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

Cette fonction JavaScript gère le mécanisme de téléchargement côté navigateur, convertissant le flux de données provenant de votre application Blazor Server en un fichier téléchargeable. La fonction crée une URL de blob temporaire, déclenche le téléchargement et nettoie les ressources pour éviter les fuites de mémoire.

Comment exporter une source de données vers des fichiers Excel avec IronXL ?

Créez un service d'exportation Excel pour gérer votre logique métier. Ce service encapsule les fonctionnalités d'IronXL et fournit des méthodes réutilisables pour différents scénarios d'exportation dans votre implémentation d'exportation Excel sur 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

This service demonstrates key IronXL features, including creating new workbooks and worksheets, adding formatted headers, populating data rows with imported data from your data source, applying formulas, and handling potential errors. La méthode AutoSizeColumn assure que les colonnes s'affichent correctement, quelle que soit la longueur du contenu. Pour des options de formatage plus avancées, explorez notre guide de mise en forme des cellules.

Comment implémenter le téléchargement de fichiers dans Blazor ?

Créez un composant Razor qui utilise le service d'exportation et gère l'interaction utilisateur :

@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

Ce composant fournit des retours utilisateurs pendant l'exportation, gère les erreurs gracieusement et génère des noms de fichiers horodatés. L'enveloppe DotNetStreamReference permet un streaming efficace de données binaires vers JavaScript.

Sortie

Lorsque nous exécutons notre code, nous verrons notre page chargée avec le bouton qui sera utilisé pour gérer le processus d'exportation.

Comment exporter vers Excel dans un Blazor en utilisant IronXL : Figure 1 - Page Blazor d'exemple

Lorsque nous cliquons sur le bouton, les données seront enregistrées dans un nouveau document Excel, et le fichier exporté sera téléchargé.

Comment exporter vers Excel dans un Blazor en utilisant IronXL : Figure 2 - Données exportées vers un fichier Excel

Quelles fonctionnalités avancées IronXL peut-il ajouter à votre exportation Excel ?

IronXL prend en charge des fonctionnalités Excel sophistiquées pour des exportations d'apparence professionnelle. For an inventory management scenario, you might add conditional formatting and multiple worksheets:

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 gère aisément plusieurs feuilles de calcul, applique un formatage conditionnel basé sur des règles métier, et prend en charge des fonctionnalités Excel avancées, telles que les tableaux croisés dynamiques et les graphiques, selon les besoins. Pour une documentation détaillée de l'API, visitez notre guide de référence complet.

Comment exporter vers Excel dans un Blazor en utilisant IronXL : Figure 3 - Exemple de sortie des fonctionnalités avancées

Conclusion

IronXL transforme la génération de fichiers Excel dans les applications Blazor Server d'un défi complexe en une tâche simple. Son API intuitive élimine le besoin d'installations Microsoft Office tout en offrant l'accès à des fonctionnalités Excel avancées. Des exportations de données simples aux rapports multi-feuilles complexes avec formules et formatages, IronXL gère tout cela avec d'excellentes performances et fiabilité.

Prêt à améliorer vos applications Blazor avec des capacités d'exportation Excel professionnelles ? Commencez votre essai gratuit pour le déploiement en production.

Questions Fréquemment Posées

Comment puis-je exporter des fichiers Excel dans une application Blazor Server ?

Vous pouvez utiliser IronXL pour exporter des fichiers Excel dans une application Blazor Server. IronXL vous permet de créer, de formater et de télécharger des fichiers Excel directement depuis votre serveur sans besoin de Microsoft Office.

Ai-je besoin de Microsoft Office pour travailler avec des fichiers Excel dans Blazor ?

Non, IronXL vous permet de travailler avec des fichiers Excel sans nécessiter Microsoft Office. Il fournit la fonctionnalité de créer et de manipuler des fichiers Excel directement dans votre application Blazor.

Quels sont les avantages d'utiliser IronXL pour l'exportation Excel dans Blazor ?

IronXL offre une intégration parfaite avec Blazor, vous permettant de créer, de formater et d'exporter facilement des fichiers Excel. Il simplifie le processus, élimine le besoin de Microsoft Office et prend en charge divers formats Excel.

IronXL peut-il s'intégrer à d'autres composants Blazor ?

Oui, IronXL s'intègre parfaitement aux composants Blazor, vous permettant d'ajouter facilement des fonctionnalités d'exportation Excel à vos applications.

Est-il possible de formater des fichiers Excel en utilisant IronXL dans Blazor ?

Oui, IronXL fournit des fonctionnalités complètes pour formater des fichiers Excel, y compris le style des cellules, l'ajustement des largeurs de colonnes et la configuration de formules complexes, tout cela dans votre application Blazor Server.

Comment gérez-vous de grands ensembles de données lors de l'exportation vers Excel dans Blazor ?

IronXL est conçu pour gérer efficacement de grands ensembles de données, garantissant des performances fluides lors de l'exportation de données volumineuses dans des fichiers Excel dans un environnement Blazor Server.

Quels formats de fichiers Excel sont pris en charge par IronXL ?

IronXL prend en charge divers formats de fichiers Excel, y compris XLS, XLSX et CSV, offrant une flexibilité dans la manière dont vous exportez et travaillez avec des données Excel dans vos applications Blazor.

IronXL peut-il être utilisé pour générer des rapports dans Blazor ?

Absolument, IronXL est idéal pour générer des rapports détaillés dans les applications Blazor. Il offre de solides fonctionnalités pour compiler, formater et exporter des données dans des rapports Excel professionnels.

Comment IronXL assure-t-il l'intégrité des données lors de l'exportation de fichiers Excel ?

IronXL assure l'intégrité des données en préservant avec précision la structure et le formatage de vos données pendant le processus d'exportation, ce qui en fait une solution fiable pour les applications Blazor.

Est-il possible d'automatiser la création de fichiers Excel dans une application Blazor Server en utilisant IronXL ?

Oui, IronXL peut être utilisé pour automatiser la création et l'exportation de fichiers Excel dans des applications Blazor Server, vous permettant d'optimiser les flux de travail et d'améliorer l'efficacité.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit