Wie man Excel-Dateien in Blazor mit IronXL exportiert

Erstellung des Blazor -Server-Projekts

Erstellen Sie zunächst ein neues Blazor Server-Projekt in Visual Studio 2022 oder höher mit .NET 10 als Zielplattform. Sobald das Projekt fertig ist, installieren Sie IronXL über die NuGet -Paket-Manager-Konsole:

Install-Package IronXl.Excel

IronXL funktioniert mit .NET 6 und höher, sodass bestehende Blazor Projekte es ohne Aktualisierung des Frameworks übernehmen können. Informationen zu alternativen Installationsmethoden – wie der NuGet Benutzeroberfläche oder der Befehlszeilenschnittstelle – finden Sie im IronXL Installationshandbuch .

Hinzufügen des JavaScript -Download-Helfers

Blazor Server läuft serverseitig, daher ist zum Auslösen eines Dateidownloads eine kleine JavaScript Brücke erforderlich. Fügen Sie in Ihrem Ordner wwwroot eine Datei mit dem Namen excelExport.js hinzu:

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

Fügen Sie dieses Skript in Ihre _Host.cshtml-Datei (oder App.razor in .NET 8+) ein:

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

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

Diese Funktion wandelt den Byte-Stream von Blazor in eine temporäre Blob-URL um, löst den Download im Browser aus und bereinigt anschließend das URL-Objekt, um Speicherlecks zu vermeiden. Es ist bewusst minimalistisch gehalten – die eigentliche Arbeit findet in C# auf dem Server statt.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten

Erstellen des ExcelExportService

Erstelle eine neue Datei 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();
    }
}

Registrierung des Dienstes

Fügen Sie den Dienst dem DI-Container in Program.cs hinzu:

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();

Dieser Service demonstriert mehrere wichtige Funktionen von IronXL . Sie können mit einem einzigen Methodenaufruf neue Arbeitsmappen und Arbeitsblätter erstellen , formatierte Überschriften anwenden, Zeilen aus beliebigen Datenquellen füllen und Excel-Formeln wie =D2*0.15 einbetten. Der Aufruf AutoSizeColumn stellt sicher, dass die Spalten breit genug sind, um ihren Inhalt unabhängig von der Datenlänge korrekt anzuzeigen. Weitere Formatierungsoptionen finden Sie im Leitfaden zur Zellenformatierung .

Schreiben der Razor Komponente

Erstelle eine Seite unter 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 }
        };
    }
}

Funktion der Komponente

Das Flag isExporting deaktiviert die Schaltfläche während der Generierung und verhindert so doppelte Anfragen. Der Wrapper DotNetStreamReference sorgt für effizientes Binärstreaming vom .NET Speicherstream zur JavaScript Funktion und vermeidet so große Base64-Strings, die die Nutzdatengröße unnötig erhöhen würden. Zeitgestempelte Dateinamen wie SalesReport_20260228.xlsx gewährleisten eine übersichtliche Downloadstruktur ohne zusätzliche Konfiguration.

Wenn Sie im Browser zu /excel-export navigieren, wird die Dashboard-Seite mit einer Export-Schaltfläche geladen:

Durch Klicken des Buttons wird die Tabelle generiert und der Browser lädt die Datei automatisch herunter:

Bedingte Formatierung für Inventurberichte

Der folgende Dienst hebt Artikel mit niedrigem Lagerbestand rot hervor – eine gängige Anforderung für Lager- oder Bestandsverwaltungsanwendungen:

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

IronXL wendet die Zellformatierung basierend auf den Datenwerten zum Zeitpunkt der Generierung an. Sie können außerdem bedingte Formatierungsregeln deklarativ anwenden oder mehrere Arbeitsblätter innerhalb derselben Arbeitsmappe verwalten – beispielsweise ein Blatt für den aktuellen Lagerbestand und ein weiteres für historische Bestellungen.

Hinzufügen mehrerer Arbeitsblätter zu einem einzigen Export

Die Aufteilung der Daten in logische Tabellenblätter verbessert die Lesbarkeit, ohne dass separate Downloads erforderlich sind:

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

Eine vollständige API-Referenz mit Informationen zu Arbeitsmappeneigenschaften, Bereichsoperationen und Diagrammunterstützung finden Sie in der IronXL API-Dokumentation .

Fehlerbehandlung in der Serviceschicht

Durch die Einbettung der Generierungslogik in den Service (und nicht in die Komponente) wird eine einheitliche Fehlerbehandlung für alle Aufrufer gewährleistet. Es wird empfohlen, IronXL Ausnahmen zunächst weiterzuleiten und sie dann in eine domänenspezifische Ausnahme mit Kontextinformationen darüber, welcher Bericht fehlgeschlagen ist, einzuschließen:

Platzieren Sie einen try/catch Block um die Arbeitsmappengenerierung in GenerateSalesReport, fangen Sie Exception ab und werfen Sie ihn als InvalidOperationException("Failed to generate sales report", ex) erneut aus. In der Blazor Komponente soll der Fehler InvalidOperationException abgefangen und eine benutzerfreundliche Meldung angezeigt werden, ohne interne Details preiszugeben. Protokollieren Sie die innere Ausnahme mit ILogger<t>, die in den Service-Konstruktor eingefügt wird, damit das Entwicklerteam Fehler auf eine bestimmte Arbeitsmappenoperation zurückführen kann. Geben Sie niemals unformatierte Fehlermeldungen an Endbenutzer weiter – Dateipfade, Speicheradressen oder Stacktraces können interne Serverinformationen offenlegen.

Hinweise zu Best Practices für die Fehlerbehandlung finden Sie in der offiziellen Microsoft-Dokumentation. Dort finden Sie Anleitungen zur strukturierten Fehlerprotokollierung in Blazor. Weitere Hinweise zum Erstellen testbarer Dienste in .NET finden Sie in der Microsoft-Dokumentation zur Abhängigkeitsinjektion. Dort wird erklärt, wie Dienste mit Gültigkeitsbereich registriert und aufgelöst werden. Genau dieses Muster wird hier mit ExcelExportService verwendet.

Leistungsüberlegungen für große Datensätze

Für Datensätze mit mehr als einigen tausend Zeilen sollten Sie folgende Ansätze in Betracht ziehen:

Die Methode ToStream() von IronXL schreibt direkt in einen Ausgabestream, ohne vorher die gesamte Datei in ein Byte-Array zu laden. Dadurch wird der Speicherverbrauch bei großen Arbeitsmappen reduziert. Weitere Hinweise zur Leistungsfähigkeit finden Sie unter Lesen und Schreiben großer Excel-Dateien mit IronXL.

Formeln, benannte Bereiche und Zahlenformatierung

Sie können jede beliebige Excel-Formel mit der gleichen Syntax einbetten, die Sie auch direkt in eine Zelle eingeben würden. IronXL wertet Formeln beim Einlesen aus, sodass die Empfänger der generierten Datei die berechneten Ergebnisse sofort nach dem Öffnen der Tabelle sehen. Benannte Bereiche machen Formeln im Laufe der Zeit lesbarer und wartungsfreundlicher:

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

Um benannte Bereiche zu definieren und das Zahlenformat explizit festzulegen, stellt IronXL beides als Eigenschaften des Bereichsobjekts bereit. Dadurch wird verhindert, dass Excel Währungswerte als Klartext behandelt – ein häufiges Problem beim Exportieren von Finanzdaten aus Datenbanken, die Werte als Zeichenketten speichern.

Unterstützte Excel-Dateiformate

IronXL kann mehrere Excel-Formate lesen und schreiben, darunter .xlsx, .xls, .csv und .tsv. Das Format wird beim Speichern festgelegt, sodass dieselbe Serviceklasse mit einer kleinen Parameteränderung sowohl Excel- als auch CSV-Exporte unterstützen kann:

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

Diese Flexibilität ist wichtig bei Integrationen, bei denen nachgelagerte Systeme – wie ERP-Plattformen oder Data Warehouses – ein bestimmtes Dateiformat erwarten. Einen vollständigen Funktionsvergleich zwischen IronXL und anderen Excel-Bibliotheken finden Sie auf der IronXL -Funktionsseite .

Microsoft bietet eine gute Referenz zum Verständnis von OOXML-Dateiformaten, falls Sie die interne Struktur von .xlsx-Dateien beim Debuggen unerwarteter Ausgaben verstehen müssen. Das NuGet Paket für IronXL ist auch auf NuGet mit vollständiger Versionshistorie und Kompatibilitätshinweisen aufgeführt.