.NET Core Excel-Tabellenkalkulation: Professionelle Excel-Arbeitsblattdateien in C# mit IronXL erstellen

Wie kann ich Excel-Tabellen in .NET Core ohne Office-Abhängigkeiten erstellen?

Die herkömmliche Microsoft Excel-Automatisierung erfordert eine MS Office-Installation und verwendet Office Interop, was unter Linux oder in containerisierten Umgebungen nicht funktioniert. Wie in der Microsoft-Dokumentation beschrieben, führt Office Interop auch zu einer komplexen Bereitstellung und zu Problemen bei der Lizenzierung. IronXLfor .NET beseitigt diese Beschränkungen durch die Bereitstellung einer reinen .NET-Lösung, die Excel-Dateien nativ mit voller Unterstützung für moderne Tabellenkalkulationsfunktionen verarbeitet.

Die Bibliothek unterstützt .NET 8, .NET 9 und .NET 10, sowie frühere .NET Core Versionen. Sie verarbeitet XLSX, XLS, CSV und andere Tabellenkalkulationsformate ohne externe Abhängigkeiten. Das macht sie besonders wertvoll für serverseitige Anwendungen, Microservices und Szenarien, in denen die Installation von Microsoft Office nicht sinnvoll ist. Dank der einfachen Integration über die Installation von NuGet-Paketen können Entwickler innerhalb weniger Minuten mit dem Schreiben von Excel-Dateien beginnen. Öffnen Sie Visual Studio, rufen Sie die NuGet-Paketmanager-Konsole auf und führen Sie den folgenden Befehl aus:

Install-Package IronXL.Excel

using IronXL;
// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add an Excel worksheet with a custom name
WorkSheet sheet = workbook.CreateWorkSheet("SalesReport");
// Set a cell value
sheet["A1"].Value = "Product Sales Summary";
// Save the generated Excel file
workbook.SaveAs("SalesReport.xlsx");

using IronXL;
// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add an Excel worksheet with a custom name
WorkSheet sheet = workbook.CreateWorkSheet("SalesReport");
// Set a cell value
sheet["A1"].Value = "Product Sales Summary";
// Save the generated Excel file
workbook.SaveAs("SalesReport.xlsx");

Die Methode WorkBook.Create() initialisiert eine neue Excel-Arbeitsmappe und akzeptiert einen ExcelFileFormat-Parameter zur Angabe von XLSX (modernes XML-basiertes Format, das in Excel 2007 eingeführt wurde) oder XLS (altes Binärformat). Aufgrund der geringeren Dateigröße und der besseren Kompatibilität mit modernen Tools wird für die meisten Szenarien XLSX empfohlen. Die Methode CreateWorkSheet() fügt benannte Arbeitsblätter hinzu, in denen Excel-Daten gespeichert werden - jede Arbeitsmappe kann mehrere einzelne Blätter enthalten, um zusammengehörige Daten zu organisieren.

Welche Schritte sind erforderlich, um Arbeitsblätter hinzuzufügen und Daten einzugeben?

Echte Excel-Tabellen enthalten strukturierte Daten auf mehreren Arbeitsblättern. IronXLbietet flexible Methoden für die Organisation von Informationen und die effiziente Befüllung von Zellen, unabhängig davon, ob mit manueller Dateneingabe oder automatisierten Datenpipelines in datengesteuerten Anwendungen gearbeitet wird.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("MonthlySales");
// Set column names as headers
sheet["A1"].Value = "Month";
sheet["B1"].Value = "Revenue";
sheet["C1"].Value = "Units Sold";
// Populate Excel data using a loop (mock sales data)
string[] months = { "January", "February", "March", "April", "May", "June" };
decimal[] revenue = { 45000.50m, 52000.75m, 48500.25m, 61000.00m, 58750.50m, 67200.25m };
int[] units = { 150, 175, 160, 200, 190, 220 };
for (int i = 0; i < months.Length; i++)
{
    int row = i + 2;
    sheet[$"A{row}"].Value = months[i];
    sheet[$"B{row}"].Value = revenue[i];
    sheet[$"C{row}"].Value = units[i];
}
// Set a range of cells to the same value across columns
sheet["D2:D7"].Value = "Active";
workbook.SaveAs("MonthlySales.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("MonthlySales");
// Set column names as headers
sheet["A1"].Value = "Month";
sheet["B1"].Value = "Revenue";
sheet["C1"].Value = "Units Sold";
// Populate Excel data using a loop (mock sales data)
string[] months = { "January", "February", "March", "April", "May", "June" };
decimal[] revenue = { 45000.50m, 52000.75m, 48500.25m, 61000.00m, 58750.50m, 67200.25m };
int[] units = { 150, 175, 160, 200, 190, 220 };
for (int i = 0; i < months.Length; i++)
{
    int row = i + 2;
    sheet[$"A{row}"].Value = months[i];
    sheet[$"B{row}"].Value = revenue[i];
    sheet[$"C{row}"].Value = units[i];
}
// Set a range of cells to the same value across columns
sheet["D2:D7"].Value = "Active";
workbook.SaveAs("MonthlySales.xlsx");

Die String-Interpolation ($"A{row}") ermöglicht die dynamische Adressierung von Zellen innerhalb von Schleifen und macht es einfach, Zeilen programmatisch aus jeder Datenquelle zu füllen. Die Bereichssyntax sheet["D2:D7"] wendet Werte auf mehrere Zellen gleichzeitig an - nützlich für Statusspalten, Standardwerte oder die Initialisierung von Datenbereichen. IronXLübernimmt automatisch die Konvertierung von Datentypen und speichert Dezimalzahlen als numerische Werte und String-Inhalte als Text, wobei die entsprechenden Excel-Datentypen für die generierte Excel-Datei beibehalten werden.

Für Anwendungen, die eine Datenbankintegration erfordern, arbeitet IronXLnahtlos mit Entity Framework Core, Dapper oder raw ADO.NET zusammen. Daten aus DataTable-Objekten können direkt in Arbeitsblätter exportiert werden, was die Arbeitsabläufe bei der Berichterstellung vereinfacht und es den Benutzern ermöglicht, Daten systemübergreifend zu nutzen.

Durch die Erstellung mehrerer Arbeitsblätter werden zusammengehörige Excel-Daten logisch in einer einzigen Arbeitsmappe organisiert:

WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
WorkSheet detailSheet = workbook.CreateWorkSheet("Details");
WorkSheet archiveSheet = workbook.CreateWorkSheet("Archive");

WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
WorkSheet detailSheet = workbook.CreateWorkSheet("Details");
WorkSheet archiveSheet = workbook.CreateWorkSheet("Archive");

Erfahren Sie mehr über Verwaltung von Arbeitsblättern und Schreiben von Excel-Dateien in der IronXL-Dokumentation. Zum Lesen einer vorhandenen Excel-Datei siehe das Tutorial zum Laden von Excel-Dateien.

Wie wende ich professionelle Formatierung und Stilisierung an?

Rohdaten werden aussagekräftig, wenn sie richtig formatiert sind. IronXLunterstützt Hintergrundfarben, Schriftarten, Rahmen und Zahlenformate - wichtige Formatierungsfunktionen, mit denen Excel-Tabellen in ausgefeilte Berichte verwandelt werden können, die sich für Präsentationen für Führungskräfte oder Kunden eignen.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("FormattedReport");
// Create headers with styling
sheet["A1"].Value = "Category";
sheet["B1"].Value = "Amount";
sheet["C1"].Value = "Date";
// Apply header formatting to the Excel sheet
sheet["A1:C1"].Style.SetBackgroundColor("#2E86AB");
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.Font.SetColor("#FFFFFF");
// Add sample data to specific cells
sheet["A2"].Value = "Software License";
sheet["B2"].Value = 1299.99m;
sheet["C2"].Value = DateTime.Now;
// Format currency and date columns
sheet["B2"].FormatString = "$#,##0.00";
sheet["C2"].FormatString = "yyyy-MM-dd";
// Add borders around the data range
var dataRange = sheet["A1:C2"];
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
workbook.SaveAs("FormattedReport.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("FormattedReport");
// Create headers with styling
sheet["A1"].Value = "Category";
sheet["B1"].Value = "Amount";
sheet["C1"].Value = "Date";
// Apply header formatting to the Excel sheet
sheet["A1:C1"].Style.SetBackgroundColor("#2E86AB");
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.Font.SetColor("#FFFFFF");
// Add sample data to specific cells
sheet["A2"].Value = "Software License";
sheet["B2"].Value = 1299.99m;
sheet["C2"].Value = DateTime.Now;
// Format currency and date columns
sheet["B2"].FormatString = "$#,##0.00";
sheet["C2"].FormatString = "yyyy-MM-dd";
// Add borders around the data range
var dataRange = sheet["A1:C2"];
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
workbook.SaveAs("FormattedReport.xlsx");

Die Eigenschaft Stil bietet Formatierungsoptionen, die den Möglichkeiten von Microsoft Excel entsprechen. Hintergrundfarben akzeptieren Hex-Codes (mit oder ohne #-Präfix), während FormatString Zahlenformate anwendet, die mit der benutzerdefinierten Formatierungssyntax von Excel identisch sind - dieselben Muster funktionieren in beiden Umgebungen. Die Randgestaltung unterstützt verschiedene Typen, darunter Dünn, Mittel, Dick und Doppelt, und ermöglicht eine präzise Steuerung der Zellgrenzen in Ihrem Excel-Arbeitsblatt.

Bei Excel-Tabellen mit umfangreichen Daten sorgt CreateFreezePane(0, 1) dafür, dass die Kopfzeilen beim Scrollen sichtbar bleiben - eine subtile Verbesserung, die die Benutzerfreundlichkeit bei großen Datensätzen deutlich erhöht und die Leistung der Tabelle verbessert. Die Druckkonfiguration über sheet.PrintSetup regelt Ausrichtung, Ränder und Skalierung für die physische Ausgabe.

Weitere Gestaltungsoptionen finden Sie im Leitfaden zur Zellenformatierung und im Tutorial zur Konfiguration von Rahmen. Diese Tools geben Entwicklern vollständigen Zugriff auf die Bearbeitung und Anpassung jedes Aspekts des Zellaussehens.

Wie kann ich Excel-Formeln für Berechnungen verwenden?

Die Berechnungs-Engine von Excel ist eine Kernfunktion, die die Datenanalyse automatisiert, und IronXLbietet vollständige Unterstützung für Formeln. Formeln werden als Zeichenketten mit der Standard-Excel-Syntax eingegeben, und IronXLberechnet die Ergebnisse automatisch, wenn sie angefordert werden - wichtig für Berichte und Finanzanalysen.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("BudgetCalculations");
// Add expense data to the Excel workbook
sheet["A1"].Value = "Expense";
sheet["B1"].Value = "Amount";
sheet["A2"].Value = "Rent";
sheet["B2"].Value = 2500;
sheet["A3"].Value = "Utilities";
sheet["B3"].Value = 350;
sheet["A4"].Value = "Supplies";
sheet["B4"].Value = 875;
sheet["A5"].Value = "Marketing";
sheet["B5"].Value = 1200;
// Add formulas for calculations
sheet["A7"].Value = "Total:";
sheet["B7"].Formula = "=SUM(B2:B5)";
sheet["A8"].Value = "Average:";
sheet["B8"].Formula = "=AVERAGE(B2:B5)";
sheet["A9"].Value = "Maximum:";
sheet["B9"].Formula = "=MAX(B2:B5)";
sheet["A10"].Value = "Count:";
sheet["B10"].Formula = "=COUNT(B2:B5)";
// Calculate all formulas
workbook.EvaluateAll();
// Access calculated values programmatically
decimal total = sheet["B7"].DecimalValue;
Console.WriteLine($"Calculated total: {total}");
workbook.SaveAs("BudgetCalculations.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("BudgetCalculations");
// Add expense data to the Excel workbook
sheet["A1"].Value = "Expense";
sheet["B1"].Value = "Amount";
sheet["A2"].Value = "Rent";
sheet["B2"].Value = 2500;
sheet["A3"].Value = "Utilities";
sheet["B3"].Value = 350;
sheet["A4"].Value = "Supplies";
sheet["B4"].Value = 875;
sheet["A5"].Value = "Marketing";
sheet["B5"].Value = 1200;
// Add formulas for calculations
sheet["A7"].Value = "Total:";
sheet["B7"].Formula = "=SUM(B2:B5)";
sheet["A8"].Value = "Average:";
sheet["B8"].Formula = "=AVERAGE(B2:B5)";
sheet["A9"].Value = "Maximum:";
sheet["B9"].Formula = "=MAX(B2:B5)";
sheet["A10"].Value = "Count:";
sheet["B10"].Formula = "=COUNT(B2:B5)";
// Calculate all formulas
workbook.EvaluateAll();
// Access calculated values programmatically
decimal total = sheet["B7"].DecimalValue;
Console.WriteLine($"Calculated total: {total}");
workbook.SaveAs("BudgetCalculations.xlsx");

Die Eigenschaft "Formel" akzeptiert die standardmäßige Excel-Formelsyntax - dieselben Formeln, die in Microsoft Excel funktionieren, werden hier verwendet. Nach dem Setzen von Formeln rufen Sie EvaluateAll() auf, um die Ergebnisse zu berechnen. Dieser Schritt stellt sicher, dass berechnete Werte sofort über typisierte Eigenschaften wie DecimalValue, IntValue oder StringValue verfügbar sind. Ohne den Aufruf von EvaluateAll() werden Formeln immer noch korrekt gespeichert und berechnet, wenn sie in Excel geöffnet werden, aber der programmatische Zugriff auf die Ergebnisse erfordert zunächst eine Auswertung.

decimal sum = sheet["B2:B5"].Sum();
decimal avg = sheet["B2:B5"].Avg();
decimal max = sheet["B2:B5"].Max();

decimal sum = sheet["B2:B5"].Sum();
decimal avg = sheet["B2:B5"].Avg();
decimal max = sheet["B2:B5"].Max();

Wie exportiere ich Excel-Dateien und stelle sie zum Download bereit?

IronXL unterstützt mehrere Exportformate, um unterschiedliche Integrationsanforderungen zu erfüllen. Neben den Standard-Excel-Formaten können Tabellenkalkulationen in CSV für den Datenaustausch, JSON für Webanwendungen oder TSV für die Kompatibilität mit Altsystemen exportiert werden. Diese Flexibilität macht es einfach, die Excel-Erstellung in jeden Arbeitsablauf zu integrieren.

using IronXL;
WorkBook workbook = WorkBook.Load("BudgetCalculations.xlsx");
// Export to different formats - save the Excel data as needed
workbook.SaveAs("output.xlsx");      // Modern Excel (Office 2007+)
workbook.SaveAs("output.xls");       // Legacy Excel (97-2003)
workbook.SaveAsCsv("output.csv");    // CSV for data import/export
workbook.SaveAsJson("output.json");  // JSON for web APIs

using IronXL;
WorkBook workbook = WorkBook.Load("BudgetCalculations.xlsx");
// Export to different formats - save the Excel data as needed
workbook.SaveAs("output.xlsx");      // Modern Excel (Office 2007+)
workbook.SaveAs("output.xls");       // Legacy Excel (97-2003)
workbook.SaveAsCsv("output.csv");    // CSV for data import/export
workbook.SaveAsJson("output.json");  // JSON for web APIs

Jedes Format dient bestimmten Anwendungsfällen. XLSX eignet sich am besten für die Beibehaltung von Formatierungen und Formeln bei der Weitergabe an Excel-Benutzer. CSV bietet maximale Kompatibilität für den Import in Datenbanken, Analysetools oder andere Tabellenkalkulationsanwendungen. JSON lässt sich problemlos in JavaScript-Frontends und REST-APIs integrieren. Für Dokumenten-Workflows sollten Sie die Integration mit Tools zur PDF-Erzeugung in Betracht ziehen, um Ihre Excel-Daten in PDF zu konvertieren.

[HttpGet("download-report")]
public IActionResult DownloadReport()
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workbook.CreateWorkSheet("Report");
    sheet["A1"].Value = "Generated Report";
    sheet["A2"].Value = DateTime.Now;
    var stream = workbook.ToStream();
    return File(stream,
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        "Report.xlsx");
}

[HttpGet("download-report")]
public IActionResult DownloadReport()
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workbook.CreateWorkSheet("Report");
    sheet["A1"].Value = "Generated Report";
    sheet["A2"].Value = DateTime.Now;
    var stream = workbook.ToStream();
    return File(stream,
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        "Report.xlsx");
}

Leistungs- und Sicherheitsaspekte bei der Excel-Erstellung

Bei der Entwicklung von Anwendungen, die Excel-Dateien in .NET Core generieren, haben sowohl Leistung als auch Sicherheit oberste Priorität—zumal Benutzer schnelle, zuverlässige und sichere Tabellenkalkulationslösungen erwarten. Das moderne .NET Core-Tabellenkalkulationssteuerelement wurde entwickelt, um eine leistungsstarke Excel-Dateigenerierung zu bieten, die es ermöglicht, selbst die komplexesten Excel-Arbeitsblätter ohne den Overhead von Microsoft Office oder Office Interop zu erstellen und zu bearbeiten.

Für eine optimale Leistung der Tabellenkalkulation nutzt das .NET Core-Steuerelement für Tabellenkalkulation fortschrittliche Techniken wie Datenvirtualisierung. Das bedeutet, dass Ihre Anwendung große Datenmengen effizient verarbeiten und in Excel-Dateien exportieren kann, ohne dass es zu Speicherengpässen oder Verlangsamungen kommt. Durch die Unterstützung von Multi-Threading wird die Leistung weiter gesteigert, da die gleichzeitige Verarbeitung mehrerer Aufgaben zur Erstellung von Excel-Dateien möglich ist, wodurch sichergestellt wird, dass selbst datenintensive Vorgänge schnell und effizient abgeschlossen werden.

Sicherheit ist bei der Arbeit mit Excel-Dateien ebenso wichtig, insbesondere beim Umgang mit sensiblen oder vertraulichen Daten. Durch den unabhängigen Betrieb von Microsoft Office und die Vermeidung von Office Interop minimiert das .NET Core Tabellenkalkulationssteuerelement das Risiko externer Schwachstellen und gewährleistet eine sicherere Umgebung für Ihre .NET-Anwendungen. Die integrierte Unterstützung für Verschlüsselung und Kennwortschutz ermöglicht es Ihnen, Ihre generierten Excel-Dateien zu schützen und sicherzustellen, dass nur autorisierte Benutzer auf wichtige Arbeitsblätter und Daten zugreifen oder diese bearbeiten können.

Warum diese Bibliothek gegenüber anderen .NET-Excel-Lösungen bevorzugen?

Es gibt mehrere Bibliotheken für die .NET-Excel-Bearbeitung, jede mit unterschiedlichen Stärken. Hier sehen Sie, wie IronXLals Lösung für die Erstellung und Verwaltung von Excel-Dateien abschneidet:

Abschluss

Die Erstellung von .NET Core Excel-Tabellen mit IronXLvereinfacht die ehemals komplexe, abhängigkeitslastige Aufgabe. Von der grundlegenden Zellmanipulation bis hin zu Formelberechnungen und professioneller Formatierung bietet die Bibliothek ein komplettes Toolkit für die Automatisierung von Tabellenkalkulationen, das überall dort läuft, wo .NET läuft: auf Windows-Servern, Linux-Containern oder Cloud-Plattformen.

Die plattformübergreifende Architektur gewährleistet ein identisches Verhalten auf Entwicklungsmaschinen und in Produktionsumgebungen, wodurch die bei Office-Interop-Lösungen üblichen "funktioniert auf meinem Rechner"-Probleme vermieden werden. Wie in den Diskussionen der .NET Foundation erwähnt, zielt die moderne .NET-Entwicklung zunehmend auf eine plattformübergreifende Bereitstellung ab, wodurch Office-unabhängige Bibliotheken für wartbare Lösungen und eine bessere Systemkompatibilität unerlässlich sind.

Bereit, loszulegen? Laden Sie eine kostenlose 30-Tage-Testversion herunter, um alle Funktionen ohne Einschränkungen zu erkunden, oder sehen Sie sich die Lizenzierungsoptionen für den Produktionseinsatz an. Weitere Code-Beispiele für fortgeschrittene Szenarien wie Lesen einer bestehenden Excel-Datei oder Arbeiten mit passwortgeschützten Arbeitsmappen finden Sie in der vollständigen Dokumentation und API-Referenz.