Erstellen Sie Excel-Dateien in C# mit IronXL, einer Bibliothek, mit der Sie Excel-Tabellen ohne Microsoft Office erstellen, formatieren und befüllen können. Ideal für Serverumgebungen, Docker-Container und CI/CD-Pipelines.
DevOps wichtig?Die Entwicklung von Excel-Generierungsfunktionen ohne Office-Zugriff löst wichtige Herausforderungen bei der Bereitstellung. Serverumgebungen verfügen aufgrund von Lizenzkosten und Ressourcenbedarf häufig nicht über Microsoft Office. Jede Office-Installation benötigt erheblichen Speicherplatz und Arbeitsspeicher, wodurch sie für Cloud-Bereitstellungen oder containerisierte Anwendungen ungeeignet ist. Bei der Bereitstellung auf AWS Lambda oder der Ausführung in Docker-Containern ist eine schlanke Lösung für die Infrastrukturautomatisierung von entscheidender Bedeutung.
IronXL beseitigt diese Einschränkungen durch seine unabhängige Funktionsweise. Die Generierung Ihrer Excel-Datei läuft ohne Änderungen unter Windows, Linux, macOS, Docker-Containern oder Azure App Services. Diese plattformübergreifende Kompatibilität bedeutet einmal schreiben und überall bereitstellen, egal ob Sie .NET Framework, .NET Core oder .NET 8/9-Anwendungen anvisieren. Für Teams, die .NET MAUI oder Blazor verwenden, lässt sich IronXL nahtlos in alle modernen .NET -Plattformen integrieren.
IronXL unterstützt alle wichtigen .NET Plattformen und Betriebssysteme für maximale Flexibilität bei der Bereitstellung.
| Feature | IronXL | EPPlus | ClosedXML | NPOI |
|---|---|---|---|---|
| Preis | $999 | $599 | Kostenlos | Kostenlos |
| Büro-Abhängigkeit | None | None | None | None |
| Leistung | 40x schneller* | Gut | Mäßig | Langsam |
| Speichernutzung | <1GB** | 2-3 GB | 1-2 GB | 3-5 GB |
| Docker-Unterstützung | Native | Beschränkt | Basic | Basic |
| Formelunterstützung | Mehr als 165 Funktionen | 100+ | 80+ | Basic |
| Kommerzielle Unterstützung | Ja | Ja | Nein | Nein |
| Lernkurve | Einfach | Mäßig | Mäßig | Steil |
*Basierend auf den jüngsten Leistungsverbesserungen **Zur Verarbeitung großer Excel-Dateien
Die Leistung verbessert sich deutlich ohne den 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 Bibliothek hat bedeutende Leistungsverbesserungen erfahren, wobei die jüngsten Updates eine bis zu 40-fache Geschwindigkeitssteigerung und eine drastische Reduzierung des Speicherverbrauchs von 19,5 GB auf unter 1 GB ermöglichten.
Die Bereitstellung wird einfach, da IronXL als einzelnes NuGet-Paket geliefert wird. Es müssen keine Registry-Einträge, COM-Registrierungen oder Office-Service-Packs verwaltet werden. 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 wird, in denen Fachleute ihre Erfahrungen mit der Excel-Automatisierung ohne Interop austauschen.
IronXL bietet umfassende Funktionen zur Excel-Bearbeitung über ein intuitives API-Design.
DevOps-Workflows?Die Installation von IronXL über den NuGet -Paketmanager dauert nur wenige Augenblicke. 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. Detaillierte Installationshinweise speziell für Ihre Entwicklungsumgebung finden Sie in der Übersicht "Erste Schritte" .
Alternativ können Sie die Paket-Manager-Konsole verwenden:
Die Paket-Manager-Konsole bestätigt die erfolgreiche Installation von IronXL mit allen erforderlichen Abhängigkeiten.
Für .NET CLI-Benutzer, die mit modernen C#-Projekten in automatisierten Build-Pipelines arbeiten:
Für containerisierte Bereitstellungen fügen Sie Folgendes zu Ihrer Dockerfile hinzu:
RUN dotnet add package IronXL.ExcelÜberprüfen Sie die Installation mit diesem einfachen Test, um Excel-Dateien programmatisch zu erstellen:
using IronXL;
// new Excel workbook
var workbook = WorkBook.Create();
Console.WriteLine("IronXL installed successfully!");Imports IronXL
' 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 VB .NET Entwickler stehen ähnliche Funktionen mit VB-spezifischen Syntaxbeispielen zur Verfügung. Bei der Arbeit mit älteren Dateiformaten oder bei Problemen mit der Dateigröße bietet die Bibliothek Komplettlösungen .
Die Konsolenausgabe bestätigt, dass IronXL ordnungsgemäß installiert und für die Excel-Generierung bereit ist.
Mit IronXL lassen sich Excel-Dateien mit nur wenigen Codezeilen erstellen, was es ideal für schnelle Entwicklungs- und Bereitstellungsszenarien macht.
using IronXL;
// Create a new workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add a worksheet
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Add data
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Revenue";
// Save the file
workbook.SaveAs("sales_report.xlsx");
Das Erstellen 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. Die Funktion zum Erstellen von Tabellenkalkulationen bietet umfassende Optionen zum Initialisieren neuer Arbeitsmappen.
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 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. Die Metadaten-Eigenschaft ermöglicht es Ihnen, Dokumentinformationen einzubetten, die in den Dateieigenschaften von Excel angezeigt werden, wobei die Standards für Dokumenteigenschaften von Microsoft eingehalten werden und die Dateiorganisation in Enterprise erleichtert wird. Erfahren Sie mehr über das Bearbeiten von Arbeitsmappen-Metadaten .
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 komplette Excel-Datei auf die Festplatte. Weitere Informationen zu Arbeitsblattfunktionen finden Sie im Tutorial zur Arbeitsblattverwaltung .
Einfache Excel-Datei, die von IronXL generiert wurde und strukturierte Daten mit korrekten Spaltenüberschriften anzeigt.
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. Der Leitfaden zum Schreiben von Excel-Werten behandelt alle verfügbaren Optionen ausführlich.
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("EmployeeData.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("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") setzen effizient mehrere Zellen auf denselben Wert, ideal für die Initialisierung von Spalten oder die Anwendung von Standardwerten. Bei der Arbeit mit benannten Bereichen oder benannten Tabellen bietet IronXL zusätzliche Organisationsmöglichkeiten.
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 mit Zeile 2, um Header zu erhalten. Bei der Verarbeitung großer Datensätze können Sie Zeilen und Spalten dynamisch hinzufügen oder Zellbereiche kopieren, um die Effizienz zu steigern.
Mitarbeiterdaten-Tabelle, die verschiedene Datentypen und Zellzuordnungsmethoden in IronXL demonstriert.
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, wenn Sie Excel-Dateien in C# generieren. Die Bibliothek bietet umfassende Zellformatierungsoptionen zur Erstellung optisch ansprechender Tabellenkalkulationen.
using IronXL;
using IronXL.Formatting;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Create a worksheet
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Add sample data first
worksheet["A1"].Value = "ID";
worksheet["B1"].Value = "Name";
worksheet["C1"].Value = "Department";
worksheet["D1"].Value = "Phone";
worksheet["E1"].Value = "Salary";
worksheet["F1"].Value = "Start Date";
worksheet["G1"].Value = "Full Time";
// Add employee data
worksheet["A2"].Value = 101;
worksheet["B2"].Value = "John Smith";
worksheet["C2"].Value = "Sales";
worksheet["D2"].Value = "(555) 123-4567";
worksheet["E2"].Value = 75000.50m;
worksheet["F2"].Value = new DateTime(2020, 3, 15);
worksheet["G2"].Value = true;
worksheet["A3"].Value = 102;
worksheet["B3"].Value = "Jane Doe";
worksheet["C3"].Value = "Marketing";
worksheet["D3"].Value = "(555) 987-6543";
worksheet["E3"].Value = 82000.75m;
worksheet["F3"].Value = new DateTime(2019, 7, 1);
worksheet["G3"].Value = true;
// Header formatting
var headerRange = worksheet["A1:G1"];
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.SetColumnWidth(1, 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.SetColor("#000000");
dataRange.Style.BottomBorder.SetColor("#000000");
dataRange.Style.LeftBorder.SetColor("#000000");
dataRange.Style.RightBorder.SetColor("#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");
}
}
workbook.SaveAs("FormattedEmployees.xlsx");Imports IronXL
Imports IronXL.Formatting
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Create a worksheet
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Add sample data first
worksheet("A1").Value = "ID"
worksheet("B1").Value = "Name"
worksheet("C1").Value = "Department"
worksheet("D1").Value = "Phone"
worksheet("E1").Value = "Salary"
worksheet("F1").Value = "Start Date"
worksheet("G1").Value = "Full Time"
' Add employee data
worksheet("A2").Value = 101
worksheet("B2").Value = "John Smith"
worksheet("C2").Value = "Sales"
worksheet("D2").Value = "(555) 123-4567"
worksheet("E2").Value = 75000.5D
worksheet("F2").Value = New DateTime(2020, 3, 15)
worksheet("G2").Value = True
worksheet("A3").Value = 102
worksheet("B3").Value = "Jane Doe"
worksheet("C3").Value = "Marketing"
worksheet("D3").Value = "(555) 987-6543"
worksheet("E3").Value = 82000.75D
worksheet("F3").Value = New DateTime(2019, 7, 1)
worksheet("G3").Value = True
' Header formatting
Dim headerRange = worksheet("A1:G1")
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.SetColumnWidth(1, 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.SetColor("#000000")
dataRange.Style.BottomBorder.SetColor("#000000")
dataRange.Style.LeftBorder.SetColor("#000000")
dataRange.Style.RightBorder.SetColor("#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 row
workbook.SaveAs("FormattedEmployees.xlsx")Dieser Formatierungscode erstellt ein professionelles Erscheinungsbild, das Unternehmensstandards erfüllt. Fettgedruckte Überschriften mit Hintergrundmustern und -farben schaffen eine visuelle Hierarchie. Die SetBackgroundColor()-Methode akzeptiert Hex-Farbcodes und bietet Ihnen präzise Kontrolle über Ihr Farbschema. Zu den Schrifteigenschaften gehören Optionen für Größe, Farbe, Fettdruck, Kursivschrift und Unterstreichung – allesamt unerlässlich für die Erstellung von Excel-Dateien, die den Corporate-Branding-Richtlinien entsprechen. Für anspruchsvollere Formatierungsanforderungen sollten Sie die Möglichkeiten der bedingten Formatierung erkunden.
Spaltenbreitenanpassungen verhindern Textverkürzungen. AutoSizeColumn() passt den Inhalt automatisch an, während SetColumnWidth() genaue Kontrolle bietet. Die automatische Anpassung von Zeilen und Spalten gewährleistet eine optimale Darstellung Ihrer Daten. Die Zahlenformatierung verwendet die Formatcodes von Excel – erfahren Sie mehr über die Excel-Zahlenformate für umfassende Formatierungsoptionen.
Rahmen und Zellenausrichtung definieren Datengrenzen und verbessern so die Lesbarkeit. Das BorderType-Enum bietet verschiedene Stile: dünn, mittel, dick, gepunktet und gestrichelt. Rahmen- und Ausrichtungsoptionen zentrieren Überschriften und richten Zahlen rechtsbündig aus, gemäß den Konventionen für Tabellenkalkulationen. Wechselnde Zeilenfarben, oft auch "gestreifte Zeilen" genannt, helfen Lesern, Informationen über große Datensätze hinweg zu verfolgen.
Professionell formatierte Excel-Datei, die die Gestaltungsmöglichkeiten von IronXL für Enterprise demonstriert.
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. Die Bibliothek bietet Unterstützung für über 165 Excel-Funktionen und ermöglicht die programmgesteuerte Bearbeitung von Formeln .
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 Budgetbeispiel veranschaulicht die praktische Anwendung der Formel. Die Formula-Eigenschaft akzeptiert die Standard-Excel-Formelsyntax, beginnend mit einem Gleichheitszeichen. IronXL unterstützt gängige Funktionen: SUM, AVERAGE, COUNT, MAX, MIN und viele andere. Zellverweise in Formeln funktionieren genauso wie in Excel, einschließlich relativer und absoluter Verweise. Für komplexere Berechnungen sollten Sie die Aggregatfunktionen von Excel und die Excel-Formeln in C# erkunden.
Wenn Formeln nicht wie erwartet funktionieren:
= beginnenEvaluateAll() auf: Erforderlich vor dem Speichern, um Ergebnisse zu sehenDie 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. Für komplexe Szenarien mit Excel-Formeln in C# bietet IronXL umfassende Unterstützung.
Budget-Arbeitsblatt mit aktiven Formeln zur automatischen Berechnung von Summen und Prozentsätzen.
Echtweltanwendungen exportieren häufig Datenbanken-Daten zu Excel für Berichterstattungs- und Analysezwecke. IronXL vereinfacht diesen Prozess mit eingebauter DataTable Unterstützung, wodurch manuelles Feldmapping bei der Erstellung von Excel-Dateien aus C#-Anwendungen entfällt. Die Bibliothek bietet verschiedene Methoden zur Datenbankintegration und DataGrid-Kompatibilität .
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.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#. Die DataTable simuliert die Datenbankabfrage - im Produktionsbetrieb ersetzen Sie dies durch Ihre tatsächliche Datenbankabfrage mithilfe von Entity Framework, Dapper oder ADO.NET. Für eine direkte SQL-Integration sollten Sie das Laden von Excel-Datensätzen aus SQL-Datenbanken oder das Aktualisieren von Datenbankeinträgen aus Excel-Datensätzen in Betracht ziehen.
Bei großen Datenbankexporten sollten Sie Folgendes beachten:
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 anstelle von DataTables sehen Sie sich den Anleitung zur Exportdatensatz-Datentabelle an.
Professional Verkaufsbericht, generiert aus Datenbankdaten mit automatischen Berechnungen und Formatierungen.
Müssen Sie Ihr Excel-Reporting rationalisieren? Erwerben Sie eine Lizenz, um das volle Potenzial von IronXL für den Produktiveinsatz auszuschöpfen.
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. Erfahren Sie mehr über die Verwaltung von Arbeitsblättern und das Kopieren von Arbeitsblattdaten für fortgeschrittene Szenarien.
// 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 Verkaufsblatt. Für komplexere Operationen empfiehlt es sich, Excel-Bereiche zu kombinieren und Zeilen und Spalten zu gruppieren .
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, um ein professionelles Erscheinungsbild im gesamten Workbook beizubehalten. In Excel werden Tabellenblattnamen als Registerkarten angezeigt, sodass Benutzer einfach zwischen verschiedenen Datenansichten navigieren können. Für komplexere Szenarien empfiehlt sich das Hinzufügen von Fixierfenstern , um die Überschriften beim Scrollen durch große Datensätze sichtbar zu halten.
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. Prüfen Sie die Best Practices für die Sicherheit und die Optionen zum Dateischutz für Enterprise .
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 SubDevOps-Teams?| Problem | Lösung | Verhütung |
|---|---|---|
| Speicherplatz erschöpft | Verarbeitung in Chargen | Überwachen Sie die Chargengrößen |
| Dateisperren | Verwenden Sie Streams, keine Dateien. | Sorgen Sie für eine ordnungsgemäße Entsorgung. |
| Lizenzfehler | Lizenz im Code überprüfen | Lizenz korrekt beantragen |
| Leistung | Asynchrone Operationen aktivieren | Profilengpässe |
| Containerprobleme | Abhängigkeiten installieren | Lokaler Test in Docker |
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
}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 TryBei Webanwendungen werden Excel-Dateien im Arbeitsspeicher generiert und an die Benutzer gestreamt. Dieser Ansatz funktioniert perfekt mit ASP.NET MVC-Anwendungen :
// 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. Informationen zur korrekten Lizenzkonfiguration finden Sie unter Verwendung von Lizenzschlüsseln und Einrichtung der web.config-Datei .
Für Docker-Bereitstellungen:
FROM mcr.microsoft.com/dotnet/runtime:8.0
WORKDIR /app
COPY . .
# Abhängigkeiten installieren for Excel operations
RUN apt-get update && apt-get install -y libgdiplus
ENV IRONXL_LICENSE_KEY=${IRONXL_LICENSE_KEY}
ENTRYPOINT ["dotnet", "YourApp.dll"]Bei der Arbeit mit sensiblen Daten sollten Sie Arbeitsmappen mit einem Passwort schützen und Arbeitsblätter sichern . IronXL bietet umfassende Sicherheitsfunktionen, um Ihre Excel-Dateien vor unberechtigtem Zugriff zu schützen. Für eine optimale Leistung bei großen Dateien sollten Sie Strategien zum Datentrimmen und Zellenlöschen implementieren, um die Dateigröße effektiv zu verwalten.
Bei Linux-Installationen ist auf eine korrekte Konfiguration gemäß der Linux-Setup-Anleitung zu achten. Bei der Bereitstellung auf AWS Lambda konsultieren Sie bitte den AWS-Bereitstellungsleitfaden für serverlose Konfigurationen.
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.
Weitere Funktionen finden Sie hier:
Bereit zur Implementierung von Excel-Generierung in Ihren C#-Anwendungen? Starten Sie Ihre kostenlose Testphase oder erkunden Sie die umfassende API-Dokumentation für erweiterte Funktionen. Für Produktionsumgebungen sehen Sie sich die Lizenzoptionen an, die Ihren Projektanforderungen entsprechen. Erwägen Sie, Lizenzerweiterungen und Upgrade-Optionen in Betracht zu ziehen, wenn Ihre Anforderungen wachsen.
Flexible Lizenzierungsoptionen, die Ihren Anforderungen an die Excel-Generierung von der Entwicklung bis zum Enterprise gerecht werden.
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.
