Wie man mit IronXL in C# Excel-Dateien generiert

Warum sollte man Excel-Dateien ohne Microsoft Office erstellen?

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 Einschränkungen durch seinen unabhängigen Betrieb. Ihre C#-Excel-Dateigenerierung läuft unter Windows, Linux, macOS, Docker-Containern oder Azure App Services ohne Änderungen. Diese plattformübergreifende Kompatibilität bedeutet, dass Sie einmal schreiben und überall einsetzen können, egal ob Sie .NET Framework, .NET Core oder .NET 10-Anwendungen als Zielplattformen verwenden.

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 Arbeitsspeicher innerhalb des Prozessraums Ihrer Anwendung, was zu einer schnelleren Ausführung und einem geringeren Ressourcenverbrauch bei der programmatischen Generierung von Excel-Dateien führt.

Die Bereitstellung wird einfach, da IronXL als einzelnes NuGet-Paket geliefert wird. Keine Registry-Einträge, keine COM-Registrierung und keine Office-Service-Packs, die gewartet werden müssen. Ihre Continuous-Integration-Pipelines funktionieren reibungslos, und die Docker-Container bleiben ressourcenschonend. 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 nutzen nach wie vor Microsofts Open XML Productivity Tool, um direkt mit Office Open XML-Dateistrukturen zu arbeiten. Diese Herangehensweise erfordert jedoch mehr manuelles Eingreifen und detailliertes Wissen über das XML-Schema und die Installation des Open XML SDK. IronXL abstrahiert diese Komplexität und bietet Ihnen einen viel schnelleren Weg, mit Excel programmatisch zu arbeiten.

Wie installiert man IronXL in einem C#-Projekt?

Die Installation von IronXL über den NuGet -Paketmanager in Visual Studio dauert nur wenige Augenblicke. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt und wählen Sie " NuGet Pakete verwalten". Suchen Sie nach "IronXL" und klicken Sie auf "Installieren". Das Paket beinhaltet automatisch alle Abhängigkeiten, die für die Generierung von Excel-Dateien in C# erforderlich sind.

Zur Installation über die Paket-Manager-Konsole oder die .NET -Befehlszeilenschnittstelle verwenden Sie einen der folgenden Befehle:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Überprüfen Sie die Installation mit diesem einfachen Test, um sicherzustellen, dass die Bibliothek einsatzbereit ist:

using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

using IronXL;
// Create an in-memory workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

Wenn dieser Vorgang fehlerfrei abläuft, ist IronXL einsatzbereit. Die Bibliothek unterstützt alle modernen .NET-Versionen und stellt die Kompatibilität mit Ihren bestehenden Projekten sicher. Detaillierte Installationshinweise und Tipps zur Fehlerbehebung finden Sie in der offiziellen NuGet Installationsdokumentation .

Wie erstellt man seine erste Excel-Datei?

Die Erstellung von Excel-Dateien mit IronXL beginnt mit der WorkBook-Klasse, Ihrem Zugang zu allen Excel-Operationen. Die Bibliothek unterstützt sowohl das moderne XLSX- als auch das ältere XLS-Format und bietet Ihnen somit Flexibilität für unterschiedliche Anforderungen beim Erstellen einer Excel-Datei in C# .

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 header row
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");

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 header row
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");

Dieser Code demonstriert mehrere Schlüsselkonzepte für die Generierung von Excel-Dateien. Die Methode WorkBook.Create() initialisiert eine neue Excel-Datei im Speicher. Das Format geben Sie mithilfe des Enums ExcelFileFormat an – wählen Sie XLSX für die Kompatibilität mit modernen Excel-Tabellen oder XLS für die Unterstützung älterer Tabellen. Mit der Eigenschaft Metadata können Sie Dokumentinformationen einbetten, die in den Dateieigenschaften von Excel angezeigt werden, und zwar gemäß den Dokumenteigenschaftenstandards von Microsoft .

Die Methode CreateWorkSheet() fügt ein neues Tabellenblatt 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 Methode SaveAs() schreibt die gesamte Excel-Datei auf die Festplatte. Weitere Informationen zu Tabellenkalkulationsfunktionen finden Sie im Leitfaden zum Erstellen von Excel-Dateien .

Wie schreibt man Daten in Excel-Zellen?

IronXL bietet mehrere Ansätze für das Befüllen von Excel-Zellen, von der individuellen Zellzuweisung bis zu Massenbereichsoperationen. Das Verständnis dieser Methoden hilft Ihnen, beim Schreiben in eine Excel-Datei den effizientesten Ansatz für Ihr Datenszenario zu wählen.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header 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("EmployeeData.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 at once
worksheet["B1:B3"].Value = "Active";
// Using numeric indices (0-based row, 0-based column)
worksheet.SetCellValue(0, 2, "Department"); // C1
worksheet.SetCellValue(1, 2, "Sales");       // C2
worksheet.SetCellValue(2, 2, "Marketing");   // C3
// Array-based header 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("EmployeeData.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") weisen mehreren Zellen effizient denselben Wert zu und eignen sich ideal zum Initialisieren von Spalten oder zum Anwenden von Standardwerten.

IronXL verarbeitet verschiedene Datentypen intelligent. Dezimalzahlen behalten ihre Genauigkeit bei Finanzdaten, DateTime Objekte werden korrekt als Excel-Datumsangaben formatiert und boolesche Werte werden als WAHR/FALSCH angezeigt. Diese automatische Umwandlung eliminiert manuellen Formatierungscode, während die Datenintegrität gewährleistet bleibt. Bei großen Datensätzen sollten Sie im Leitfaden zum Datenimport nach weiteren Mustern suchen.

Wie wendet man professionelle Formatierung auf Excel-Dateien an?

Professionelle Excel-Dateien erfordern mehr als rohe Daten. Die Styling-API von IronXL verwandelt einfache Tabellenkalkulationen durch Formatierung, Farben und visuelle Hierarchie in professionelle Geschäftsdokumente. Sie können die Zellformatierung anwenden, um jeden visuellen Aspekt Ihrer Tabelle zu steuern.

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 width
// 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;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
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 width
// 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;
dataRange.Style.TopBorder.Color = "#000000";
dataRange.Style.BottomBorder.Color = "#000000";
// Text alignment
worksheet["A1:G1"].Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
// Alternating row colors for readability (banded rows)
for (int row = 2; row <= 10; row++)
{
    if (row % 2 == 0)
    {
        worksheet[$"A{row}:G{row}"].Style.SetBackgroundColor("#F2F2F2");
    }
}
workbook.SaveAs("FormattedReport.xlsx");

Dieser Formatierungscode sorgt für ein professionelles Erscheinungsbild, das den Geschäftsstandards entspricht. Fettgedruckte Überschriften mit Hintergrundfarben schaffen eine visuelle Hierarchie. Die Methode SetBackgroundColor() akzeptiert Hex-Farbcodes und ermöglicht so eine präzise Steuerung Ihres Farbschemas. Zu den Schrifteigenschaften gehören Größe, Farbe, Fettdruck, Kursivschrift und Unterstreichung – allesamt unerlässlich für die Erstellung von Excel-Dateien, die den Corporate-Branding-Richtlinien entsprechen.

Spaltenbreitenanpassungen verhindern Textverkürzungen. AutoSizeColumn() passt den Inhalt automatisch an, während GetColumn().Width eine exakte Steuerung ermöglicht. Die Zahlenformatierung verwendet die Formatcodes von Excel – beispielsweise zeigt "$#,##0.00" Währungsbeträge mit Tausendertrennzeichen und zwei Dezimalstellen an. Die Datumsformatierung folgt ähnlichen Mustern und verwendet Standard-Excel-Datumsformatzeichenfolgen, wie sie in der Referenz für Zahlenformatcodes von Microsoft dokumentiert sind.

Rahmen definieren Datenrahmen und verbessern die Lesbarkeit. Die Aufzählung BorderType bietet verschiedene Stile: dünn, mittel, dick, gepunktet und gestrichelt. Wechselnde Zeilenfarben, oft als "Bänderréihen" bezeichnet, helfen Lesern, Informationen über weite Datensätze hinweg zu verfolgen. Weitere Informationen zum Zusammenführen von Zellen und anderen Layoutfunktionen finden Sie im Leitfaden zum Zusammenführen von Zellen .

Wie verwendet man Excel-Formeln programmatisch?

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.

using IronXL;
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 and add row total formulas
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];
    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";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

using IronXL;
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 and add row total formulas
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];
    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";
// Average calculation
budget["A10"].Value = "Average Spending";
budget["B10"].Formula = "=AVERAGE(B2:B6)";
// Evaluate all formulas before saving
workbook.EvaluateAll();
workbook.SaveAs("Budget.xlsx");

Dieses Budget-Beispiel zeigt die praktische Anwendung von Formeln. Die Eigenschaft Formula 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 Methode EvaluateAll() verarbeitet alle Formeln und aktualisiert die berechneten Werte in der gesamten Arbeitsmappe. Dadurch wird sichergestellt, dass die Formeln Ergebnisse anzeigen, wenn die Datei in Excel geöffnet wird. Ohne Auswertung würde Excel den Formeltext so lange anzeigen, bis der Benutzer eine Neuberechnung auslöst. Weitere Informationen zum Lesen von Formelergebnissen finden Sie in der Dokumentation zum Lesen von Excel-Dateien .

Wie exportiert man Datenbankdaten nach Excel?

Echtweltanwendungen exportieren häufig Datenbanken-Daten zu Excel für Berichterstattungs- und Analysezwecke. IronXL vereinfacht diesen Prozess durch die integrierte Unterstützung von DataTable, wodurch die manuelle Feldzuordnung beim Export von Excel-Tabellen aus C# -Anwendungen entfällt.

using System.Data;
using IronXL;

// Simulate database retrieval (replace with 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));
    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");
DataTable salesData = GetSalesData();

// Title row
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);
}
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]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date 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";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

// 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";

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

using System.Data;
using IronXL;

// Simulate database retrieval (replace with 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));
    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");
DataTable salesData = GetSalesData();

// Title row
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);
}
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]);
    }
    reportSheet[$"G{row + headerRow + 1}"].Formula = $"=D{row + headerRow + 1}*E{row + headerRow + 1}";
}

// Total header
reportSheet["G3"].Value = "Total";
reportSheet["G3"].Style.Font.Bold = true;
reportSheet["G3"].Style.SetBackgroundColor("#D9E1F2");
// Format currency and date 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";
reportSheet[$"F{headerRow + 1}:F{headerRow + salesData.Rows.Count}"].FormatString = "MM/dd/yyyy";

// 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";

for (int col = 0; col <= 6; col++) { reportSheet.AutoSizeColumn(col); }
reportWorkbook.EvaluateAll();
reportWorkbook.SaveAs("DatabaseExport.xlsx");

Dieses Beispiel veranschaulicht einen kompletten Workflow von der Datenbank zur Excel-Übertragung. Der Code DataTable simuliert einen Datenbankabruf. Ersetzen Sie diesen in der Produktion durch tatsächliche Datenbankabfragen mit 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. Im Abschnitt "Zusammenfassung" werden Excel-Formeln verwendet, um Bestellungen zu zählen und den Umsatz zu summieren. Dadurch wird sichergestellt, dass sich diese Werte aktualisieren, wenn sich die Daten ändern. Für die Arbeit mit DataSets und größeren Datenstrukturen konsultieren Sie bitte den Konvertierungsleitfaden von Excel zu DataSet .

Wie geht man mit mehreren Arbeitsblättern um?

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. Sie können Arbeitsmappenblätter mit nur wenigen Codezeilen öffnen und verwalten .

using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// 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";
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];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
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\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");

using IronXL;
WorkBook companyReport = WorkBook.Create();
// Create department sheets
WorkSheet salesSheet = companyReport.CreateWorkSheet("Sales");
WorkSheet inventorySheet = companyReport.CreateWorkSheet("Inventory");
WorkSheet summarySheet = companyReport.CreateWorkSheet("Summary");

// 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";
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];
    string status = stock[i] <= reorderPoint[i] ? "REORDER" : "OK";
    inventorySheet[$"D{i + 4}"].Value = status;
    if (status == "REORDER")
        inventorySheet[$"D{i + 4}"].Style.Font.Color = "#FF0000";
}

// Summary sheet with cross-sheet formulas
summarySheet["A1"].Value = "Company Overview";
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\")";

// Apply consistent formatting across all sheets
foreach (WorkSheet sheet in companyReport.WorkSheets)
{
    sheet["A1"].Style.Font.Bold = true;
    sheet["A1"].Style.Font.Height = 14;
}
companyReport.SaveAs("CompanyReport.xlsx");

Dieses Beispiel erstellt einen vollständigen Multiblatt-Bericht. Jedes Arbeitsblatt hat einen bestimmten Zweck: Verkaufsdaten, Bestandsverfolgung und eine zusammenfassende Übersicht. Das Zusammenfassungsblatt konsolidiert wichtige Kennzahlen mithilfe von übergreifenden Formeln. Beachten Sie die Syntax für Blattverweise – "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 sorgt für eine einheitliche Formatierung aller Tabellenblätter und gewährleistet so ein professionelles Erscheinungsbild der gesamten Arbeitsmappe. In Excel werden Tabellenblattnamen als Registerkarten angezeigt, sodass Benutzer einfach zwischen verschiedenen Datenansichten navigieren können.

Was sind die Best Practices für die Generierung von Excel-Dateien in C#?

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. Daten in Batches verarbeiten, anstatt ganze Datensätze auf einmal zu laden. Das folgende Muster sorgt für eine vorhersehbare Speichernutzung bei großen Exportmengen:

using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable 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("LargeDataset.xlsx");

using IronXL;
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
int rowsPerBatch = 1000;
int currentRow = 2;
sheet["A1"].Value = "ID";
sheet["B1"].Value = "Name";
sheet["C1"].Value = "Value";
// Process records in manageable 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("LargeDataset.xlsx");

Bei Webanwendungen werden Excel-Dateien im Arbeitsspeicher generiert und direkt an die Benutzer gestreamt, anstatt temporäre Dateien auf der Festplatte zu speichern. Um Abstürze zu vermeiden und aussagekräftiges Feedback zu erhalten, sollte die Generierungslogik stets in eine Fehlerbehandlung eingebettet werden:

// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}

// ASP.NET Core controller action with error handling
IActionResult DownloadExcel()
{
    try
    {
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Report");
        sheet["A1"].Value = "Report Data";
        // Populate report data here...
        var stream = new MemoryStream();
        workbook.SaveAs(stream);
        stream.Position = 0;
        return File(stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "report.xlsx");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Excel generation failed: {ex.Message}");
        return StatusCode(500, "Failed to generate Excel file.");
    }
}

Die folgende Tabelle fasst die wichtigsten Best Practices und deren Anwendungsbereiche zusammen:

IronXL funktioniert in eingeschränkten Umgebungen ohne erhöhte Berechtigungen, was es für geteiltes Hosting und containerisierte Bereitstellungen geeignet macht. Fügen Sie die IronXL -Lizenzdatei Ihrem Bereitstellungspaket hinzu und stellen Sie sicher, dass Ihre Anwendung über Schreibberechtigungen für alle erforderlichen temporären Dateioperationen verfügt. Weitere Hinweise zur Implementierung finden Sie in der IronXL -Funktionsübersicht und der vollständigen API-Dokumentation .

Wie geht es von hier aus weiter?

IronXL verwandelt die Excel-Dateigenerierung in C# von einer komplexen Herausforderung in einfaches Kodieren. Sie haben gelernt, Arbeitsmappen zu erstellen, Zellen zu füllen, Formatierungen anzuwenden, Formeln zu verwenden, Datenbankdaten zu exportieren und mehrere Arbeitsblätter zu verwalten – und das alles ohne Abhängigkeiten von Microsoft Office. Diese Techniken funktionieren konsistent auf Windows-, Linux- und Cloud-Plattformen, die auf .NET 10 abzielen.

Um tiefer in die Materie einzusteigen, können Sie die IronXL -Anleitungen zum Lesen und Bearbeiten bestehender Excel-Dateien oder die Seite für die Testlizenz besuchen, um mit der Produktion zu beginnen. Sehen Sie sich die Lizenzoptionen an, die Ihren Projektanforderungen und Ihrem Umfang entsprechen.