Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Blog sur l'exportation Blazor vers Excel
UTILISATION D'IRONXL

Comment exporter des fichiers Excel depuis Blazor avec IronXL

Jordi Bardia
Jordi Bardia
Mis à jour:

L'exportation de données vers Excel est une fonctionnalité quasi indispensable pour toutes les applications web Blazor , qu'il s'agisse de générer des rapports de vente, des listes d'inventaire ou des factures clients. Dans une application Blazor Server, réaliser cette opération de manière fiable sans avoir recours à Microsoft Office peut s'avérer complexe. IronXL simplifie les choses : vous pouvez créer, formater et télécharger des fichiers Excel directement depuis le serveur, sans installation d'Office. Ce guide vous accompagne dans la création d'une fonctionnalité d'exportation Excel prête pour la production dans Blazor à l'aide IronXL , de la configuration du projet et de la conception du service à la mise en forme avancée et aux rapports multi-feuilles.

Comment configurer IronXL dans un projet Blazor Server ?

Avant d'écrire toute logique d'exportation, vous devez ajouter IronXL à un projet Blazor Server et configurer un assistant de téléchargement côté navigateur.

Création du projet Blazor Server

Commencez par créer un nouveau projet Blazor Server dans Visual Studio 2022 ou version ultérieure, ciblant .NET 10. Une fois le projet prêt, installez IronXL via la console du gestionnaire de packages NuGet :

Install-Package IronXL.Excel

IronXL fonctionne avec .NET 6 et versions ultérieures, les projets Blazor existants peuvent donc l'adopter sans avoir à mettre à niveau le framework. Pour connaître les autres méthodes d'installation, telles que l'interface utilisateur NuGet ou l'interface de ligne de commande, consultez le guide d'installation IronXL .

Ajout de l'assistant de téléchargement JavaScript

Blazor Server s'exécute côté serveur, donc le déclenchement du téléchargement d'un fichier nécessite un petit pont JavaScript . Dans votre dossier wwwroot, ajoutez un fichier 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 (ou App.razor dans .NET 8+) :

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

Cette fonction convertit le flux d'octets provenant de Blazor en une URL blob temporaire, déclenche le téléchargement par le navigateur, puis nettoie l'objet URL pour éviter les fuites de mémoire. Il est volontairement minimal – le gros du travail est effectué en C# sur le serveur.

Commencez avec IronXL maintenant.
green arrow pointer

Comment créer un service d'exportation Excel en C# ?

Séparer la génération Excel de vos composants Razor permet de conserver un code testable et réutilisable sur plusieurs pages. Le schéma ci-dessous intègre IronXL dans une classe de service dédiée.

Création du service d'exportation Excel

Créer un nouveau fichier 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

Enregistrement du service

Ajoutez le service au conteneur DI dans 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

Ce service illustre plusieurs fonctionnalités clés IronXL . Vous pouvez créer de nouveaux classeurs et feuilles de calcul avec un seul appel de méthode, appliquer des en-têtes stylisés, remplir des lignes à partir de n'importe quelle source de données et intégrer des formules Excel telles que =D2*0.15. L'appel AutoSizeColumn garantit que les colonnes sont suffisamment larges pour afficher correctement leur contenu, quelle que soit la longueur des données. Pour plus d'options de mise en forme, consultez le guide de style des cellules .

Comment déclencher un téléchargement Excel à partir d'un composant Blazor ?

Une fois le service en place, vous avez besoin d'un composant Razor qui l'appelle et transmet les octets résultants au navigateur.

Écriture du composant Razor

Créez une page à 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

Fonctionnement du composant

L'indicateur isExporting désactive le bouton pendant la génération, empêchant ainsi les requêtes en double. Le wrapper DotNetStreamReference gère efficacement le flux binaire du flux mémoire .NET vers la fonction JavaScript , évitant ainsi les chaînes base64 volumineuses qui augmenteraient la taille de la charge utile. Les noms de fichiers horodatés, tels que SalesReport_20260228.xlsx, permettent d'organiser les téléchargements sans configuration supplémentaire.

Lorsque vous accédez à /excel-export dans le navigateur, la page du tableau de bord se charge avec un bouton d'exportation :

Exportation Blazor vers Excel : Guide complet avec IronXL en C# : Image 1 - Exemple de page Blazor

Cliquer sur le bouton génère la feuille de calcul et le navigateur télécharge automatiquement le fichier :

Exportation Blazor vers Excel : Guide complet avec IronXL en C# : Image 2 - Données exportées vers un fichier Excel

Quelles options de mise en forme avancée pouvez-vous appliquer aux exportations Excel ?

L'exportation de données de base répond à de nombreux cas d'utilisation, mais les applications de production nécessitent souvent une mise en forme conditionnelle, plusieurs feuilles de calcul ou une validation des données. IronXL prend en charge nativement toutes ces fonctionnalités.

Mise en forme conditionnelle des rapports d'inventaire

Le service suivant met en évidence en rouge les articles en faible stock – une exigence courante pour les applications de gestion d'entrepôt ou d'inventaire :

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 applique une mise en forme au niveau des cellules en fonction des valeurs des données lors de leur génération. Vous pouvez également appliquer des règles de mise en forme conditionnelle de manière déclarative ou gérer plusieurs feuilles de calcul au sein d'un même classeur ; par exemple, une feuille pour le stock actuel et une autre pour l'historique des commandes.

Ajout de plusieurs feuilles de calcul à une seule exportation

Le fait de séparer les données en feuilles logiques améliore la lisibilité sans nécessiter de téléchargements séparés :

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

Pour une documentation complète de l'API couvrant les propriétés des classeurs, les opérations sur les plages et la prise en charge des graphiques, consultez la documentation de l'API IronXL .

Exportation Blazor vers Excel : Guide complet avec IronXL en C# : Image 3 - Exemple de sortie avec fonctionnalités avancées

Comment gérer efficacement les erreurs et les grands ensembles de données ?

Les opérations d'exportation Excel peuvent échouer silencieusement ou dégrader les performances lorsque les ensembles de données sont volumineux. Les modèles ci-dessous répondent à ces deux préoccupations.

Gestion des erreurs dans la couche de service

En intégrant la logique de génération dans le service (plutôt que dans le composant), on assure une gestion des erreurs cohérente pour tous les appelants. Le modèle recommandé consiste à laisser les exceptions IronXL se propager, puis à les encapsuler dans une exception spécifique au domaine avec un contexte sur le rapport ayant échoué :

Placez un bloc try/catch autour de la génération du classeur dans GenerateSalesReport, en interceptant Exception et en le relançant comme InvalidOperationException("Failed to generate sales report", ex). Dans le composant Blazor , interceptez le InvalidOperationException et affichez un message convivial sans exposer les détails internes. Consignez l'exception interne en utilisant ILogger<t> injecté dans le constructeur du service, afin que l'équipe de développement puisse retracer les échecs jusqu'à une opération de classeur spécifique. Ne jamais exposer les messages d'exception bruts aux utilisateurs finaux : les chemins d'accès aux fichiers, les adresses mémoire ou les traces de pile peuvent révéler le fonctionnement interne du serveur.

Consultez les bonnes pratiques de gestion des erreurs dans la documentation officielle de Microsoft pour obtenir des conseils sur la journalisation structurée des erreurs dans Blazor. Pour plus d'informations sur la création de services testables dans .NET, la documentation Microsoft sur l'injection de dépendances explique comment enregistrer et résoudre les services à portée limitée, ce qui correspond exactement au modèle utilisé ici avec ExcelExportService.

Considérations relatives aux performances pour les grands ensembles de données

Pour les ensembles de données comportant plus de quelques milliers de lignes, envisagez les approches suivantes :

Stratégies d'exportation Excel pour optimiser les performances
Stratégie Quand l'utiliser Assistance IronXL
Flux direct vers la réponse Files >10 MB `workbook.ToStream()`
Paginer les données avant l'exportation Exportations pilotées par l'interface utilisateur avec filtres Postuler en service avant de créer le classeur
Travail en arrière-plan + lien de téléchargement Reports taking >5 seconds Combiner avec SignalR ou l'interrogation
Désactiver AutoSizeColumn sur les grandes feuilles Sheets with >500 rows Définissez plutôt des largeurs de colonnes fixes

La méthode ToStream() d'IronXL écrit directement dans un flux de sortie sans charger au préalable l'intégralité du fichier dans un tableau d'octets, ce qui réduit l'utilisation de la mémoire pour les classeurs volumineux. Pour plus d'informations sur les performances, consultez la section lecture et écriture de fichiers Excel volumineux avec IronXL.

Quelles autres fonctionnalités Excel IronXL prend-il en charge ?

Au-delà de l'exportation de base, IronXL offre un large éventail de fonctionnalités Excel qui couvrent les exigences réelles en matière de reporting.

Formules, plages nommées et mise en forme des nombres

Vous pouvez intégrer n'importe quelle formule Excel en utilisant la même syntaxe que celle que vous saisiriez directement dans une cellule. IronXL évalue les formules au moment de la lecture, de sorte que les utilisateurs du fichier généré voient les résultats calculés dès qu'ils ouvrent la feuille de calcul. Les plages nommées rendent les formules plus lisibles et plus faciles à maintenir dans le temps :

// 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

Pour définir des plages nommées et définir explicitement le format numérique , IronXL expose les deux en tant que propriétés de l'objet plage. Cela empêche Excel de traiter les valeurs monétaires comme du texte brut, un problème courant lors de l'exportation de données financières à partir de bases de données qui stockent les valeurs sous forme de chaînes de caractères.

Formats de fichiers Excel pris en charge

IronXL peut lire et écrire plusieurs formats Excel, notamment .xlsx, .xls, .csv et .tsv. Le format est déterminé lors de l'enregistrement, de sorte que la même classe de service peut prendre en charge les exportations Excel et CSV avec une simple modification de paramètre :

// 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

Cette flexibilité est importante dans les intégrations où les systèmes en aval — tels que les plateformes ERP ou les entrepôts de données — attendent un format de fichier spécifique. Pour une comparaison complète des fonctionnalités IronXL avec celles d'autres bibliothèques Excel, consultez la page des fonctionnalités IronXL .

Microsoft fournit une bonne référence pour comprendre les formats de fichiers OOXML si vous avez besoin de comprendre la structure interne des fichiers .xlsx lors du débogage d'une sortie inattendue. Le package NuGet pour IronXL est également répertorié sur NuGet avec l'historique complet des versions et les notes de compatibilité.

Comment débuter avec IronXL pour les projets Blazor ?

IronXL est disponible sous une licence de développement gratuite qui vous permet de créer et de tester sans aucune limite de temps. Pour les applications de production, une licence de déploiement est requise.

Vous pouvez télécharger une version d'essai gratuite directement depuis NuGet ; aucune inscription n'est nécessaire pour commencer. Lorsque vous serez prêt à déployer votre application, consultez les options de licence IronXL pour trouver le plan qui correspond à sa taille.

IronXL est compatible avec tous les principaux types d'applications .NET : Blazor Server, Blazor WebAssembly (rendu côté serveur), ASP.NET Core MVC, applications console et applications de bureau Windows. La bibliothèque cible .NET Standard 2.0 et est donc compatible avec toutes les versions de .NET prises en charge, de .NET Framework 4.6.2 à .NET 10. Si votre projet nécessite également la génération de PDF, IronPDF s'intègre parfaitement à IronXL , vous permettant d'exporter des données aux formats Excel ou PDF depuis la même couche de service.

Pour découvrir d'autres exemples spécifiques à Blazor, consultez le tutoriel d'exportation Excel Blazor et le guide d'exportation ASP.NET Core . Pour la lecture de feuilles de calcul existantes, le tutoriel sur le lecteur Excel en C# couvre les scénarios d'importation courants. Vous pouvez également consulter laprocédure pour créer un classeur Excel à partir de zéro pour les projets qui nécessitent la création de fichiers par programmation plutôt qu'à partir de modèles.

Questions Fréquemment Posées

Comment exporter des données vers Excel depuis des applications Blazor Server ?

Vous pouvez utiliser IronXL pour exporter des données vers Excel depuis des applications Blazor Server. IronXL vous permet de créer, de mettre en forme et de télécharger des fichiers Excel directement depuis le serveur, sans avoir besoin de Microsoft Office.

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

Non, Microsoft Office n'est pas nécessaire. IronXL vous permet de gérer les fichiers Excel dans les applications Blazor Server indépendamment de Microsoft Office.

Est-il possible de formater des fichiers Excel avec IronXL dans des applications Blazor ?

Oui, IronXL fournit des outils pour formater les fichiers Excel, vous permettant de personnaliser l'apparence de vos données directement depuis votre application Blazor Server.

IronXL est-il compatible avec les applications Blazor Server ?

Oui, IronXL s'intègre parfaitement aux applications Blazor Server, permettant une exportation et une gestion faciles des fichiers Excel.

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

IronXL offre une méthode simple pour créer et manipuler des fichiers Excel sans nécessiter Office, ce qui en fait une solution efficace pour exporter des données dans les applications Blazor .

IronXL peut-il gérer les fichiers Excel volumineux dans les applications Blazor Server ?

Oui, IronXL est conçu pour gérer efficacement les fichiers Excel volumineux au sein des applications Blazor Server.

Quels types de fichiers Excel puis-je créer avec IronXL dans une application Blazor ?

Avec IronXL, vous pouvez créer différents types de fichiers Excel, notamment XLSX, XLS et CSV, directement dans votre application Blazor .

Est-il possible de télécharger des fichiers Excel depuis une application Blazor Server en utilisant IronXL?

Oui, IronXL prend en charge le téléchargement direct de fichiers Excel depuis une application Blazor Server, offrant ainsi une expérience utilisateur optimale.

En quoi IronXL améliore-t-il les fonctionnalités d'exportation Excel dans Blazor par rapport aux autres solutions ?

IronXL simplifie le processus d'exportation de fichiers Excel dans Blazor en éliminant le besoin de Microsoft Office et en s'intégrant directement à votre application serveur.

Pourquoi IronXL est-il un bon choix pour les développeurs Blazor ?

IronXL est un excellent choix pour les développeurs Blazor car il offre des fonctionnalités robustes de gestion d'Excel, ne nécessite pas l'installation d'Office et s'intègre facilement aux applications Blazor Server.

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

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi