Der Datenexport nach Excel ist eine Funktion, die nahezu jede Blazor -Webanwendung benötigt – egal ob es sich um Verkaufsberichte, Inventarlisten oder Kundenrechnungen handelt. In einer Blazor -Server-Anwendung kann dies jedoch ohne Microsoft Office zuverlässig umzusetzen, eine Herausforderung darstellen. IronXL macht es Ihnen leicht: Sie können Excel-Dateien direkt vom Server erstellen, formatieren und herunterladen, ohne dass eine Office-Installation erforderlich ist. Dieser Leitfaden führt Sie durch die Entwicklung einer produktionsreifen Excel-Exportfunktion in Blazor mit IronXL – von der Projekteinrichtung und dem Service-Design bis hin zu erweiterten Formatierungen und mehrseitigen Berichten.
Bevor Sie die Exportlogik schreiben, müssen Sie IronXL zu einem Blazor Server-Projekt hinzufügen und einen browserseitigen Download-Helfer konfigurieren.
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:
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 .
Blazor Server läuft serverseitig, daher ist zum Auslösen eines Dateidownloads eine kleine JavaScript Brücke erforderlich. In Ihrem wwwroot Ordner fügen Sie eine Datei namens 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);
}Integrieren Sie dieses Skript in Ihre _Host.cshtml Datei (oder App.razor in .NET 8+):
<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.
Durch die Trennung der Excel-Generierung von Ihren Razor Komponenten bleibt der Code testbar und kann über mehrere Seiten hinweg wiederverwendet werden. Das untenstehende Muster kapselt IronXL in eine eigene Serviceklasse ein.
Erstellen Sie 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();
}
}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 ClassFü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();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()Dieser Service demonstriert mehrere wichtige Funktionen von IronXL . Sie können neue Arbeitsmappen und Arbeitsblätter erstellen mit einem einzigen Methodenaufruf, gestaltete Kopfzeilen anwenden, Zeilen aus beliebigen Datenquellen füllen und Excel-Formeln wie =D2*0.15 einbetten. Der AutoSizeColumn Aufruf stellt sicher, dass die Spalten breit genug sind, um ihren Inhalt korrekt anzuzeigen, unabhängig von der Datenlänge. Weitere Formatierungsoptionen finden Sie im Leitfaden zur Zellenformatierung .
Sobald der Dienst eingerichtet ist, benötigen Sie eine Razor Komponente, die ihn aufruft und die resultierenden Bytes an den Browser übergibt.
Erstellen Sie eine Seite bei 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 }
};
}
}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
}Das isExporting Flag deaktiviert den Button während der Generierung, um doppelte Anfragen zu verhindern. Der DotNetStreamReference Wrapper sorgt für effizientes binäres Streaming vom .NET-Speicherstrom zur JavaScript-Funktion und vermeidet große Base64-Strings, die die Payload-Größe aufblähen würden. Zeitgestempelte Dateinamen wie SalesReport_20260228.xlsx halten Downloads ohne zusätzliche Konfiguration organisiert.
Wenn Sie im Browser zu /excel-export navigieren, lädt die Dashboard-Seite mit einem Export-Button:
Durch Klicken des Buttons wird die Tabelle generiert und der Browser lädt die Datei automatisch herunter:
Für viele Anwendungsfälle genügen einfache Datenexporte, Produktionsanwendungen benötigen jedoch häufig bedingte Formatierung, mehrere Arbeitsblätter oder eine Datenvalidierung. IronXL unterstützt all diese Funktionen nativ.
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();
}
}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 ClassIronXL 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.
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 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 FunctionEine vollständige API-Referenz mit Informationen zu Arbeitsmappeneigenschaften, Bereichsoperationen und Diagrammunterstützung finden Sie in der IronXL -API-Dokumentation .
Bei großen Datensätzen können Excel-Exportvorgänge unbemerkt fehlschlagen oder die Leistung beeinträchtigen. Die folgenden Muster gehen auf beide Bedenken ein.
Durch die Einbettung der Generierungslogik in den Service (und nicht in die Komponente) wird eine einheitliche Fehlerbehandlung für alle Aufrufer gewährleistet. Das empfohlene Vorgehen besteht darin, IronXL Ausnahmen sich selbst überlassen 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 Arbeitsmappe-Erstellung in GenerateSalesReport, fangen Sie Exception ab und werfen Sie diese als InvalidOperationException("Failed to generate sales report", ex) erneut. Fangen Sie in der Blazor-Komponente die InvalidOperationException ab und zeigen Sie eine benutzerfreundliche Nachricht an, ohne interne Details offenzulegen. Protokollieren Sie die innere Ausnahme mit ILogger<t>, die in den Dienstkonstruktor injiziert wird, damit das Entwicklungsteam Fehler zu einem bestimmten Arbeitsmappenprozess zurückverfolgen 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. Für weitere Anleitungen zum Erstellen testbarer Dienste in .NET erklärt die Microsoft-Dokumentation zur Abhängigkeitsinjektion, wie Sie Scoped-Services registrieren und auflösen – genau das Muster, das hier mit ExcelExportService verwendet wird.
Für Datensätze mit mehr als einigen tausend Zeilen sollten Sie folgende Ansätze in Betracht ziehen:
| Strategie | Wann verwenden? | IronXL Unterstützung |
|---|---|---|
| Streamen Sie direkt zur Antwort | Files >10 MB | workbook.ToStream() |
| Daten vor dem Export paginieren | UI-gesteuerte Exporte mit Filtern | Im Service anwenden, bevor die Arbeitsmappe erstellt wird |
| Hintergrundjob + Download-Link | Reports taking >5 seconds | Kombinieren Sie es mit SignalR oder Polling. |
| Automatische Spaltengröße auf großen Tabellenblättern deaktivieren | Sheets with >500 rows | Legen Sie stattdessen feste Spaltenbreiten fest. |
Die ToStream() Methode von IronXL schreibt direkt in einen Ausgabestream, ohne die gesamte Datei zuerst in ein Byte-Array zu laden, was den Speicherverbrauch bei großen Arbeitsmappen gering hält. Für zusätzliche Leistungsleitlinien siehe Lesen und Schreiben großer Excel-Dateien mit IronXL.
Über den einfachen Export hinaus bietet IronXL eine breite Palette von Excel-Funktionen, die den Anforderungen an die Berichtserstellung in der Praxis gerecht werden.
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.67D
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 beide als Eigenschaften auf dem Bereichsobjekt zur Verfügung. 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.
IronXL kann mehrere Excel-Formate lesen und schreiben, einschließlich .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 ms As Stream = workbook.ToStream(ExcelFileFormat.CSV)
End UsingDiese 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 für das Verständnis der OOXML-Dateiformate, 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.
IronXL ist unter einer kostenlosen Entwicklerlizenz erhältlich, die es Ihnen ermöglicht, ohne zeitliche Begrenzung zu entwickeln und zu testen. Für Produktionsanwendungen ist eine Bereitstellungslizenz erforderlich.
Sie können eine kostenlose Testversion direkt von NuGet herunterladen – zum Starten ist keine Registrierung erforderlich. Wenn Sie bereit für die Bereitstellung sind, prüfen Sie die IronXL -Lizenzierungsoptionen, um den Plan zu finden, der zum Umfang der Anwendung passt.
IronXL ist mit allen gängigen .NET Anwendungstypen kompatibel – Blazor Server, Blazor WebAssembly (serverseitig gerendert), ASP.NET Core MVC, Konsolenanwendungen und Windows-Desktopanwendungen. Die Bibliothek ist für .NET Standard 2.0 ausgelegt und somit mit allen unterstützten .NET Versionen von .NET Framework 4.6.2 bis .NET 10 kompatibel. Falls Ihr Projekt auch die PDF-Generierung erfordert, lässt sich IronPDF nahtlos in IronXL integrieren. So können Sie Daten aus derselben Serviceebene entweder als Excel- oder als PDF-Datei exportieren.
Weitere Blazor-spezifische Beispiele finden Sie im Blazor Excel-Export-Tutorial und im ASP.NET Core Exportleitfaden . Zum Lesen vorhandener Tabellenkalkulationen behandelt das C# Excel Reader-Tutorial gängige Importszenarien. Sie können auch nachlesen, wie Sie eine neue Excel-Arbeitsmappe von Grund auf neu erstellen, für Projekte, bei denen Dateien programmatisch und nicht anhand von Vorlagen erstellt werden müssen.
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.
