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
Mis à jour:

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 package NuGet (voir notre guide d'installation complet pour des méthodes alternatives) :

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, le remplissage de 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, 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 = "";
            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. Dans un scénario de gestion d'inventaire, vous pouvez ajouter un formatage conditionnel et plusieurs feuilles de calcul :

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 de l'API, visitez 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.

Questions Fréquemment Posées

Comment exporter des fichiers Excel dans les applications Blazor Server ?

Vous pouvez utiliser IronXL pour exporter des fichiers Excel dans les apps Blazor Server en créant, formatant et téléchargeant des fichiers XLSX directement depuis votre serveur sans avoir besoin de Microsoft Office.

Ai-je besoin que Microsoft Office soit installé pour utiliser IronXL dans Blazor ?

Non, IronXL ne nécessite pas l'installation de Microsoft Office sur votre serveur pour créer, formater et exporter des fichiers Excel dans les applications Blazor.

IronXL peut-il s'intégrer aux applications de Blazor ?

Oui, IronXL s'intègre parfaitement aux applications Blazor, ce qui vous permet d'ajouter facilement des fonctionnalités d'exportation Excel.

Quelles sont les utilisations courantes de l'exportation de fichiers Excel dans les applications web ?

Les utilisations courantes comprennent la génération de rapports, la création de listes d'inventaire et la production de factures clients au format Excel.

Existe-t-il des exemples de code disponibles pour l'exportation de fichiers Excel à l'aide d'IronXL.Excel ?

Oui, le guide fournit des exemples de code pour vous aider à mettre en œuvre les fonctionnalités d'exportation Excel dans votre application Blazor Server à l'aide d'IronXL.

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

Oui, IronXL vous permet de mettre en forme des fichiers Excel, notamment en définissant des styles, en ajoutant des formules, et plus encore, directement dans les applications Blazor.

Quels types de fichiers Excel puis-je créer avec IronXL ?

Vous pouvez créer des fichiers XLSX à l'aide d'IronXL.Excel, qui est un format de fichier Excel largement utilisé et compatible avec la plupart des tableurs.

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