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

Blazor Export to Excel : Guide complet utilisant IronXL en C#

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à que IronXL entre en jeu. 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 paquets NuGet (consultez notre guide d'installation complet pour d'autres méthodes) :

Install-Package IronXL
Install-Package IronXL
SHELL

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)
        {
            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)
        {
            throw new InvalidOperationException("Failed to generate sales report", ex);
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ce service démontre les principales fonctionnalités d'IronXL, notamment la création de nouveaux classeurs et feuilles de calcul, l'ajout d'en-têtes formatés, l'alimentation des lignes de données avec des données importées de votre source de données, l'application de formules, et la gestion des erreurs potentielles. La méthode AutoSizeColumn garantit que les colonnes s'affichent correctement, quelle que soit la longueur du contenu. Pour des options de formatage plus avancées, consultez notre guide de style de cellule.

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 = "";
            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 ex)
        {
            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 }
        };
    }
}

Ce composant fournit des retours utilisateurs pendant l'exportation, gère les erreurs gracieusement et génère des noms de fichiers horodatés. Le wrapper DotNetStreamReference permet un flux 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.

Blazor Export to Excel : Guide complet utilisant IronXL en C# : Image 1 - Exemple de page Blazor

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

Blazor Export to Excel : Guide complet utilisant IronXL en C# : Image 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. Pour un scénario de gestion des stocks, vous pourriez ajouter conditional formatting et 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");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var 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;
                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");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var 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;
                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 sur les API, consultez notre guide de référence complet.

Blazor Export to Excel : Guide complet utilisant IronXL en C# : Image 3 - Fonctionnalités avancées exemple de sortie

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 d'IronXL dès aujourd'hui, ou explorez nos options de licence pour un déploiement en production.

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. Essai gratuit