Wie man mit IronXL eine Excel-Datei in C# generiert

Warum Excel-Arbeitsblattdateien ohne Microsoft Office generieren?

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.

Wie installiert man IronXL in seinem C#-Projekt?

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:

Install-Package IronXL.Excel

Install-Package IronXL.Excel

Für .NET CLI-Benutzer, die mit modernen C#-Projekten arbeiten:

dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

Ü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!");

using IronXL;
// Create a new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");

IRON VB CONVERTER ERROR developers@ironsoftware.com

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.

Wie erstellt man seine erste Excel-Datei?

Die Erstellung von Excel-Dateien mit IronXL beginnt mit der WorkBook-Klasse, dem Tor 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");

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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 geben das Format mit dem ExcelFileFormat enum an - wählen Sie XLSX für moderne Excel-Kompatibilität oder XLS für Legacy-Unterstützung. Mit der Metadaten-Eigenschaft können Sie Dokumentinformationen einbetten, die in den Dateieigenschaften von Excel erscheinen und den Microsoft-Standards für Dokumenteigenschaften entsprechen.

Die Methode CreateWorkSheet() 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 Methode SaveAs() schreibt die komplette Excel-Datei auf die Festplatte. Weitere Arbeitsblattoperationen finden Sie im Tutorial zur Arbeitsblattverwaltung.

Wie schreibe ich Daten in Excel-Zellen?

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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.

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Wie wende ich professionelles Formatieren an?

Professionelle Excel-Dateien erfordern mehr als rohe Daten. Die Styling API von IronXL verwandelt einfache Tabellenkalkulationen durch Formatierung, Farben und visuelle Hierarchie in ausgefeilte Geschäftsdokumente, wenn Sie Excel-Dateien in C# erstellen.

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");
    }
}

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");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dieser Formatierungscode erstellt ein professionelles Erscheinungsbild, das Unternehmensstandards erfüllt. Fettgedruckte Überschriften mit Hintergrundfarben schaffen eine visuelle Hierarchie. Die SetBackgroundColor()-Methode akzeptiert Hex-Farbcodes und bietet 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() eine genaue Steuerung 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.

Wie verwendet man Excel-Formeln programmgesteuert?

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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 Zeilen-Gesamtformeln (=SUM(B{i + 2}:D{i + 2})) berechnen vierteljährliche Gesamtsummen 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 berechnete Werte im gesamten Workbook. 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.

Wie exportiert man Daten aus Datenbanken nach Excel?

Echtweltanwendungen exportieren häufig Datenbanken-Daten zu Excel für Berichterstattungs- und Analysezwecke. IronXL vereinfacht diesen Prozess durch die eingebaute DataTable-Unterstützung, die eine manuelle Feldzuordnung bei der Erstellung von Excel-Dateien aus C#-Anwendungen überflüssig macht.

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dieses umfassende Beispiel demonstriert einen vollständigen Datenbank-zu-Excel-Workflow zur Erstellung von Excel-Dateien in C#. Die DataTable simuliert den Abruf von Datenbanken - in der Produktion sollten Sie diese durch Ihre tatsächlichen Datenbankabfragen mit Entity Framework, Dapper oder ADO.NET ersetzen. 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.

Wie Handhabt man mehrere Arbeitsblätter?

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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 eine einheitliche Formatierung auf alle Blätter an und sorgt so für ein professionelles Erscheinungsbild der gesamten Arbeitsmappe. Blattnamen erscheinen als Registerkarten in Excel und ermöglichen es den Benutzern, einfach zwischen verschiedenen Datenansichten zu navigieren.

Was sind die besten Praktiken für die Excel-Generierung?

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 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);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Fehlerbehandlung 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
}

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
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Fü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");
}

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Bereitstellungsü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. Weitere Hinweise zum Einsatz finden Sie in der Einsatzdokumentation.

Abschluss

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.