Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronXL
  2. IronXL Blog
  3. IronXL verwenden
  4. Blazor Excel-Export
IRONXL VERWENDEN

Wie man in einem Blazor zu Excel exportiert mit IronXL

Jordi Bardia
Jordi Bardia
Aktualisiert:

Das Exportieren von Daten nach Excel ist etwas, das fast jede Web-App benötigt, sei es für die Erstellung von Berichten, Inventarlisten oder Kundenrechnungen. In einer Blazor Server-Anwendung kann es eine Herausforderung sein, dies zuverlässig zu erreichen, ohne Microsoft Office zu benötigen. Hier kommt IronXL ins Spiel. Es ermöglicht Ihnen, Excel-Dateien direkt von Ihrem Server zu erstellen, zu formatieren und herunterzuladen, ohne dass eine Office-Installation erforderlich ist, und es integriert sich nahtlos in Blazor. In diesem Leitfaden erfahren Sie, wie einfach es ist, Ihrer App professionelle Excel-Exportfunktionen hinzuzufügen. Lassen Sie uns beginnen.

Erste Schritte mit IronXL zum Exportieren von Daten nach Excel

Das Einrichten von IronXL in einer Blazor Server-Anwendung erfordert minimale Konfiguration. Beginnen Sie mit der Erstellung eines neuen Blazor Server-Projekts in Visual Studio 2022 oder später, das auf .NET 6 oder höher abzielt.

Installieren Sie IronXL über die NuGet-Paketmanager-Konsole (siehe unser vollständiges Installationshandbuch für alternative Methoden):

Install-Package IronXL.Excel

Erstellen Sie als Nächstes eine JavaScript-Hilfsfunktion für Dateidownloads. Fügen Sie in Ihrem wwwroot-Ordner eine neue JavaScript-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);
}
JAVASCRIPT

Binden Sie dieses Skript in Ihre _Host.cshtml-Datei ein:

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

Diese JavaScript-Funktion behandelt den Browser-seitigen Downloadmechanismus, der den Bytestream Ihrer Blazor Server-Anwendung in eine herunterladbare Datei konvertiert. Die Funktion erstellt eine temporäre Blob-URL, löst den Download aus und räumt Ressourcen auf, um Speicherlecks zu vermeiden.

Wie exportiere ich eine Datenquelle in Excel-Dateien mit IronXL?

Erstellen Sie einen Excel-Exportdienst, um Ihre Geschäftslogik zu handhaben. Dieser Dienst kapselt die IronXL-Funktionalität ein und bietet wiederverwendbare Methoden für verschiedene Export-Szenarien in Ihrer Blazor Excel-Export-Implementierung:

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);
        }
    }
}
Imports IronXL
Imports System.IO
Imports ExportExcel.Models

Public Class ExcelExportService
    Public Function GenerateSalesReport(salesData As List(Of SalesData)) As Byte()
        Try
            Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            workbook.Metadata.Author = "Sales Department"
            Dim 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"
            Dim headerRange = worksheet("A1:E1")
            headerRange.Style.Font.Bold = True
            headerRange.Style.BackgroundColor = "#4472C4"
            headerRange.Style.Font.Color = "#FFFFFF"
            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
        Catch ex As Exception
            ' If the program fails to return file
            Throw New InvalidOperationException("Failed to generate sales report", ex)
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

Dieser Dienst demonstriert wichtige IronXL-Funktionen, einschließlich der Erstellung neuer Arbeitsmappen und Arbeitsblätter, dem Hinzufügen formatierter Überschriften, dem Ausfüllen von Datenzeilen mit importierten Daten aus Ihrer Datenquelle, der Anwendung von Formeln und der Handhabung potenzieller Fehler. Die AutoSizeColumn-Methode stellt sicher, dass Spalten unabhängig von der Inhaltlänge korrekt angezeigt werden. Für erweiterte Formatierungsoptionen sehen Sie sich unseren Zellstil-Leitfaden an.

Wie implementieren Sie den Dateidownload in Blazor?

Erstellen Sie eine Razor-Komponente, die den Exportdienst nutzt und die Benutzerinteraktion handhabt:

@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 }
        };
    }
}
@page "/excel-export"
@Imports 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 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 = ""
            ' Generate sample data - replace with actual data source
            Dim salesData = GetSalesData()
            ' Generate Excel file
            Dim fileBytes = ExcelService.GenerateSalesReport(salesData)
            ' Trigger download using a memory stream to handle the file
            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."
            ' Log exception details for debugging
        Finally
            isExporting = False
        End Try
    End Function

    Private Function GetSalesData() As List(Of SalesData)
        ' Return your actual data here
        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

Diese Komponente bietet dem Benutzer während des Exports Feedback, behandelt Fehler anmutig und generiert Dateinamen mit Zeitstempel. Der DotNetStreamReference-Wrapper ermöglicht effizientes Streaming von Binärdaten zu JavaScript.

Ausgabe

Wenn wir unseren Code ausführen, sehen wir unsere Seite geladen mit dem Button, der für den Exportvorgang verwendet wird.

So exportieren Sie Daten aus Blazor mit IronXL nach Excel: Abbildung 1 – Beispielseite aus Blazor

Wenn wir den Button klicken, werden die Daten in einem neuen Excel-Dokument gespeichert und die exportierte Datei heruntergeladen.

So exportieren Sie Daten in Blazor mit IronXL nach Excel: Abbildung 2 – In eine Excel-Datei exportierte Daten

Welche erweiterten Funktionen kann IronXL zu Ihrem Excel-Export hinzufügen?

IronXL unterstützt anspruchsvolle Excel-Funktionen für professionell aussehende Exporte. Für ein Inventarverwaltungsszenario könnten Sie bedingte Formatierung und mehrere Arbeitsblätter hinzufügen:

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();
        }
    }
}
Imports IronXL
Imports ExportExcel.Models
Imports System.IO

Namespace ExportExcel.Services
    Public Class InventoryExportService
        Public Function GenerateInventoryReport(items As List(Of InventoryItem)) As Byte()
            Dim workbook = WorkBook.Create()
            Dim details = workbook.CreateWorkSheet("Inventory Details")
            ' Add headers
            details("A1").Value = "SKU"
            details("B1").Value = "Name"
            details("C1").Value = "Quantity"
            ' Apply bold font for headers
            Dim headerRange = details("A1:C1")
            headerRange.Style.Font.Bold = True
            For i As Integer = 0 To items.Count - 1
                Dim row = i + 2 ' start from row 2
                Dim 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 Then
                    details($"C{row}").Style.BackgroundColor = "#FFB6B6"
                End If
            Next
            Using stream = workbook.ToStream()
                Return stream.ToArray()
            End Using
        End Function
    End Class
End Namespace
$vbLabelText   $csharpLabel

IronXL handhabt mehrere Arbeitsblätter mühelos, wendet bedingte Formatierungen basierend auf Geschäftsregeln an und unterstützt fortgeschrittene Excel-Funktionen wie Pivot-Tabellen und Diagramme, wenn nötig. Für detaillierte API-Dokumentation besuchen Sie unseren umfassenden Referenzleiter.

Export nach Excel in Blazor mit IronXL: Abbildung 3 – Beispielausgabe für erweiterte Funktionen

Abschluss

IronXL verwandelt die Erstellung von Excel-Dateien in Blazor Server-Anwendungen von einer komplexen Herausforderung in eine unkomplizierte Aufgabe. Seine intuitive API beseitigt die Notwendigkeit von Microsoft Office-Installationen und bietet gleichzeitig Zugang zu erweiterten Excel-Funktionen. Von einfachen Datenexporten bis hin zu komplexen Mehrblattberichten mit Formeln und Formatierungen, IronXL bewältigt alles mit ausgezeichneter Leistung und Zuverlässigkeit.

Bereit, Ihre Blazor-Anwendungen mit professionellen Excel-Exportfähigkeiten zu erweitern? Starten Sie Ihre kostenlose Testversion für Produktionsbereitstellung.

Häufig gestellte Fragen

Wie kann ich Excel-Dateien in einer Blazor-Server-App exportieren?

Sie können IronXL verwenden, um Excel-Dateien in einer Blazor-Server-App zu exportieren. IronXL ermöglicht es Ihnen, Excel-Dateien direkt von Ihrem Server zu erstellen, zu formatieren und herunterzuladen, ohne dass Microsoft Office erforderlich ist.

Benötige ich Microsoft Office, um mit Excel-Dateien in Blazor zu arbeiten?

Nein, IronXL ermöglicht es Ihnen, mit Excel-Dateien zu arbeiten, ohne dass Microsoft Office erforderlich ist. Es bietet die Funktionalität zum Erstellen und Bearbeiten von Excel-Dateien direkt innerhalb Ihrer Blazor-Anwendung.

Welche Vorteile bietet die Verwendung von IronXL für den Excel-Export in Blazor?

IronXL bietet eine nahtlose Integration mit Blazor und ermöglicht es Ihnen, Excel-Dateien einfach zu erstellen, zu formatieren und zu exportieren. Es vereinfacht den Prozess, beseitigt den Bedarf an Microsoft Office und unterstützt verschiedene Excel-Formate.

Kann IronXL mit anderen Blazor-Komponenten integriert werden?

Ja, IronXL integriert sich nahtlos in Blazor-Komponenten und ermöglicht es Ihnen, die Excel-Exportfunktionalität problemlos zu Ihren Anwendungen hinzuzufügen.

Ist es möglich, Excel-Dateien mit IronXL in Blazor zu formatieren?

Ja, IronXL bietet umfassende Funktionen zur Formatierung von Excel-Dateien, einschließlich das Stylen von Zellen, Anpassen der Spaltenbreiten und Einrichten komplexer Formeln, alles innerhalb Ihrer Blazor-Server-Anwendung.

Wie gehen Sie mit großen Datensätzen beim Export nach Excel in Blazor um?

IronXL ist darauf ausgelegt, große Datensätze effizient zu verarbeiten und einen reibungslosen Ablauf beim Exportieren umfangreicher Daten in Excel-Dateien in einer Blazor-Serverumgebung zu gewährleisten.

Welche Excel-Dateiformate werden von IronXL unterstützt?

IronXL unterstützt verschiedene Excel-Dateiformate, einschließlich XLS, XLSX und CSV, und bietet Flexibilität, wie Sie Excel-Daten in Ihren Blazor-Anwendungen exportieren und verarbeiten.

Kann IronXL zum Erstellen von Berichten in Blazor verwendet werden?

Absolut, IronXL ist ideal für die Erstellung detaillierter Berichte in Blazor-Anwendungen. Es bietet robuste Funktionen, um Daten in professionelle Excel-Berichte zu kompilieren, zu formatieren und zu exportieren.

Wie stellt IronXL die Datenintegrität beim Export von Excel-Dateien sicher?

IronXL stellt die Datenintegrität sicher, indem es die Struktur und Formatierung Ihrer Daten während des Exportvorgangs genau erhält und ist damit eine zuverlässige Lösung für Blazor-Anwendungen.

Gibt es eine Möglichkeit, die Erstellung von Excel-Dateien in einer Blazor-Server-App mit IronXL zu automatisieren?

Ja, IronXL kann verwendet werden, um die Erstellung und den Export von Excel-Dateien in Blazor-Server-Apps zu automatisieren, was es Ihnen ermöglicht, Arbeitsabläufe zu optimieren und die Effizienz zu verbessern.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an