Die programmatische Generierung von Excel-Arbeitsblattdateien in C# oder Visual Basic erforderte traditionell eine Microsoft Office-Installation oder eine komplexe COM-Interop. IronXL ändert dies vollständig und bietet eine einfache API, die Excel-Anwendungsdateien ohne jegliche Office-Abhängigkeiten erstellt. Dieses Tutorial führt Sie durch die Erstellung von Excel-Dateien in C# mit IronXL, von der grundlegenden Tabellenkalkulationserstellung bis zur erweiterten Formatierung und Datenbankintegration. Ganz gleich, ob Sie Berichte erstellen, Daten exportieren (XLS- oder XLSX-Dateien) oder die Erstellung von Tabellenkalkulationen automatisieren, Sie lernen die wichtigsten Techniken für die Arbeit mit Excel in .NET-Anwendungen.
Die Entwicklung von Excel-Generierungsfunktionen ohne Office-Abhängigkeiten löst kritische Bereitstellungsprobleme. Serverumgebungen haben aufgrund der Lizenzierungskosten und des Ressourcenaufwands selten Microsoft Office installiert. Jede Office-Installation erfordert erheblichen Festplattenspeicher und Arbeitsspeicher, was sie für Cloud-Bereitstellungen oder containerisierte Anwendungen unpraktisch macht.
IronXL beseitigt diese Beschränkungen, indem es unabhängig arbeitet. Ihre C#-Excel-Dateigenerierung läuft unter Windows, Linux, macOS, Docker-Containern oder Azure App Services ohne Änderungen. Diese plattformübergreifende Kompatibilität bedeutet einmal schreiben und überall bereitstellen, egal ob Sie .NET Framework, .NET Core oder .NET 8/9-Anwendungen anvisieren.
Die Leistung verbessert sich dramatisch ohne COM Interop-Overhead. Traditionelle Office-Automatisierung erstellt für jede Operation separate Prozessinstanzen, die Speicher und CPU-Ressourcen verbrauchen. IronXL verarbeitet alles im Speicher innerhalb des Prozessraums Ihrer Anwendung, was zu einer schnelleren Ausführung und einem geringeren Ressourcenverbrauch führt, wenn Sie Excel-Dateien programmgesteuert generieren.
Die Bereitstellung wird einfach, da IronXL als einzelnes NuGet-Paket geliefert wird. Ohne Registrierungseinträge, ohne COM-Registrierung und ohne zu pflegende Office-Service-Packs. Ihre kontinuierlichen Integrationspipelines funktionieren nahtlos und Docker-Container bleiben leichtgewichtig. Dieser vereinfachte Ansatz hat IronXL zu einer beliebten Wahl gemacht, wie in verschiedenen Entwicklerforen diskutiert, in denen Fachleute ihre Erfahrungen mit der Automatisierung von Excel teilen.
Einige Entwickler erforschen immer noch Microsofts Open XML Productivity Tool, um direkt mit Office Open XML-Dateistrukturen zu arbeiten. Dieser Ansatz erfordert jedoch mehr manuellen Aufwand und detaillierte Kenntnisse des XML-Schemas und der Installation von Open XML SDK. IronXL abstrahiert diese Komplexität und bietet Ihnen einen viel schnelleren Weg, mit Excel programmatisch zu arbeiten.
Die Installation von IronXL erfolgt in wenigen Augenblicken über den NuGet-Paketmanager im Solution Explorer. Klicken Sie in Visual Studio mit der rechten Maustaste auf Ihr Projekt und wählen Sie "NuGet-Pakete verwalten". Suchen Sie nach "IronXL.Excel" und klicken Sie auf Installieren. Das Paket beinhaltet automatisch alle Abhängigkeiten, die für die Generierung von Excel-Dateien in C# erforderlich sind.
Alternativ können Sie die Paket-Manager-Konsole verwenden:
Für .NET CLI-Benutzer, die mit modernen C#-Projekten arbeiten:
Überprüfen Sie die Installation mit diesem einfachen Test zur programmgesteuerten Erstellung einer Excel-Datei:
using IronXL;
// Create a new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");Imports IronXL
' Create a new Excel workbook
Dim workbook = WorkBook.Create()
Console.WriteLine("IronXL installed successfully!")Das Verständnis dieser Methoden hilft Ihnen, den effizientesten Ansatz für Ihr Datenszenario zu wählen. Wenn es ohne Fehler ausgeführt wird, ist IronXL bereit für die Verwendung. Die Bibliothek unterstützt alle modernen .NET-Versionen und stellt die Kompatibilität mit Ihren bestehenden Projekten sicher. Für detaillierte Installationsanweisungen und Fehlerbehebung konsultieren Sie die offizielle Dokumentation. Bereit zum Start? Sie können sie auch mit einem benutzerdefinierten Trennzeichen speichern.
Die Erstellung von Excel-Dateien mit IronXL beginnt mit der WorkBook-Klasse, Ihrem Zugang zu allen Excel-Operationen. Die Bibliothek unterstützt sowohl moderne XLSX- als auch Legacy-XLS-Formate und bietet Ihnen Flexibilität für unterschiedliche Anforderungen, wenn Sie Excel-Dateien in C# generieren.
using IronXL;
// Create a new workbook (XLSX format by default)
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Title = "Monthly Sales Report";
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Comments = "Generated using IronXL";
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("January Sales");
// Add some basic data
worksheet["A1"].Value = "Date";
worksheet["B1"].Value = "Product";
worksheet["C1"].Value = "Quantity";
worksheet["D1"].Value = "Revenue";
// Add data rows
worksheet["A2"].Value = new DateTime(2024, 1, 15);
worksheet["B2"].Value = "Widget Pro";
worksheet["C2"].Value = 100;
worksheet["D2"].Value = 2500.00;
// Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx");Imports IronXL
' Create a new workbook (XLSX format by default)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add metadata
workbook.Metadata.Title = "Monthly Sales Report"
workbook.Metadata.Author = "Sales Department"
workbook.Metadata.Comments = "Generated using IronXL"
' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("January Sales")
' Add some basic data
worksheet("A1").Value = "Date"
worksheet("B1").Value = "Product"
worksheet("C1").Value = "Quantity"
worksheet("D1").Value = "Revenue"
' Add data rows
worksheet("A2").Value = New DateTime(2024, 1, 15)
worksheet("B2").Value = "Widget Pro"
worksheet("C2").Value = 100
worksheet("D2").Value = 2500.0
' Save the workbook
workbook.SaveAs("FirstExcelFile.xlsx")Dieser Code demonstriert mehrere Schlüsselkonzepte für die Generierung von Excel-Dateien. Die WorkBook.Create()-Methode initialisiert eine neue Excel-Datei im Speicher. Sie spezifizieren das Format mit dem ExcelFileFormat-Enum - wählen Sie XLSX für moderne Excel-Kompatibilität oder XLS für Legacy-Unterstützung. Die Metadata-Eigenschaft ermöglicht es Ihnen, Dokumentinformationen einzubetten, die in den Dateieigenschaften von Excel erscheinen, gemäß Microsofts Dokumenteigenschaftsstandards.
Die CreateWorkSheet()-Methode fügt ein neues Blatt mit dem angegebenen Namen hinzu. Notation von Excel-Zellen (A1, B1, etc.) macht das Setzen von Werten intuitiv. IronXL verarbeitet die Datentypumwandlung automatisch und erkennt Daten, Zahlen und Text ohne explizite Typumwandlung. Die SaveAs()-Methode schreibt die vollständige Excel-Datei auf die Festplatte. Weitere Arbeitsblattoperationen finden Sie im Tutorial zur Arbeitsblattverwaltung.
IronXL bietet mehrere Ansätze für das Befüllen von Excel-Zellen, von der individuellen Zellzuweisung bis zu Massenbereichsoperationen. Die Speicherverwaltung wird bei großen Dateien kritisch.
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Individual cell assignment
worksheet["A1"].Value = "Employee Name";
worksheet["A2"].Value = "John Smith";
worksheet["A3"].Value = "Jane Doe";
// Range assignment for multiple cells
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales"); // C2
worksheet.SetCellValue(2, 2, "Marketing"); // C3
// Array-based population
string[] headers = { "ID", "Name", "Email", "Phone" };
for (int i = 0; i < headers.Length; i++)
{
worksheet.SetCellValue(0, i, headers[i]);
}
// Working with different data types
worksheet["E1"].Value = "Salary";
worksheet["E2"].Value = 75000.50m; // Decimal for currency
worksheet["E3"].Value = 82000.75m;
worksheet["F1"].Value = "Start Date";
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G1"].Value = "Full Time";
worksheet["G2"].Value = true; // Boolean
worksheet["G3"].Value = true;
workbook.SaveAs("FirstExcelFile.xlsx");Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Individual cell assignment
worksheet("A1").Value = "Employee Name"
worksheet("A2").Value = "John Smith"
worksheet("A3").Value = "Jane Doe"
' Range assignment for multiple cells
worksheet("B1:B3").Value = "Active"
' Using numeric indices (0-based)
worksheet.SetCellValue(0, 2, "Department") ' C1
worksheet.SetCellValue(1, 2, "Sales") ' C2
worksheet.SetCellValue(2, 2, "Marketing") ' C3
' Array-based population
Dim headers As String() = {"ID", "Name", "Email", "Phone"}
For i As Integer = 0 To headers.Length - 1
worksheet.SetCellValue(0, i, headers(i))
Next
' Working with different data types
worksheet("E1").Value = "Salary"
worksheet("E2").Value = 75000.5D ' Decimal for currency
worksheet("E3").Value = 82000.75D
worksheet("F1").Value = "Start Date"
worksheet("F2").Value = New DateTime(2020, 3, 15)
worksheet("F3").Value = New DateTime(2019, 7, 1)
worksheet("G1").Value = "Full Time"
worksheet("G2").Value = True ' Boolean
worksheet("G3").Value = True
workbook.SaveAs("FirstExcelFile.xlsx")Der Code zeigt IronXL's flexible Zelladressierung. String-Notation ("A1") fühlt sich für Excel-Anwender natürlich an, während numerische Indizes programmatische Kontrolle für Schleifen und dynamische Generierung bieten. Bereichszuweisungen ("B1:B3") setzen effizient mehrere Zellen auf denselben Wert, ideal für die Initialisierung von Spalten oder die Anwendung von Standardwerten.
IronXL verarbeitet intelligent verschiedene Datentypen. Dezimalzahlen behalten die Genauigkeit für Finanzdaten, DateTime-Objekte werden korrekt als Excel-Daten formatiert und Booleans erscheinen als TRUE/FALSE. Diese automatische Umwandlung eliminiert manuellen Formatierungscode, während die Datenintegrität gewährleistet bleibt.
Für größere Datensätze sollten Sie dieses Muster beachten:
// Populate from a data source
var employees = GetEmployeeData(); // Your data source
for (int row = 0; row < employees.Count; row++)
{
worksheet[$"A{row + 2}"].Value = employees[row].Id;
worksheet[$"B{row + 2}"].Value = employees[row].Name;
worksheet[$"C{row + 2}"].Value = employees[row].Department;
worksheet[$"D{row + 2}"].Value = employees[row].Salary;
}' Populate from a data source
Dim employees = GetEmployeeData() ' Your data source
For row As Integer = 0 To employees.Count - 1
worksheet($"A{row + 2}").Value = employees(row).Id
worksheet($"B{row + 2}").Value = employees(row).Name
worksheet($"C{row + 2}").Value = employees(row).Department
worksheet($"D{row + 2}").Value = employees(row).Salary
NextDieser Ansatz iteriert durch Ihre Datensammlung und ordnet jede Eigenschaft ihrer entsprechenden Spalte zu. Die String-Interpolation ($"A{row + 2}") generiert dynamisch Zelladressen, beginnend bei Zeile 2, um Überschriften zu erhalten.
Professionelle Excel-Dateien erfordern mehr als rohe Daten. IronXL's Styling-API verwandelt einfache Tabellenkalkulationen in polierte Geschäftsdokumente durch Formatierung, Farben und visuelle Hierarchie, wenn Sie Excel-Dateien in C# generieren.
using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Header formatting
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
// Column width adjustment
worksheet.AutoSizeColumn(0); // Auto-fit column A
worksheet.GetColumn(1).Width = 20; // Set column B to 20 characters
// Number formatting
var salaryColumn = worksheet["E2:E3"];
salaryColumn.FormatString = "$#,##0.00";
// Date formatting
var dateColumn = worksheet["F2:F3"];
dateColumn.FormatString = "MM/dd/yyyy";
// Cell borders
var dataRange = worksheet["A1:G3"];
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin;
// To set border color, use:
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
dataRange.Style.LeftBorder.Color = "#000000";
dataRange.Style.RightBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability
for (int row = 2; row <= 3; row++)
{
if (row % 2 == 0)
{
worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
}
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Header formatting
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.Font.Height = 12
headerRange.Style.SetBackgroundColor("#4472C4")
headerRange.Style.Font.Color = "#FFFFFF"
' Column width adjustment
worksheet.AutoSizeColumn(0) ' Auto-fit column A
worksheet.GetColumn(1).Width = 20 ' Set column B to 20 characters
' Number formatting
Dim salaryColumn = worksheet("E2:E3")
salaryColumn.FormatString = "$#,##0.00"
' Date formatting
Dim dateColumn = worksheet("F2:F3")
dateColumn.FormatString = "MM/dd/yyyy"
' Cell borders
Dim dataRange = worksheet("A1:G3")
dataRange.Style.TopBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.BottomBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.LeftBorder.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.RightBorder.Type = IronXL.Styles.BorderType.Thin
' To set border color, use:
dataRange.Style.TopBorder.Color = "#000000"
dataRange.Style.BottomBorder.Color = "#000000"
dataRange.Style.LeftBorder.Color = "#000000"
dataRange.Style.RightBorder.Color = "#000000"
' Text alignment
worksheet("A1:G1").Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
' Alternating row colors for readability
For row As Integer = 2 To 3
If row Mod 2 = 0 Then
worksheet($"A{row}:G{row}").Style.SetBackgroundColor("#F2F2F2")
End If
Next rowDieser Formatierungscode erstellt ein professionelles Erscheinungsbild, das Unternehmensstandards erfüllt. Fettgedruckte Überschriften mit Hintergrundfarben schaffen eine visuelle Hierarchie. Die SetBackgroundColor()-Methode akzeptiert Hex-Farbcodes und gibt Ihnen präzise Kontrolle über Ihr Farbschema. Schrifteigenschaften umfassen Größe, Farbe, fett, kursiv und Unterstreichungsoptionen, dies sind alle wesentlichen Elemente für die Erstellung von Excel-Dateien, die den Designrichtlinien des Unternehmens entsprechen.
Spaltenbreitenanpassungen verhindern Textverkürzungen. AutoSizeColumn() passt den Inhalt automatisch an, während SetColumnWidth() exakte Kontrolle bietet. Zahlenformatierung verwendet Excels Format-Codes. Zum Beispiel zeigt "$#,##0.00" Währung mit Tausendertrennzeichen und zwei Dezimalstellen an. Datumformatierung folgt ähnlichen Mustern, indem standardmäßige Excel-Datumformatzeichenfolgen verwendet werden, wie in Microsofts Excel-Spezifikationen dokumentiert.
Rahmen definieren Datenrahmen und verbessern die Lesbarkeit. Das BorderType-Enum bietet verschiedene Stile: dünn, mittel, dick, punktiert und gestrichelt. Ausrichtungsoptionen zentrieren Überschriften und richten Zahlen aus, entsprechend den Konventionen für Tabellenkalkulationen. Wechselnde Zeilenfarben, oft als "Bänderréihen" bezeichnet, helfen Lesern, Informationen über weite Datensätze hinweg zu verfolgen. Erfahren Sie mehr über fortgeschrittene Formatierungen, um formatierte Excel-Daten in unserem Cell-Styling-Guide zu erstellen.
Excel-Formeln beleben Tabellenkalkulationen mit automatischen Berechnungen. IronXL unterstützt die Erstellung und Auswertung von Formeln und ermöglicht dynamische Tabellenkalkulationen, die sich automatisch aktualisieren.
var workbook = WorkBook.Create();
// Create a budget worksheet
WorkSheet budget = workbook.CreateWorkSheet("Q1 Budget");
// Headers
budget["A1"].Value = "Category";
budget["B1"].Value = "January";
budget["C1"].Value = "February";
budget["D1"].Value = "March";
budget["E1"].Value = "Q1 Total";
// Budget categories and values
string[] categories = { "Salaries", "Marketing", "Operations", "Equipment", "Training" };
decimal[,] monthlyBudgets = {
{ 50000, 52000, 51000 },
{ 15000, 18000, 20000 },
{ 8000, 8500, 9000 },
{ 12000, 5000, 7000 },
{ 3000, 3500, 4000 }
};
// Populate data
for (int i = 0; i < categories.Length; i++)
{
budget[$"A{i + 2}"].Value = categories[i];
budget[$"B{i + 2}"].Value = monthlyBudgets[i, 0];
budget[$"C{i + 2}"].Value = monthlyBudgets[i, 1];
budget[$"D{i + 2}"].Value = monthlyBudgets[i, 2];
// Row total formula
budget[$"E{i + 2}"].Formula = $"=SUM(B{i + 2}:D{i + 2})";
}
// Monthly totals row
budget["A7"].Value = "Monthly Total";
budget["B7"].Formula = "=SUM(B2:B6)";
budget["C7"].Formula = "=SUM(C2:C6)";
budget["D7"].Formula = "=SUM(D2:D6)";
budget["E7"].Formula = "=SUM(E2:E6)";
// Calculate percentages
budget["A9"].Value = "Marketing %";
budget["B9"].Formula = "=B3/B7*100";
budget["C9"].Formula = "=C3/C7*100";
budget["D9"].Formula = "=D3/D7*100";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");Imports System
Dim workbook = WorkBook.Create()
' Create a budget worksheet
Dim budget As WorkSheet = workbook.CreateWorkSheet("Q1 Budget")
' Headers
budget("A1").Value = "Category"
budget("B1").Value = "January"
budget("C1").Value = "February"
budget("D1").Value = "March"
budget("E1").Value = "Q1 Total"
' Budget categories and values
Dim categories As String() = {"Salaries", "Marketing", "Operations", "Equipment", "Training"}
Dim monthlyBudgets As Decimal(,) = {
{50000, 52000, 51000},
{15000, 18000, 20000},
{8000, 8500, 9000},
{12000, 5000, 7000},
{3000, 3500, 4000}
}
' Populate data
For i As Integer = 0 To categories.Length - 1
budget($"A{i + 2}").Value = categories(i)
budget($"B{i + 2}").Value = monthlyBudgets(i, 0)
budget($"C{i + 2}").Value = monthlyBudgets(i, 1)
budget($"D{i + 2}").Value = monthlyBudgets(i, 2)
' Row total formula
budget($"E{i + 2}").Formula = $"=SUM(B{i + 2}:D{i + 2})"
Next
' Monthly totals row
budget("A7").Value = "Monthly Total"
budget("B7").Formula = "=SUM(B2:B6)"
budget("C7").Formula = "=SUM(C2:C6)"
budget("D7").Formula = "=SUM(D2:D6)"
budget("E7").Formula = "=SUM(E2:E6)"
' Calculate percentages
budget("A9").Value = "Marketing %"
budget("B9").Formula = "=B3/B7*100"
budget("C9").Formula = "=C3/C7*100"
budget("D9").Formula = "=D3/D7*100"
' Average calculation
budget("A10").Value = "Average Spending"
budget("B10").Formula = "=AVERAGE(B2:B6)"
' Evaluate all formulas
workbook.EvaluateAll()
workbook.SaveAs("Budget.xlsx")Dieses Budget-Beispiel zeigt die praktische Anwendung von Formeln. Die Formula-Eigenschaft akzeptiert die Standard-Excel-Formelsyntax, beginnend mit einem Gleichheitszeichen. IronXL unterstützt gängige Funktionen: SUMME, MITTELWERT, ZAEHLEN, MAX, MIN und viele andere. Zellverweise in Formeln funktionieren genauso wie in Excel, einschließlich relativer und absoluter Verweise.
Die Zeilensummelformeln (=SUM(B{i + 2}:D{i + 2})) berechnen vierteljährliche Summen für jede Kategorie. String-Interpolation generiert dynamisch die korrekten Zellreferenzen für jede Zeile. Monatliche Gesamtsummen summieren ganze Spalten, während Prozentberechnungen bestimmte Zellen durch Gesamtsummen teilen.
Die EvaluateAll()-Methode verarbeitet alle Formeln und aktualisiert die berechneten Werte im gesamten Arbeitsbuch. Dies stellt sicher, dass Formeln Ergebnisse anzeigen, wenn sie in Excel geöffnet werden. Ohne Auswertung würde Excel die Formeln zeigen, bis der Benutzer eine Neuberechnung auslöst.
Echtweltanwendungen exportieren häufig Datenbanken-Daten zu Excel für Berichterstattungs- und Analysezwecke. IronXL vereinfacht diesen Prozess mit eingebauter DataTable-Unterstützung, wodurch das manuelle Zuordnen von Feldern beim Generieren von Excel-Dateien aus C#-Anwendungen überflüssig wird.
using System;
using System.Data;
using System.Data.SqlClient;
// Simulate database retrieval (replace with your actual database code)
DataTable GetSalesData()
{
DataTable dt = new DataTable("Sales");
dt.Columns.Add("OrderID", typeof(int));
dt.Columns.Add("CustomerName", typeof(string));
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Quantity", typeof(int));
dt.Columns.Add("UnitPrice", typeof(decimal));
dt.Columns.Add("OrderDate", typeof(DateTime));
// Sample data (normally from database)
dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99m, DateTime.Now.AddDays(-5));
dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99m, DateTime.Now.AddDays(-4));
dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99m, DateTime.Now.AddDays(-3));
dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99m, DateTime.Now.AddDays(-2));
dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99m, DateTime.Now.AddDays(-1));
return dt;
}
// Export to Excel
WorkBook reportWorkbook = WorkBook.Create();
WorkSheet reportSheet = reportWorkbook.CreateWorkSheet("Sales Report");
// Get data from database
DataTable salesData = GetSalesData();
// Method 1: Manual mapping with formatting
reportSheet["A1"].Value = "Order Report - " + DateTime.Now.ToString("MMMM yyyy");
reportSheet.Merge("A1:F1");
reportSheet["A1"].Style.Font.Bold = true;
reportSheet["A1"].Style.Font.Height = 14;
// Headers
int headerRow = 3;
for (int col = 0; col < salesData.Columns.Count; col++)
{
reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns[col].ColumnName);
}
// Format headers
var headers = reportSheet[$"A{headerRow}:F{headerRow}"];
headers.Style.Font.Bold = true;
headers.Style.SetBackgroundColor("#D9E1F2");
// Data rows
for (int row = 0; row < salesData.Rows.Count; row++)
{
for (int col = 0; col < salesData.Columns.Count; col++)
{
reportSheet.SetCellValue(row + headerRow, col, salesData.Rows[row][col]);
}
// Add total column with formula
reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}
// Add total header and format
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency columns
reportSheet[$"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
reportSheet[$"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}"].FormatString = "$#,##0.00";
// Format date column
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";
// Add summary section
int summaryRow = headerRow + salesData.Rows.Count + 2;
reportSheet[$"A{summaryRow}"].Value = "Summary";
reportSheet[$"A{summaryRow}"].Style.Font.Bold = true;
reportSheet[$"A{summaryRow + 1}"].Value = "Total Orders:";
reportSheet[$"B{summaryRow + 1}"].Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})";
reportSheet[$"A{summaryRow + 2}"].Value = "Total Revenue:";
reportSheet[$"B{summaryRow + 2}"].Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})";
reportSheet[$"B{summaryRow + 2}"].FormatString = "$#,##0.00";
// Auto-fit columns
for (int col = 0; col <= 6; col++)
{
reportSheet.AutoSizeColumn(col);
}
// Evaluate formulas and save
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");Imports System
Imports System.Data
Imports System.Data.SqlClient
' Simulate database retrieval (replace with your actual database code)
Function GetSalesData() As DataTable
Dim dt As New DataTable("Sales")
dt.Columns.Add("OrderID", GetType(Integer))
dt.Columns.Add("CustomerName", GetType(String))
dt.Columns.Add("Product", GetType(String))
dt.Columns.Add("Quantity", GetType(Integer))
dt.Columns.Add("UnitPrice", GetType(Decimal))
dt.Columns.Add("OrderDate", GetType(DateTime))
' Sample data (normally from database)
dt.Rows.Add(1001, "ABC Corp", "Widget Pro", 50, 25.99D, DateTime.Now.AddDays(-5))
dt.Rows.Add(1002, "XYZ Ltd", "Widget Basic", 100, 15.99D, DateTime.Now.AddDays(-4))
dt.Rows.Add(1003, "ABC Corp", "Widget Premium", 25, 45.99D, DateTime.Now.AddDays(-3))
dt.Rows.Add(1004, "Tech Solutions", "Widget Pro", 75, 25.99D, DateTime.Now.AddDays(-2))
dt.Rows.Add(1005, "XYZ Ltd", "Widget Premium", 30, 45.99D, DateTime.Now.AddDays(-1))
Return dt
End Function
' Export to Excel
Dim reportWorkbook As WorkBook = WorkBook.Create()
Dim reportSheet As WorkSheet = reportWorkbook.CreateWorkSheet("Sales Report")
' Get data from database
Dim salesData As DataTable = GetSalesData()
' Method 1: Manual mapping with formatting
reportSheet("A1").Value = "Order Report - " & DateTime.Now.ToString("MMMM yyyy")
reportSheet.Merge("A1:F1")
reportSheet("A1").Style.Font.Bold = True
reportSheet("A1").Style.Font.Height = 14
' Headers
Dim headerRow As Integer = 3
For col As Integer = 0 To salesData.Columns.Count - 1
reportSheet.SetCellValue(headerRow - 1, col, salesData.Columns(col).ColumnName)
Next
' Format headers
Dim headers = reportSheet($"A{headerRow}:F{headerRow}")
headers.Style.Font.Bold = True
headers.Style.SetBackgroundColor("#D9E1F2")
' Data rows
For row As Integer = 0 To salesData.Rows.Count - 1
For col As Integer = 0 To salesData.Columns.Count - 1
reportSheet.SetCellValue(row + headerRow, col, salesData.Rows(row)(col))
Next
' Add total column with formula
reportSheet($"G{row + headerRow + 1}").Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}"
Next
' Add total header and format
reportSheet("G3").Value = "Total"
reportSheet("G3").Style.Font.Bold = True
reportSheet("G3").Style.SetBackgroundColor("#D9E1F2")
' Format currency columns
reportSheet($"E{headerRow + 1}:E{headerRow + salesData.Rows.Count}").FormatString = "$#,##0.00"
reportSheet($"G{headerRow + 1}:G{headerRow + salesData.Rows.Count}").FormatString = "$#,##0.00"
' Format date column
reportSheet($"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}").FormatString = "MM/dd/yyyy"
' Add summary section
Dim summaryRow As Integer = headerRow + salesData.Rows.Count + 2
reportSheet($"A{summaryRow}").Value = "Summary"
reportSheet($"A{summaryRow}").Style.Font.Bold = True
reportSheet($"A{summaryRow + 1}").Value = "Total Orders:"
reportSheet($"B{summaryRow + 1}").Formula = $"=COUNTA(A{headerRow + 1}:A{headerRow + salesData.Rows.Count})"
reportSheet($"A{summaryRow + 2}").Value = "Total Revenue:"
reportSheet($"B{summaryRow + 2}").Formula = $"=SUM(G{headerRow + 1}:G{headerRow + salesData.Rows.Count})"
reportSheet($"B{summaryRow + 2}").FormatString = "$#,##0.00"
' Auto-fit columns
For col As Integer = 0 To 6
reportSheet.AutoSizeColumn(col)
Next
' Evaluate formulas and save
reportWorkbook.EvaluateAll()
reportWorkbook.SaveAs("DatabaseExport.xlsx")Dieses umfassende Beispiel demonstriert einen vollständigen Datenbank-zu-Excel-Workflow zur Erstellung von Excel-Dateien in C#. Der DataTable simuliert die Datenbankabfrage - im Produktiveinsatz ersetzen Sie dies mit Ihren tatsächlichen Datenbankabfragen unter Verwendung von Entity Framework, Dapper oder ADO.NET. Der manuelle Abbildungsansatz gibt vollständige Kontrolle über Formatierung und Layout, wie von Microsofts Best Practices für Dateiexport empfohlen.
Der Code erstellt einen professionellen Bericht mit einem Titel, formatierten Überschriften und Datenzeilen. Formelspalten berechnen Zeilensummen dynamisch. Der Zusammenfassungsabschnitt nutzt Excel-Formeln, um Bestellungen zu zählen und Einnahmen zu summieren, sicherstellend, dass diese Werte aktualisiert werden, wenn sich die Daten ändern. Währungs- und Datenformatierung folgen Geschäftsdokumentstandards, während das automatische Anpassen der Spaltengröße sicherstellt, dass alle Inhalte ordnungsgemäß angezeigt werden. Für den Umgang mit größeren Datensätzen konsultieren Sie unseren Leitfaden zur Leistungsoptimierung.
Müssen Sie Ihr Excel-Reporting rationalisieren? Erwerben Sie eine Lizenz, um das volle Potenzial von IronXL für den Produktionseinsatz zu erschließen.
Komplexe Excel-Dateien erfordern häufig mehrere Arbeitsblätter, um verwandte Daten zu organisieren. IronXL vereinfacht die Verwaltung von mehreren Blättern mit intuitiven Methoden zum Erstellen, Zugreifen und Organisieren von Arbeitsblättern.
// Create a multi-sheet workbook
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet hrSheet = companyReport.CreateWorkSheet("HR Metrics");
// Populate Sales sheet
salesSheet["A1"].Value = "Sales Dashboard";
salesSheet["A3"].Value = "Region";
salesSheet["B3"].Value = "Q1 Sales";
salesSheet["C3"].Value = "Q2 Sales";
string[] regions = { "North", "South", "East", "West" };
decimal[] q1Sales = { 250000, 180000, 220000, 195000 };
decimal[] q2Sales = { 275000, 195000, 240000, 210000 };
for (int i = 0; i < regions.Length; i++)
{
salesSheet[$"A{i + 4}"].Value = regions[i];
salesSheet[$"B{i + 4}"].Value = q1Sales[i];
salesSheet[$"C{i + 4}"].Value = q2Sales[i];
}
// Populate Inventory sheet
inventorySheet["A1"].Value = "Inventory Status";
inventorySheet["A3"].Value = "Product";
inventorySheet["B3"].Value = "Stock Level";
inventorySheet["C3"].Value = "Reorder Point";
inventorySheet["D3"].Value = "Status";
// Add inventory data with conditional status
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] stock = { 150, 45, 200 };
int[] reorderPoint = { 100, 50, 75 };
for (int i = 0; i < products.Length; i++)
{
inventorySheet[$"A{i + 4}"].Value = products[i];
inventorySheet[$"B{i + 4}"].Value = stock[i];
inventorySheet[$"C{i + 4}"].Value = reorderPoint[i];
// Status based on stock level
string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
inventorySheet[$"D{i + 4}"].Value = status;
// Color code status
if (status == "REORDER")
{
inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}
}
// Create summary sheet referencing other sheets
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Company Overview";
summarySheet["A3"].Value = "Metric";
summarySheet["B3"].Value = "Value";
summarySheet["A4"].Value = "Total Q1 Sales";
summarySheet["B4"].Formula = "=SUM(Sales!B4:B7)";
summarySheet["A5"].Value = "Total Q2 Sales";
summarySheet["B5"].Formula = "=SUM(Sales!C4:C7)";
summarySheet["A6"].Value = "Products Need Reorder";
summarySheet["B6"].Formula = "=COUNTIF(Inventory!D4:D6,\"REORDER\")";
// Format all sheets consistently
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
// Format headers
sheet["A1"].Style.Font.Bold = true;
sheet["A1"].Style.Font.Height = 14;
var headerRow = sheet["A3:D3"];
headerRow.Style.Font.Bold = true;
headerRow.Style.SetBackgroundColor("#E7E6E6");
}
// Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx");Imports System
' Create a multi-sheet workbook
Dim companyReport As WorkBook = WorkBook.Create()
' Create department sheets
Dim salesSheet As WorkSheet = companyReport.CreateWorkSheet("Sales")
Dim inventorySheet As WorkSheet = companyReport.CreateWorkSheet("Inventory")
Dim hrSheet As WorkSheet = companyReport.CreateWorkSheet("HR Metrics")
' Populate Sales sheet
salesSheet("A1").Value = "Sales Dashboard"
salesSheet("A3").Value = "Region"
salesSheet("B3").Value = "Q1 Sales"
salesSheet("C3").Value = "Q2 Sales"
Dim regions As String() = {"North", "South", "East", "West"}
Dim q1Sales As Decimal() = {250000D, 180000D, 220000D, 195000D}
Dim q2Sales As Decimal() = {275000D, 195000D, 240000D, 210000D}
For i As Integer = 0 To regions.Length - 1
salesSheet($"A{i + 4}").Value = regions(i)
salesSheet($"B{i + 4}").Value = q1Sales(i)
salesSheet($"C{i + 4}").Value = q2Sales(i)
Next
' Populate Inventory sheet
inventorySheet("A1").Value = "Inventory Status"
inventorySheet("A3").Value = "Product"
inventorySheet("B3").Value = "Stock Level"
inventorySheet("C3").Value = "Reorder Point"
inventorySheet("D3").Value = "Status"
' Add inventory data with conditional status
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim stock As Integer() = {150, 45, 200}
Dim reorderPoint As Integer() = {100, 50, 75}
For i As Integer = 0 To products.Length - 1
inventorySheet($"A{i + 4}").Value = products(i)
inventorySheet($"B{i + 4}").Value = stock(i)
inventorySheet($"C{i + 4}").Value = reorderPoint(i)
' Status based on stock level
Dim status As String = If(stock(i) <= reorderPoint(i), "REORDER", "OK")
inventorySheet($"D{i + 4}").Value = status
' Color code status
If status = "REORDER" Then
inventorySheet($"D{i + 4}").Style.Font.Color = "#FF0000"
End If
Next
' Create summary sheet referencing other sheets
Dim summarySheet As WorkSheet = companyReport.CreateWorkSheet("Summary")
summarySheet("A1").Value = "Company Overview"
summarySheet("A3").Value = "Metric"
summarySheet("B3").Value = "Value"
summarySheet("A4").Value = "Total Q1 Sales"
summarySheet("B4").Formula = "=SUM(Sales!B4:B7)"
summarySheet("A5").Value = "Total Q2 Sales"
summarySheet("B5").Formula = "=SUM(Sales!C4:C7)"
summarySheet("A6").Value = "Products Need Reorder"
summarySheet("B6").Formula = "=COUNTIF(Inventory!D4:D6,""REORDER"")"
' Format all sheets consistently
For Each sheet As WorkSheet In companyReport.WorkSheets
' Format headers
sheet("A1").Style.Font.Bold = True
sheet("A1").Style.Font.Height = 14
Dim headerRow = sheet("A3:D3")
headerRow.Style.Font.Bold = True
headerRow.Style.SetBackgroundColor("#E7E6E6")
Next
' Save multi-sheet workbook
companyReport.SaveAs("CompanyReport.xlsx")Dieses Beispiel erstellt einen vollständigen Multiblatt-Bericht. Jedes Arbeitsblatt dient einem bestimmten Zweck: Verkaufsdaten, Bestandsverfolgung und HR-Kennzahlen. Das Zusammenfassungsblatt konsolidiert wichtige Kennzahlen mithilfe von übergreifenden Formeln. Beachten Sie die Blattreferenzsyntax in Formeln: "Sales!B4:B7" bezieht sich auf die Zellen B4 bis B7 auf dem Blatt Sales.
Das Bestandsblatt zeigt bedingte Logik, die Artikel mit niedrigem Bestand rot färbt, um sofortige Aufmerksamkeit zu erregen. Die foreach-Schleife wendet konsistente Formatierung auf alle Blätter an und erhält eine professionelle Erscheinung im gesamten Arbeitsbuch. Blattnamen erscheinen als Registerkarten in Excel und ermöglichen es den Benutzern, einfach zwischen verschiedenen Datenansichten zu navigieren.
Die effiziente Generierung von Excel-Dateien in C# erfordert durchdachte Ansätze für die Speichernutzung, Fehlerbehandlung und Bereitstellung. Diese Praktiken sorgen dafür, dass Ihre Anwendungen effektiv skalieren und gleichzeitig Zuverlässigkeit beim programmgesteuerten Erstellen von Excel-Tabellenkalkulationen beibehalten.
Ein benutzerdefiniertes Trennzeichen angeben: Vor dem Laden der CSV-Datei können Sie das Trennzeichen Ihrer Datei angeben. Laden Sie nicht gesamte Datensätze in den Speicher, sondern verarbeiten Sie Daten in Teilen:
// Process large datasets efficiently
public void ExportLargeDataset(string filename)
{
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 1;
// Process in batches
foreach (var batch in GetDataInBatches(rowsPerBatch))
{
foreach (var record in batch)
{
sheet[$"A{currentRow}"].Value = record.Id;
sheet[$"B{currentRow}"].Value = record.Name;
sheet[$"C{currentRow}"].Value = record.Value;
currentRow++;
}
}
workbook.SaveAs(filename);
}' Process large datasets efficiently
Public Sub ExportLargeDataset(filename As String)
Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
Dim rowsPerBatch As Integer = 1000
Dim currentRow As Integer = 1
' Process in batches
For Each batch In GetDataInBatches(rowsPerBatch)
For Each record In batch
sheet($"A{currentRow}").Value = record.Id
sheet($"B{currentRow}").Value = record.Name
sheet($"C{currentRow}").Value = record.Value
currentRow += 1
Next
Next
workbook.SaveAs(filename)
End SubFehlerbehandlung verhindert Anwendungsabstürze und liefert aussagekräftige Rückmeldungen bei der Generierung von Excel-Dateien:
try
{
WorkBook workbook = WorkBook.Create();
// Excel generation code
workbook.SaveAs("output.xlsx");
}
catch (Exception ex)
{
// Log the error
Console.WriteLine($"Excel generation failed: {ex.Message}");
// Implement appropriate recovery or notification
}Imports System
Try
Dim workbook As WorkBook = WorkBook.Create()
' Excel generation code
workbook.SaveAs("output.xlsx")
Catch ex As Exception
' Log the error
Console.WriteLine($"Excel generation failed: {ex.Message}")
' Implement appropriate recovery or notification
End TryFür Webanwendungen, generieren Sie Excel-Dateien im Speicher und streamen Sie sie an die Benutzer:
// ASP.NET Core example
public IActionResult DownloadExcel()
{
WorkBook workbook = GenerateReport();
var stream = new MemoryStream();
workbook.SaveAs(stream);
stream.Position = 0;
return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx");
}Imports System.IO
Imports Microsoft.AspNetCore.Mvc
Public Function DownloadExcel() As IActionResult
Dim workbook As WorkBook = GenerateReport()
Dim stream As New MemoryStream()
workbook.SaveAs(stream)
stream.Position = 0
Return File(stream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "report.xlsx")
End FunctionBereitstellungsüberlegungen sorgen für einen reibungslosen Produktionsbetrieb. IronXL funktioniert in eingeschränkten Umgebungen ohne erhöhte Berechtigungen, was es für geteiltes Hosting und containerisierte Bereitstellungen geeignet macht. Integrieren Sie die IronXL-Lizenzdatei in Ihr Bereitstellungspaket und stellen Sie sicher, dass Ihre Anwendung Schreibberechtigungen für temporäre Dateioperationen hat, falls erforderlich. Für zusätzliche Bereitstellungsanleitungen konsultieren Sie die Bereitstellungsdokumentation.
IronXL verwandelt die Excel-Dateigenerierung in C# von einer komplexen Herausforderung in einfaches Kodieren. Sie haben gelernt, wie Sie Arbeitsbücher erstellen, Zellen befüllen, Formatierungen anwenden, Formeln verwenden und Datenbanken-Daten exportieren - alles ohne Abhängigkeiten von Microsoft Office. Diese Techniken zur programmgesteuerten Erzeugung von Excel-Dateien funktionieren konsistent über Windows, Linux und Cloud-Plattformen hinweg.
Bereit zur Implementierung von Excel-Generierung in Ihren C#-Anwendungen? Starten Sie Ihre kostenlose Testversion oder erkunden Sie die umfassende API-Dokumentation für erweiterte Funktionen. Für Produktiveinsätze betrachten Sie die Lizenzoptionen, die zu Ihren Projektanforderungen passen.
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.
