Wofür wird IronXL in C# verwendet?

IronXL ist eine leistungsstarke Bibliothek für C#, die es Entwicklern ermöglicht, Excel-Dateien auf einfache Weise zu erstellen, zu bearbeiten und zu lesen. Sie unterstützt die Erstellung professioneller Excel-Berichte mit erweiterten Formatierungen, Formeln und Datenintegration.

Wie kann ich mit IronXL Excel-Berichte erstellen?

Um mit IronXL Excel-Berichte zu erstellen, können Sie die robuste API nutzen, um Daten hinzuzufügen, Zellen zu formatieren, Formeln anzuwenden und mit Datenbanken zu integrieren - alles in einer C#-Umgebung.

Welche Funktionen bietet IronXL für die Erstellung von Excel-Berichten?

IronXL bietet Funktionen wie Zellformatierung, Formelanwendung, Datenvalidierung, Diagrammerstellung und nahtlose Datenbankintegration für eine umfassende Excel-Berichterstellung.

Unterstützt IronXL die Integration von Datenbanken?

Ja, IronXL unterstützt die Datenbankintegration, so dass Sie Daten direkt aus Datenbanken abrufen und in Ihre Excel-Berichte einbinden können, wodurch die Datenanalyse und das Berichtswesen optimiert werden.

Kann IronXL mit komplexen Excel-Formeln umgehen?

IronXL kann eine Vielzahl von Excel-Formeln verarbeiten und ermöglicht es Entwicklern, komplexe Berechnungen durchzuführen und die Datenverarbeitung in Excel-Berichten zu automatisieren.

Ist es möglich, Excel-Zellen mit IronXL zu formatieren?

IronXL bietet umfangreiche Formatierungsfunktionen, mit denen Sie das Erscheinungsbild von Zellen, einschließlich Schriftart, Farbe, Rahmen und mehr, anpassen können, um visuell ansprechende Excel-Berichte zu erstellen.

Kann ich mit IronXL Diagramme in Excel erstellen?

Ja, IronXL ermöglicht es Ihnen, eine Vielzahl von Diagrammen in Excel-Tabellen zu erstellen, die Ihnen helfen, Daten visuell darzustellen und die Interpretierbarkeit Ihrer Berichte zu verbessern.

Wie vereinfacht IronXL den Prozess der Erstellung von Excel-Berichten?

IronXL vereinfacht die Erstellung von Excel-Berichten, indem es eine umfassende Reihe von Funktionen bietet, die die Dateneingabe, -formatierung, -berechnung und -ausgabe rationalisieren, und das alles innerhalb der C#-Programmierumgebung.

Kann IronXL große Datensätze effizient verarbeiten?

IronXL ist auf Leistung optimiert, so dass es große Datenmengen effizient verarbeiten kann, was es ideal für die Erstellung komplexer Berichte macht, ohne Kompromisse bei der Geschwindigkeit oder Zuverlässigkeit einzugehen.

Für welche Programmiersprache ist IronXL konzipiert?

IronXL ist speziell für die Verwendung mit C# konzipiert und bietet eine nahtlose Integration und Funktionalität für Entwickler, die im .NET Framework arbeiten.

Die C# Excel-Bibliothek

Explore IronXL Excel Spreadsheet Library for C# .NET Gratis testen

Excel-Dateien ohne Interop lesen

Alle Codebeispiele anzeigen

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

IRONXL VERWENDEN

Creating Excel Reports in C# with IronXL

Curtis Chau

Updated: 8. Mai 2026

Excel-Berichte in C# zu erstellen, ist ein grundlegendes Erfordernis in modernen Geschäfts- und .NET-Anwendungen. Egal, ob Sie Finanzberichte, Verkaufsanalysen oder Bestandsübersichten erstellen, die Automatisierung des Erstellungsprozesses von Excel-Dateien und Excel-Tabellen spart Stunden manueller Arbeit und reduziert Fehler.

IronXL bietet eine leistungsstarke, intuitive Lösung für Entwickler, um einen Excel-Bericht in C# zu erstellen, ohne dass Microsoft Office, MS Excel oder traditionelle Interop-Abhängigkeiten erforderlich sind. Im Gegensatz zu OLE-Automatisierung oder Ansätzen, die auf der Excel-Anwendung basieren, ermöglicht IronXL das Erzeugen von Excel-Arbeitsmappen und Excel-Daten direkt im Code mit nur einer Zeile, wo dies erforderlich ist. In diesem Leitfaden zeigen wir Ihnen, wie Sie mit IronXL Excel-Berichte erstellen können, komplett mit einfach zu befolgendem Beispielcode, den Sie leicht in Ihre eigenen Projekte implementieren können!

Was ist IronXL und warum sollte man es für die Generierung von Excel-Dateien verwenden?

IronXL ist eine .NET-Excel-Bibliothek, die es Entwicklern ermöglicht, Excel-Tabellen zu erstellen, zu lesen und Excel-Dateien direkt aus C#- oder Visual Basic-Quellcode zu bearbeiten. Im Gegensatz zu Microsoft Office Interop-Ansätzen, die sich auf die vollständige Excel-Anwendung oder das Reverse Engineering über Open XML SDK stützen, funktioniert IronXL in Windows-, Linux-, macOS- und Cloud-Umgebungen, ohne dass eine Excel-Installation oder Abhängigkeiten von Dritten erforderlich sind. Dies macht es ideal für serverseitige Excel-Berichte, automatisierte Workflows und Webanwendungen, die auf .NET Core oder dem .NET-Framework aufgebaut sind.

Für Teams, die von manuellen Excel-Prozessen, älteren Bibliotheken oder Open XML-Produktivitätstool-Workflows umsteigen müssen, die das Navigieren in verschiedenen XML-Namespaces erfordern, bietet IronXL eine intuitive API. Es unterstützt sowohl alte XLS-Dateien als auch moderne XLSX-Dateien, die im Wesentlichen ZIP-Dateien mit XML-Dateien und verschiedenen Ordnern sind. Egal, ob Sie ein neues Excel-Arbeitsbuch erzeugen, mehrere Arbeitsblätter bearbeiten oder Excel-Daten aus externem Code laden möchten, IronXL vereinfacht den Prozess erheblich, ohne dass ein Verständnis der zugrunde liegenden Formate erforderlich ist.

Erste Schritte mit IronXL zur Erstellung einer Excel-Datei

Die Einrichtung von IronXL, um Excel-Berichte zu erstellen, dauert nur wenige Minuten. Installieren Sie die Bibliothek über den NuGet-Paket-Manager in Visual Studio:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Laden Sie IronXL noch heute herunter und beginnen Sie mit der Automatisierung Ihrer Excel-Berichtserstellung.

Nachdem die Installation abgeschlossen ist, erfordert die Erstellung Ihres ersten Excel-Berichts nur ein paar Codezeilen:

using IronXL;
// Create a new Excel workbook for reports
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add a worksheet for the report
WorkSheet reportSheet = workBook.CreateWorkSheet("Monthly Report");
// Add a title
reportSheet["A1"].Value = "Sales Report - January 2024";
reportSheet["A1"].Style.Font.Bold = true;
// Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx");

using IronXL;
// Create a new Excel workbook for reports
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add a worksheet for the report
WorkSheet reportSheet = workBook.CreateWorkSheet("Monthly Report");
// Add a title
reportSheet["A1"].Value = "Sales Report - January 2024";
reportSheet["A1"].Style.Font.Bold = true;
// Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx");

Imports IronXL

' Create a new Excel workbook for reports
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add a worksheet for the report
Dim reportSheet As WorkSheet = workBook.CreateWorkSheet("Monthly Report")
' Add a title
reportSheet("A1").Value = "Sales Report - January 2024"
reportSheet("A1").Style.Font.Bold = True
' Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx")

Imports IronXL

' Create a new Excel workbook for reports
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add a worksheet for the report
Dim reportSheet As WorkSheet = workBook.CreateWorkSheet("Monthly Report")
' Add a title
reportSheet("A1").Value = "Sales Report - January 2024"
reportSheet("A1").Style.Font.Bold = True
' Save the Excel report
workBook.SaveAs("MonthlyReport.xlsx")

Dieser Code erstellt eine neue Excel-Berichtsdatei mit einem formatierten Titel. Die vertraute Zellbezugssyntax (reportSheet["A1"]) macht es Entwicklern leicht, genau anzugeben, wo Daten erscheinen sollen, genau wie bei der manuellen Arbeit mit Excel.

Ausgabe

So erstellen Sie Excel-Berichte in C# mit IronXL: Bild 1 - Beispielausgabe in Excel

Daten aus mehreren Quellen laden

Echte Excel-Berichte verwenden selten statische Daten. IronXL ist hervorragend darin, Excel-Daten aus verschiedenen Formaten, APIs, neuen DataTable-Quellen oder sogar mehreren unterschiedlichen XML-Dateien zu integrieren. Dies macht es perfekt für die dynamische C# Excel-Berichtsgenerierung in serverseitigen oder Webanwendungen.

Datenbankintegration

Für datenbankgestützte Excel-Berichte arbeitet IronXL nahtlos mit ADO.NET DataTables zusammen:

using System.Data;
using System.Data.SqlClient;
// Fetch data from database
string connectionString = "Server=localhost;Database=Sales;Integrated Security=true;";
DataTable salesData = new DataTable();
using (SqlConnection conn = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(
        "SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn);
    adapter.Fill(salesData);
}
// Create Excel report from DataTable
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.CreateWorkSheet("Sales Data");
// Add headers
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Revenue";
// Populate data
int row = 2;
foreach (DataRow dataRow in salesData.Rows)
{
    sheet[$"A{row}"].Value = dataRow["ProductName"];
    sheet[$"B{row}"].Value = dataRow["Quantity"];
    sheet[$"C{row}"].Value = dataRow["Revenue"];
    row++;
}

using System.Data;
using System.Data.SqlClient;
// Fetch data from database
string connectionString = "Server=localhost;Database=Sales;Integrated Security=true;";
DataTable salesData = new DataTable();
using (SqlConnection conn = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(
        "SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn);
    adapter.Fill(salesData);
}
// Create Excel report from DataTable
WorkBook workBook = WorkBook.Create();
WorkSheet sheet = workBook.CreateWorkSheet("Sales Data");
// Add headers
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Revenue";
// Populate data
int row = 2;
foreach (DataRow dataRow in salesData.Rows)
{
    sheet[$"A{row}"].Value = dataRow["ProductName"];
    sheet[$"B{row}"].Value = dataRow["Quantity"];
    sheet[$"C{row}"].Value = dataRow["Revenue"];
    row++;
}

Imports System.Data
Imports System.Data.SqlClient

' Fetch data from database
Dim connectionString As String = "Server=localhost;Database=Sales;Integrated Security=true;"
Dim salesData As New DataTable()
Using conn As New SqlConnection(connectionString)
    Dim adapter As New SqlDataAdapter("SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn)
    adapter.Fill(salesData)
End Using

' Create Excel report from DataTable
Dim workBook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workBook.CreateWorkSheet("Sales Data")

' Add headers
sheet("A1").Value = "Product"
sheet("B1").Value = "Quantity"
sheet("C1").Value = "Revenue"

' Populate data
Dim row As Integer = 2
For Each dataRow As DataRow In salesData.Rows
    sheet($"A{row}").Value = dataRow("ProductName")
    sheet($"B{row}").Value = dataRow("Quantity")
    sheet($"C{row}").Value = dataRow("Revenue")
    row += 1
Next

Imports System.Data
Imports System.Data.SqlClient

' Fetch data from database
Dim connectionString As String = "Server=localhost;Database=Sales;Integrated Security=true;"
Dim salesData As New DataTable()
Using conn As New SqlConnection(connectionString)
    Dim adapter As New SqlDataAdapter("SELECT ProductName, Quantity, Revenue FROM MonthlySales", conn)
    adapter.Fill(salesData)
End Using

' Create Excel report from DataTable
Dim workBook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workBook.CreateWorkSheet("Sales Data")

' Add headers
sheet("A1").Value = "Product"
sheet("B1").Value = "Quantity"
sheet("C1").Value = "Revenue"

' Populate data
Dim row As Integer = 2
For Each dataRow As DataRow In salesData.Rows
    sheet($"A{row}").Value = dataRow("ProductName")
    sheet($"B{row}").Value = dataRow("Quantity")
    sheet($"C{row}").Value = dataRow("Revenue")
    row += 1
Next

Dieser Ansatz lädt Verkaufsdaten direkt von SQL Server in Ihren Excel-Bericht. Die DataTable-Integration bedeutet, dass Sie bestehenden Datenzugriffscode ohne Modifizierung verwenden können. Für komplexere Szenarien, sehen Sie sich an, wie man Excel aus SQL-Datenbanken lädt.

Arbeiten mit Sammlungen

Für In-Memory-Daten, Excel-Daten aus API-Antworten oder eine neue DataTable können Collections Excel-Arbeitsblätter einfach und ohne Microsoft Excel oder Abhängigkeiten von Drittanbietern auffüllen:

var salesRecords = new List<SalesRecord>
{
    new SalesRecord { Product = "Widget A", Units = 150, Price = 29.99m },
    new SalesRecord { Product = "Widget B", Units = 82, Price = 49.99m }
};
// Convert collection to Excel
for (int i = 0; i < salesRecords.Count; i++)
{
    sheet[$"A{i+2}"].Value = salesRecords[i].Product;
    sheet[$"B{i+2}"].Value = salesRecords[i].Units;
    sheet[$"C{i+2}"].Value = salesRecords[i].Price;
}

var salesRecords = new List<SalesRecord>
{
    new SalesRecord { Product = "Widget A", Units = 150, Price = 29.99m },
    new SalesRecord { Product = "Widget B", Units = 82, Price = 49.99m }
};
// Convert collection to Excel
for (int i = 0; i < salesRecords.Count; i++)
{
    sheet[$"A{i+2}"].Value = salesRecords[i].Product;
    sheet[$"B{i+2}"].Value = salesRecords[i].Units;
    sheet[$"C{i+2}"].Value = salesRecords[i].Price;
}

Imports System.Collections.Generic

Dim salesRecords As New List(Of SalesRecord) From {
    New SalesRecord With {.Product = "Widget A", .Units = 150, .Price = 29.99D},
    New SalesRecord With {.Product = "Widget B", .Units = 82, .Price = 49.99D}
}

' Convert collection to Excel
For i As Integer = 0 To salesRecords.Count - 1
    sheet($"A{i + 2}").Value = salesRecords(i).Product
    sheet($"B{i + 2}").Value = salesRecords(i).Units
    sheet($"C{i + 2}").Value = salesRecords(i).Price
Next

Imports System.Collections.Generic

Dim salesRecords As New List(Of SalesRecord) From {
    New SalesRecord With {.Product = "Widget A", .Units = 150, .Price = 29.99D},
    New SalesRecord With {.Product = "Widget B", .Units = 82, .Price = 49.99D}
}

' Convert collection to Excel
For i As Integer = 0 To salesRecords.Count - 1
    sheet($"A{i + 2}").Value = salesRecords(i).Product
    sheet($"B{i + 2}").Value = salesRecords(i).Units
    sheet($"C{i + 2}").Value = salesRecords(i).Price
Next

Dieser Methode erlaubt es, einen Excel-Bericht in C# direkt in einer .NET-Anwendung zu erstellen und vereinfacht den Prozess der Erstellung von mehreren Arbeitsblättern oder XLSX-Dateien erheblich im Vergleich zur manuellen OLE-Automatisierung oder der Rückwärtsingenieurierung von XML-Dateien.

Ausgabe

So erstellen Sie Excel-Berichte in C# mit IronXL: Bild 2 – Beispielarbeitsblatt aus der Datenausgabe

Formatierung professioneller Excel-Berichte

Rohdaten allein machen keinen professionellen Bericht. IronXL bietet umfassende Zellformatierungsoptionen, um polierte, geschäftsreife Excel-Dateien zu erstellen. Der folgende Code zeigt, wie einfach das mit IronXL ist:

using IronXL;
using IronXL.Styles;

class Program
{
    static void Main(string[] args)
    {
        // Create a new workbook
        var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        // Add a new worksheet
        var sheet = workbook.CreateWorkSheet("MySheet");
        // Add header values
        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Quantity";
        sheet["C1"].Value = "Price";
        // Add sample data rows
        sheet["A2"].Value = "Laptop";
        sheet["B2"].Value = 5;
        sheet["C2"].Value = 1299.99;
        sheet["A3"].Value = "Headphones";
        sheet["B3"].Value = 15;
        sheet["C3"].Value = 199.50;
        sheet["A4"].Value = "Keyboard";
        sheet["B4"].Value = 10;
        sheet["C4"].Value = 89.99;
        sheet["A5"].Value = "Monitor";
        sheet["B5"].Value = 7;
        sheet["C5"].Value = 249.00;
        // Header formatting
        var headerRange = sheet["A1:C1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.SetBackgroundColor("#4472C4");
        headerRange.Style.Font.Color = "#FFFFFF";
        headerRange.Style.BottomBorder.Type = BorderType.Thick;
        // Number formatting for currency
        sheet["C:C"].FormatString = "$#,##0.00";
        // Alternating row colors for readability
        for (int row = 2; row <= 10; row++)
        {
            if (row % 2 == 0)
            {
                sheet[$"A{row}:C{row}"].Style.SetBackgroundColor("#F2F2F2");
            }
        }
        // Column width adjustment
        sheet.Columns[0].Width = 15 * 256; // Width in 1/256th of character width
        sheet.Columns[2].Width = 12 * 256;
        // Add borders around data
        var dataRange = sheet["A1:C10"];
        dataRange.Style.TopBorder.Type = BorderType.Thin;
        dataRange.Style.RightBorder.Type = BorderType.Thin;
        dataRange.Style.BottomBorder.Type = BorderType.Thin;
        dataRange.Style.LeftBorder.Type = BorderType.Thin;
        // Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx");
    }
}

using IronXL;
using IronXL.Styles;

class Program
{
    static void Main(string[] args)
    {
        // Create a new workbook
        var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        // Add a new worksheet
        var sheet = workbook.CreateWorkSheet("MySheet");
        // Add header values
        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Quantity";
        sheet["C1"].Value = "Price";
        // Add sample data rows
        sheet["A2"].Value = "Laptop";
        sheet["B2"].Value = 5;
        sheet["C2"].Value = 1299.99;
        sheet["A3"].Value = "Headphones";
        sheet["B3"].Value = 15;
        sheet["C3"].Value = 199.50;
        sheet["A4"].Value = "Keyboard";
        sheet["B4"].Value = 10;
        sheet["C4"].Value = 89.99;
        sheet["A5"].Value = "Monitor";
        sheet["B5"].Value = 7;
        sheet["C5"].Value = 249.00;
        // Header formatting
        var headerRange = sheet["A1:C1"];
        headerRange.Style.Font.Bold = true;
        headerRange.Style.SetBackgroundColor("#4472C4");
        headerRange.Style.Font.Color = "#FFFFFF";
        headerRange.Style.BottomBorder.Type = BorderType.Thick;
        // Number formatting for currency
        sheet["C:C"].FormatString = "$#,##0.00";
        // Alternating row colors for readability
        for (int row = 2; row <= 10; row++)
        {
            if (row % 2 == 0)
            {
                sheet[$"A{row}:C{row}"].Style.SetBackgroundColor("#F2F2F2");
            }
        }
        // Column width adjustment
        sheet.Columns[0].Width = 15 * 256; // Width in 1/256th of character width
        sheet.Columns[2].Width = 12 * 256;
        // Add borders around data
        var dataRange = sheet["A1:C10"];
        dataRange.Style.TopBorder.Type = BorderType.Thin;
        dataRange.Style.RightBorder.Type = BorderType.Thin;
        dataRange.Style.BottomBorder.Type = BorderType.Thin;
        dataRange.Style.LeftBorder.Type = BorderType.Thin;
        // Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx");
    }
}

Imports IronXL
Imports IronXL.Styles

Module Program
    Sub Main(args As String())
        ' Create a new workbook
        Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Add a new worksheet
        Dim sheet = workbook.CreateWorkSheet("MySheet")
        ' Add header values
        sheet("A1").Value = "Product"
        sheet("B1").Value = "Quantity"
        sheet("C1").Value = "Price"
        ' Add sample data rows
        sheet("A2").Value = "Laptop"
        sheet("B2").Value = 5
        sheet("C2").Value = 1299.99
        sheet("A3").Value = "Headphones"
        sheet("B3").Value = 15
        sheet("C3").Value = 199.5
        sheet("A4").Value = "Keyboard"
        sheet("B4").Value = 10
        sheet("C4").Value = 89.99
        sheet("A5").Value = "Monitor"
        sheet("B5").Value = 7
        sheet("C5").Value = 249.0
        ' Header formatting
        Dim headerRange = sheet("A1:C1")
        headerRange.Style.Font.Bold = True
        headerRange.Style.SetBackgroundColor("#4472C4")
        headerRange.Style.Font.Color = "#FFFFFF"
        headerRange.Style.BottomBorder.Type = BorderType.Thick
        ' Number formatting for currency
        sheet("C:C").FormatString = "$#,##0.00"
        ' Alternating row colors for readability
        For row As Integer = 2 To 10
            If row Mod 2 = 0 Then
                sheet($"A{row}:C{row}").Style.SetBackgroundColor("#F2F2F2")
            End If
        Next
        ' Column width adjustment
        sheet.Columns(0).Width = 15 * 256 ' Width in 1/256th of character width
        sheet.Columns(2).Width = 12 * 256
        ' Add borders around data
        Dim dataRange = sheet("A1:C10")
        dataRange.Style.TopBorder.Type = BorderType.Thin
        dataRange.Style.RightBorder.Type = BorderType.Thin
        dataRange.Style.BottomBorder.Type = BorderType.Thin
        dataRange.Style.LeftBorder.Type = BorderType.Thin
        ' Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx")
    End Sub
End Module

Imports IronXL
Imports IronXL.Styles

Module Program
    Sub Main(args As String())
        ' Create a new workbook
        Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Add a new worksheet
        Dim sheet = workbook.CreateWorkSheet("MySheet")
        ' Add header values
        sheet("A1").Value = "Product"
        sheet("B1").Value = "Quantity"
        sheet("C1").Value = "Price"
        ' Add sample data rows
        sheet("A2").Value = "Laptop"
        sheet("B2").Value = 5
        sheet("C2").Value = 1299.99
        sheet("A3").Value = "Headphones"
        sheet("B3").Value = 15
        sheet("C3").Value = 199.5
        sheet("A4").Value = "Keyboard"
        sheet("B4").Value = 10
        sheet("C4").Value = 89.99
        sheet("A5").Value = "Monitor"
        sheet("B5").Value = 7
        sheet("C5").Value = 249.0
        ' Header formatting
        Dim headerRange = sheet("A1:C1")
        headerRange.Style.Font.Bold = True
        headerRange.Style.SetBackgroundColor("#4472C4")
        headerRange.Style.Font.Color = "#FFFFFF"
        headerRange.Style.BottomBorder.Type = BorderType.Thick
        ' Number formatting for currency
        sheet("C:C").FormatString = "$#,##0.00"
        ' Alternating row colors for readability
        For row As Integer = 2 To 10
            If row Mod 2 = 0 Then
                sheet($"A{row}:C{row}").Style.SetBackgroundColor("#F2F2F2")
            End If
        Next
        ' Column width adjustment
        sheet.Columns(0).Width = 15 * 256 ' Width in 1/256th of character width
        sheet.Columns(2).Width = 12 * 256
        ' Add borders around data
        Dim dataRange = sheet("A1:C10")
        dataRange.Style.TopBorder.Type = BorderType.Thin
        dataRange.Style.RightBorder.Type = BorderType.Thin
        dataRange.Style.BottomBorder.Type = BorderType.Thin
        dataRange.Style.LeftBorder.Type = BorderType.Thin
        ' Save the workbook to a file
        workbook.SaveAs("MyWorkbook.xlsx")
    End Sub
End Module

Diese Formatierungsoptionen verwandeln einfache Daten in professionelle Berichte. Die Style-API deckt alles von Schriften und Farben bis hin zu Rändern und Ausrichtung ab und bietet vollständige Kontrolle über das Erscheinungsbild des Excel-Berichts. Für erweiterte Formatierungsanforderungen, erkunden Sie bedingte Formatierung, um wichtige Daten automatisch hervorzuheben.

So erstellen Sie Excel-Berichte in C# mit IronXL: Bild 3 – Formatierte Excel-Ausgabe

Verwendung von Formeln für dynamische Excel-Berichtrechnungen

Die Stärke von Excel liegt in seinen Formeln, und IronXL unterstützt vollständig die Erstellung von Excel-Formeln:

// Add formula for row totals
sheet["D1"].Value = "Total";
sheet["D2"].Formula = "=B2*C2";
// Copy formula down the column
for (int row = 3; row <= 10; row++)
{
    sheet[$"D{row}"].Formula = $"=B{row}*C{row}";
}
// Add summary formulas
sheet["A12"].Value = "Summary";
sheet["B12"].Formula = "=SUM(B2:B10)";
sheet["C12"].Formula = "=AVERAGE(C2:C10)";
sheet["D12"].Formula = "=SUM(D2:D10)";

// Add formula for row totals
sheet["D1"].Value = "Total";
sheet["D2"].Formula = "=B2*C2";
// Copy formula down the column
for (int row = 3; row <= 10; row++)
{
    sheet[$"D{row}"].Formula = $"=B{row}*C{row}";
}
// Add summary formulas
sheet["A12"].Value = "Summary";
sheet["B12"].Formula = "=SUM(B2:B10)";
sheet["C12"].Formula = "=AVERAGE(C2:C10)";
sheet["D12"].Formula = "=SUM(D2:D10)";

' Add formula for row totals
sheet("D1").Value = "Total"
sheet("D2").Formula = "=B2*C2"
' Copy formula down the column
For row As Integer = 3 To 10
    sheet($"D{row}").Formula = $"=B{row}*C{row}"
Next
' Add summary formulas
sheet("A12").Value = "Summary"
sheet("B12").Formula = "=SUM(B2:B10)"
sheet("C12").Formula = "=AVERAGE(C2:C10)"
sheet("D12").Formula = "=SUM(D2:D10)"

' Add formula for row totals
sheet("D1").Value = "Total"
sheet("D2").Formula = "=B2*C2"
' Copy formula down the column
For row As Integer = 3 To 10
    sheet($"D{row}").Formula = $"=B{row}*C{row}"
Next
' Add summary formulas
sheet("A12").Value = "Summary"
sheet("B12").Formula = "=SUM(B2:B10)"
sheet("C12").Formula = "=AVERAGE(C2:C10)"
sheet("D12").Formula = "=SUM(D2:D10)"

Die Formelunterstützung umfasst alle Standard-Excel-Funktionen wie SUM, AVERAGE, IF, VLOOKUP und weitere. IronXL behandelt automatisch Formelnabhängigkeiten und Berechnungsreihenfolge, wodurch die Erstellung von Excel-Berichten mit komplexen Berechnungen einfach wird. Erfahren Sie mehr über Mathematikfunktionen in IronXL.

So erstellen Sie Excel-Berichte in C# mit IronXL: Bild 4 – Beispielausgabe mit Formeln

Vorlagenbasierte Berichte

Für wiederkehrende Excel-Berichte oder standardisierte Arbeitsmappen unterstützt IronXL die vorlagenbasierte Erstellung, sodass Entwickler eine Excel-Datei aus einer Vorlage erstellen können, ohne sich mit Open XML SDK, rels-Dateien oder verschiedenen Ordnern auseinandersetzen zu müssen:

// Load existing template
Workbook templateBook = Workbook.Load("ReportTemplate.xlsx");
Worksheet templateSheet = templateBook.DefaultWorksheet;
// Find and replace template markers
foreach (var cell in templateSheet["A1:Z100"])
{
    if (cell.Text.Contains("{{CompanyName}}"))
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp");
    if (cell.Text.Contains("{{ReportDate}}"))
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"));
}
// Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx");

// Load existing template
Workbook templateBook = Workbook.Load("ReportTemplate.xlsx");
Worksheet templateSheet = templateBook.DefaultWorksheet;
// Find and replace template markers
foreach (var cell in templateSheet["A1:Z100"])
{
    if (cell.Text.Contains("{{CompanyName}}"))
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp");
    if (cell.Text.Contains("{{ReportDate}}"))
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"));
}
// Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx");

Imports System

' Load existing template
Dim templateBook As Workbook = Workbook.Load("ReportTemplate.xlsx")
Dim templateSheet As Worksheet = templateBook.DefaultWorksheet
' Find and replace template markers
For Each cell In templateSheet("A1:Z100")
    If cell.Text.Contains("{{CompanyName}}") Then
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp")
    End If
    If cell.Text.Contains("{{ReportDate}}") Then
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"))
    End If
Next
' Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx")

Imports System

' Load existing template
Dim templateBook As Workbook = Workbook.Load("ReportTemplate.xlsx")
Dim templateSheet As Worksheet = templateBook.DefaultWorksheet
' Find and replace template markers
For Each cell In templateSheet("A1:Z100")
    If cell.Text.Contains("{{CompanyName}}") Then
        cell.Value = cell.Text.Replace("{{CompanyName}}", "Acme Corp")
    End If
    If cell.Text.Contains("{{ReportDate}}") Then
        cell.Value = cell.Text.Replace("{{ReportDate}}", DateTime.Now.ToString("MMMM yyyy"))
    End If
Next
' Save as new report
templateBook.SaveAs($"Report_{DateTime.Now:yyyyMMdd}.xlsx")

Dieser Ansatz bewahrt eine einheitliche Formatierung bei der Aktualisierung dynamischer Inhalte, perfekt für monatliche Berichte oder standardisierte Dokumente.

So erstellen Sie Excel-Berichte in C# mit IronXL: Bild 5 – Die Berichtsvorlage im Vergleich zu unserer mit der Vorlage erstellten Excel-Datei

Best Practices und Troubleshooting

Beim Implementieren der Excel-Berichterstellung sollten Sie diese Tipps beachten:

Speichernutzung bei großen Dateien: Daten in Blöcken verarbeiten, anstatt ganze Datensätze zu laden ( Empfehlungen von Microsoft für große Excel-Dateien )
Probleme mit der Datumsformatierung: Verwenden Sie DateTime.ToOADate() für Excel-kompatible Datumsangaben ( Erläuterung des Excel-Datumssystems )
Fehler durch gesperrte Dateien: Excel-Objekte sollten immer ordnungsgemäß mit using Anweisungen oder neuen MemoryStream Ansätzen freigegeben werden.
Fehlende Stile: Bei einigen Stileigenschaften muss zuerst die Hintergrundfarbe eingestellt werden

Abschluss

IronXL verwandelt die Erstellung von Excel-Berichten von einem mühsamen manuellen Prozess in einen automatisierten, zuverlässigen Arbeitsablauf. Mit seiner intuitiven API, plattformübergreifenden Unterstützung und umfassendem Funktionsumfang können Entwickler professionelle Excel-Berichte in Minuten statt Stunden erstellen. Die Kombination aus einfacher Datenintegration, leistungsstarken Formatierungsoptionen und Formelsupport macht IronXL zu einem unverzichtbaren Werkzeug für jeden C#-Entwickler, der mit Excel-Berichten arbeitet. Für interessierte Entwickler bietet IronXL eine kostenlose Testversion und weitere Lizenzierungsoptionen für Unternehmen und Einzelpersonen.

Erster Schritt:

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

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.

...