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.
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):
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);
}Binden Sie dieses Skript in Ihre _Host.cshtml-Datei ein:
<script src="~/excelExport.js"></script>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.
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);
}
}
}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 ClassDieser 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.
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"
@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
}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.
Wenn wir unseren Code ausführen, sehen wir unsere Seite geladen mit dem Button, der für den Exportvorgang verwendet wird.
Wenn wir den Button klicken, werden die Daten in einem neuen Excel-Dokument gespeichert und die exportierte Datei heruntergeladen.
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();
}
}
}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 NamespaceIronXL 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.
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.
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronXL ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Das Excel-API, das Sie brauchen, ohne den Office Interop Aufwand.
