Wie man eine Liste von Objekten zu Excel in C# exportiert

Warum ist das Exportieren von Listen in Excel-Dateien herausfordernd?

Bei herkömmlichen Methoden zum Export von Daten nach Excel wird häufig Microsoft Office Interop verwendet, was die Installation von Excel auf dem Server erfordert und zu Implementierungsproblemen führt. Die manuelle Zellen-für-Zelle-Befüllung mithilfe von Reflection ist zeitaufwendig und fehleranfällig. Die leistungsstarken Datenimportfunktionen von IronXL lösen diese Probleme durch intelligentes Mapping von Eigenschaften zwischen Datenquellen und Excel-Spaltenüberschriften, ohne dass MS Office oder komplexer Reflektionscode erforderlich ist.

Die Bibliothek behandelt die Typkonvertierung automatisch, unterstützt verschachtelte Objekte und bewahrt die Datenintegrität über verschiedene Formate wie CSV-Dateien und XLSX-Dateien. Für Entwickler, die mit C# Excel-Operationen ohne Interop arbeiten, ist IronXL ideal für moderne .NET-Projekte, die robuste Excel-Generierungs- und Datenimport-/Exportfunktionen benötigen. Die Bibliothek integriert sich nahtlos in .NET MAUI-Anwendungen und unterstützt die Bereitstellung auf den Cloud-Plattformen Azure und AWS .

Bei der Arbeit mit großen Datensätzen stoßen herkömmliche Methoden oft an ihre Grenzen hinsichtlich Speichermanagement und Leistungsfähigkeit. IronXL begegnet diesen Problemen mit optimierten internen Datenstrukturen, die die Konvertierung zwischen verschiedenen Tabellenkalkulationsformaten effizient handhaben und gleichzeitig hervorragende Leistungseigenschaften beibehalten.

Wie exportiert man einfache Listendaten nach Excel?

Der Einstieg mit IronXL erfordert nur minimale Einrichtung. Installieren Sie zuerst die Bibliothek über die NuGet Package Manager-Konsole:

Install-Package IronXL.Excel

Nach der Installation können Sie sofort mit der Erstellung von Excel-Tabellen aus Ihren C#-Datenstrukturen beginnen. Lassen Sie uns untersuchen, wie man Daten mithilfe eines Mitarbeitermodells exportiert:

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
    public DateTime HireDate { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Create sample data for Excel export
        var employees = new List<Employee>
        {
            new Employee { Id = 1, Name = "Alice Johnson", Department = "Engineering",
                           Salary = 95000, HireDate = new DateTime(2020, 3, 15) },
            new Employee { Id = 2, Name = "Bob Smith", Department = "Marketing",
                           Salary = 75000, HireDate = new DateTime(2021, 7, 1) },
            new Employee { Id = 3, Name = "Carol Williams", Department = "Engineering",
                           Salary = 105000, HireDate = new DateTime(2019, 11, 20) }
        };
        // Convert the list of employees to a DataTable
        DataTable dataTable = new DataTable();
        dataTable.Columns.Add("Id", typeof(int));
        dataTable.Columns.Add("Name", typeof(string));
        dataTable.Columns.Add("Department", typeof(string));
        dataTable.Columns.Add("Salary", typeof(decimal));
        dataTable.Columns.Add("HireDate", typeof(DateTime));
        foreach (var employee in employees)
        {
            dataTable.Rows.Add(employee.Id, employee.Name, employee.Department, employee.Salary, employee.HireDate);
        }
        // Export DataTable to Excel spreadsheet
        var workbook = new WorkBook();
        var worksheet = workbook.CreateWorkSheet("Employees");
        // Populate the worksheet
        for (int i = 0; i < dataTable.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dataTable.Columns[i].ColumnName); // Add column headers
        }
        for (int i = 0; i < dataTable.Rows.Count; i++)
        {
            for (int j = 0; j < dataTable.Columns.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, dataTable.Rows[i][j]); // Add data rows
            }
        }
        // Save as XLSX file
        workbook.SaveAs("EmployeeReport.xlsx");
    }
}

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
    public DateTime HireDate { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Create sample data for Excel export
        var employees = new List<Employee>
        {
            new Employee { Id = 1, Name = "Alice Johnson", Department = "Engineering",
                           Salary = 95000, HireDate = new DateTime(2020, 3, 15) },
            new Employee { Id = 2, Name = "Bob Smith", Department = "Marketing",
                           Salary = 75000, HireDate = new DateTime(2021, 7, 1) },
            new Employee { Id = 3, Name = "Carol Williams", Department = "Engineering",
                           Salary = 105000, HireDate = new DateTime(2019, 11, 20) }
        };
        // Convert the list of employees to a DataTable
        DataTable dataTable = new DataTable();
        dataTable.Columns.Add("Id", typeof(int));
        dataTable.Columns.Add("Name", typeof(string));
        dataTable.Columns.Add("Department", typeof(string));
        dataTable.Columns.Add("Salary", typeof(decimal));
        dataTable.Columns.Add("HireDate", typeof(DateTime));
        foreach (var employee in employees)
        {
            dataTable.Rows.Add(employee.Id, employee.Name, employee.Department, employee.Salary, employee.HireDate);
        }
        // Export DataTable to Excel spreadsheet
        var workbook = new WorkBook();
        var worksheet = workbook.CreateWorkSheet("Employees");
        // Populate the worksheet
        for (int i = 0; i < dataTable.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dataTable.Columns[i].ColumnName); // Add column headers
        }
        for (int i = 0; i < dataTable.Rows.Count; i++)
        {
            for (int j = 0; j < dataTable.Columns.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, dataTable.Rows[i][j]); // Add data rows
            }
        }
        // Save as XLSX file
        workbook.SaveAs("EmployeeReport.xlsx");
    }
}

Dieses Beispielcode zeigt, wie man Daten mit IronXL aus einer List<Employee> nach Excel exportiert. Zuerst wird die Mitarbeiterliste in eine DataTable umgewandelt, dann werden Spaltenüberschriften und Zeilen manuell in ein Arbeitsblatt geschrieben. IronXL verarbeitet Datentypen wie int, string und DateTime automatisch und gewährleistet so eine saubere Formatierung in der generierten Tabelle. Schließlich erzeugt die Excel-Speicherfunktion eine XLSX-Datei, die unter dem Namen EmployeeReport gespeichert wird. Dies bietet eine einfache und effiziente Möglichkeit, strukturierte C#-Daten in einen professionellen Excel-Bericht umzuwandeln.

Der oben dargestellte Ansatz stellt ein grundlegendes Muster dar, das auf komplexere Szenarien erweitert werden kann. Beispielsweise müssen Sie möglicherweise Datensätze und Datentabellen aus bestehenden Datenbankabfragen exportieren oder Excel-Daten aus externen Quellen importieren . IronXL bietet umfassende Methoden für beide Szenarien und ist somit ein vielseitiges Werkzeug für Datenaustauschvorgänge.

! Excel-Tabelle mit exportierten Mitarbeiterdaten und Spalten für ID, Name, Abteilung, Gehalt und Einstellungsdatum; zeigt 3 Beispiel-Mitarbeiterdatensätze mit korrekter Datenformatierung

Wie exportiert man komplexe Geschäftsobjekte?

Echte .NET-Anwendungen beinhalten oft komplexere Datenstrukturen. Bei verschachtelten Eigenschaften, berechneten Feldern oder hierarchischen Daten ist ein ausgefeilterer Ansatz erforderlich. IronXL eignet sich hervorragend für die Bewältigung dieser Szenarien und bietet robuste Unterstützung für die Arbeit mit Daten in verschiedenen Formaten. So exportieren Sie einen Produktbestand mit verschachtelten Eigenschaften:

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Product
{
    public string SKU { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastRestocked { get; set; }
    public decimal CalculatedValue => Price * StockLevel;
}
class Program
{
    static void Main(string[] args)
    {
        // Generate product inventory list for Excel export
        var products = new List<Product>
        {
            new Product
            {
                SKU = "TECH-001",
                ProductName = "Wireless Mouse",
                Category = "Electronics",
                Price = 29.99m,
                StockLevel = 150,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-5)
            },
            new Product
            {
                SKU = "TECH-002",
                ProductName = "Mechanical Keyboard",
                Category = "Electronics",
                Price = 89.99m,
                StockLevel = 75,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-12)
            },
            new Product
            {
                SKU = "OFF-001",
                ProductName = "Desk Organizer",
                Category = "Office Supplies",
                Price = 15.99m,
                StockLevel = 0,
                IsActive = false,
                LastRestocked = DateTime.Now.AddMonths(-1)
            }
        };
        // Create Excel workbook and import collection data
        var workbook = WorkBook.Create();
        var worksheet = workbook.CreateWorkSheet("Inventory");
        // Export generic list to Excel with headers
        var dataTable = new DataTable();
        dataTable.Columns.Add("SKU", typeof(string));
        dataTable.Columns.Add("ProductName", typeof(string));
        dataTable.Columns.Add("Category", typeof(string));
        dataTable.Columns.Add("Price", typeof(decimal));
        dataTable.Columns.Add("StockLevel", typeof(int));
        dataTable.Columns.Add("IsActive", typeof(bool));
        dataTable.Columns.Add("LastRestocked", typeof(DateTime));
        dataTable.Columns.Add("CalculatedValue", typeof(decimal));
        foreach (var product in products)
        {
            dataTable.Rows.Add(
                product.SKU,
                product.ProductName,
                product.Category,
                product.Price,
                product.StockLevel,
                product.IsActive,
                product.LastRestocked,
                product.CalculatedValue
            );
        }
        // With the following code:
        worksheet["A1"].Value = "SKU";
        worksheet["B1"].Value = "ProductName";
        worksheet["C1"].Value = "Category";
        worksheet["D1"].Value = "Price";
        worksheet["E1"].Value = "StockLevel";
        worksheet["F1"].Value = "IsActive";
        worksheet["G1"].Value = "LastRestocked";
        worksheet["H1"].Value = "CalculatedValue";
        int row = 2;
        foreach (DataRow dataRow in dataTable.Rows)
        {
            worksheet[$"A{row}"].Value = dataRow["SKU"];
            worksheet[$"B{row}"].Value = dataRow["ProductName"];
            worksheet[$"C{row}"].Value = dataRow["Category"];
            worksheet[$"D{row}"].Value = dataRow["Price"];
            worksheet[$"E{row}"].Value = dataRow["StockLevel"];
            worksheet[$"F{row}"].Value = dataRow["IsActive"];
            worksheet[$"G{row}"].Value = dataRow["LastRestocked"];
            worksheet[$"H{row}"].Value = dataRow["CalculatedValue"];
            row++;
        }
        // Auto-fit columns for optimal display
        for (int col = 0; col < 8; col++)
        {
            worksheet.AutoSizeColumn(col);
        }
        // Save as Excel XLSX format
        workbook.SaveAs("ProductInventory.xlsx");
    }
}

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Product
{
    public string SKU { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastRestocked { get; set; }
    public decimal CalculatedValue => Price * StockLevel;
}
class Program
{
    static void Main(string[] args)
    {
        // Generate product inventory list for Excel export
        var products = new List<Product>
        {
            new Product
            {
                SKU = "TECH-001",
                ProductName = "Wireless Mouse",
                Category = "Electronics",
                Price = 29.99m,
                StockLevel = 150,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-5)
            },
            new Product
            {
                SKU = "TECH-002",
                ProductName = "Mechanical Keyboard",
                Category = "Electronics",
                Price = 89.99m,
                StockLevel = 75,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-12)
            },
            new Product
            {
                SKU = "OFF-001",
                ProductName = "Desk Organizer",
                Category = "Office Supplies",
                Price = 15.99m,
                StockLevel = 0,
                IsActive = false,
                LastRestocked = DateTime.Now.AddMonths(-1)
            }
        };
        // Create Excel workbook and import collection data
        var workbook = WorkBook.Create();
        var worksheet = workbook.CreateWorkSheet("Inventory");
        // Export generic list to Excel with headers
        var dataTable = new DataTable();
        dataTable.Columns.Add("SKU", typeof(string));
        dataTable.Columns.Add("ProductName", typeof(string));
        dataTable.Columns.Add("Category", typeof(string));
        dataTable.Columns.Add("Price", typeof(decimal));
        dataTable.Columns.Add("StockLevel", typeof(int));
        dataTable.Columns.Add("IsActive", typeof(bool));
        dataTable.Columns.Add("LastRestocked", typeof(DateTime));
        dataTable.Columns.Add("CalculatedValue", typeof(decimal));
        foreach (var product in products)
        {
            dataTable.Rows.Add(
                product.SKU,
                product.ProductName,
                product.Category,
                product.Price,
                product.StockLevel,
                product.IsActive,
                product.LastRestocked,
                product.CalculatedValue
            );
        }
        // With the following code:
        worksheet["A1"].Value = "SKU";
        worksheet["B1"].Value = "ProductName";
        worksheet["C1"].Value = "Category";
        worksheet["D1"].Value = "Price";
        worksheet["E1"].Value = "StockLevel";
        worksheet["F1"].Value = "IsActive";
        worksheet["G1"].Value = "LastRestocked";
        worksheet["H1"].Value = "CalculatedValue";
        int row = 2;
        foreach (DataRow dataRow in dataTable.Rows)
        {
            worksheet[$"A{row}"].Value = dataRow["SKU"];
            worksheet[$"B{row}"].Value = dataRow["ProductName"];
            worksheet[$"C{row}"].Value = dataRow["Category"];
            worksheet[$"D{row}"].Value = dataRow["Price"];
            worksheet[$"E{row}"].Value = dataRow["StockLevel"];
            worksheet[$"F{row}"].Value = dataRow["IsActive"];
            worksheet[$"G{row}"].Value = dataRow["LastRestocked"];
            worksheet[$"H{row}"].Value = dataRow["CalculatedValue"];
            row++;
        }
        // Auto-fit columns for optimal display
        for (int col = 0; col < 8; col++)
        {
            worksheet.AutoSizeColumn(col);
        }
        // Save as Excel XLSX format
        workbook.SaveAs("ProductInventory.xlsx");
    }
}

Dieser Code zeigt, wie man einen dynamischen Produktinventarbericht in Excel mit IronXL erstellt. Es erstellt eine Liste von Produktobjekten mit Details wie SKU, Preis, Lagerbestand und Wiederauffüllungsdatum und berechnet dann einen abgeleiteten CalculatedValue für jeden Artikel. Die Daten werden in eine DataTable konvertiert, in ein Excel-Arbeitsblatt mit Kopfzeilen geschrieben und zur besseren Lesbarkeit mit automatisch formatierten Spalten formatiert. IronXL verarbeitet nahtlos Datentypen wie Dezimalzahlen, boolesche Werte und Daten und sorgt für eine professionelle Tabellenkalkulation. Das Ergebnis, ProductInventory .xlsx , bietet einen übersichtlichen, datengesteuerten Bestandsexport, der sich ideal für Geschäftsberichte oder Analysen eignet.

Bei der Arbeit mit komplexen Objekten kann es auch erforderlich sein, Arbeitsblätter für verschiedene Datenkategorien zu verwalten oder mehrere Blätter innerhalb einer einzigen Arbeitsmappe zu erstellen . IronXL unterstützt erweiterte Tabellenfunktionen, sodass Sie Ihre exportierten Daten logisch organisieren können. Darüber hinaus können Sie bestimmte Bereiche für gezielte Datenoperationen auswählen oder Zellen sortieren, um Daten in einer sinnvollen Reihenfolge darzustellen.

Eine Excel-Tabelle zeigt den Produktbestandsexport mit Spalten für Artikelnummer (SKU), Produktname, Kategorie, Preis, Lagerbestand, Status "Aktiv", Datum der letzten Wiederauffüllung und berechneten Wert für verschiedene Elektronik- und Büroartikel.

Wie fügt man professionelle Formatierung hinzu?

Verwandeln Sie einfache Exporte mit den umfassenden Styling-Funktionen von IronXL in professionelle Berichte. Durch professionelle Formatierung werden Ihre Excel-Exporte von einfachen Datenimporten zu Managementberichten aufgewertet, die Erkenntnisse effektiv vermitteln. IronXL bietet umfangreiche Formatierungsoptionen, darunter die Anpassung von Schriftart und -größe in Zellen , Hintergrundmuster und -farben sowie Einstellungen für Rahmen und Ausrichtung :

// After importing data, apply professional formatting
var headerRange = worksheet["A1:H1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.Color = "#FFFFFF";
// Format currency columns for Excel export
var priceColumn = worksheet["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";
// Apply conditional formatting to highlight business metrics
for (int row = 2; row <= products.Count + 1; row++)
{
    var stockCell = worksheet[$"E{row}"];
    if (stockCell.IntValue < 10)
    {
        stockCell.Style.BackgroundColor = "#FF6B6B";
    }
}
// Export formatted list to Excel file
workbook.SaveAs("FormattedInventory.xlsx");

// After importing data, apply professional formatting
var headerRange = worksheet["A1:H1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.Color = "#FFFFFF";
// Format currency columns for Excel export
var priceColumn = worksheet["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";
// Apply conditional formatting to highlight business metrics
for (int row = 2; row <= products.Count + 1; row++)
{
    var stockCell = worksheet[$"E{row}"];
    if (stockCell.IntValue < 10)
    {
        stockCell.Style.BackgroundColor = "#FF6B6B";
    }
}
// Export formatted list to Excel file
workbook.SaveAs("FormattedInventory.xlsx");

Diese Styling-Optionen verwandeln rohe Datenexporte in berichtsfähige Berichte auf Führungsebene. Fettgedruckte Überschriften mit Hintergrundfarben schaffen visuelle Hierarchie beim Exportieren von Kollektionen nach Excel. Die Zahlenformatierung gewährleistet eine professionelle Darstellung der Währungswerte. Durch bedingte Formatierung werden wichtige Geschäftskennzahlen wie niedrige Lagerbestände hervorgehoben, sodass die exportierte Excel-Tabelle sofort für das Bestandsmanagement genutzt werden kann. Erfahren Sie mehr über erweiterte Zellformatierungen und Rahmenstile, um Ihre Exporte weiter zu optimieren.

Neben der grundlegenden Formatierung unterstützt IronXL auch erweiterte Funktionen wie das Erstellen von Excel-Diagrammen zur Visualisierung Ihrer exportierten Daten. Sie können außerdem Hyperlinks hinzufügen , um verwandte Datenpunkte oder externe Ressourcen zu verknüpfen, Bereiche fixieren , um die Navigation in großen Datensätzen zu erleichtern, und sogar Zellen zusammenführen, um anspruchsvolle Berichtslayouts zu erstellen.

! Excel-Inventartabelle mit professioneller Formatierung, die SKU, Produktname, Kategorie, Preis, Lagerbestand (mit bedingter Formatierung, wobei Nullbestände rot hervorgehoben werden), Status "Aktiv", Datum der letzten Wiederauffüllung und Spalten für berechnete Werte anzeigt.

Wie fange ich am besten mit IronXL an?

IronXL verwandelt die komplexe Aufgabe der Excel-Erzeugung in einfachen, wartbaren Code. Die intelligente ImportData-Methode macht Abhängigkeiten von Microsoft Office überflüssig und liefert professionelle Ergebnisse, die den Anforderungen von Unternehmen entsprechen. Das umfassende Funktionsspektrum der Bibliothek bewältigt alles von einfachen Listenexporten bis hin zu komplexen Datenumwandlungen mit Styling und Formatierung.

Der Einstieg in IronXL ist unkompliziert. Die Bibliothek unterstützt verschiedene Bereitstellungsszenarien, darunter Docker-Container , Linux-Umgebungen und macOS-Systeme . Für den Einsatz in Unternehmen bietet IronXL umfassende Lizenzierungsoptionen mit flexibler Lizenzschlüsselverwaltung .

Die Bibliothek zeichnet sich auch durch hervorragende Leistungen im Bereich des Datenaustauschs aus. Sie können XLSX in CSV konvertieren , CSV-Dateien schreiben , CSV-Daten lesen und sogar DataTables in das CSV-Format konvertieren . Für Webanwendungen lässt sich IronXL nahtlos in die Frameworks ASP.NET MVC und Blazor integrieren.

Bei der Arbeit mit bestehenden Excel-Dateien bietet IronXL leistungsstarke Funktionen zum Bearbeiten von Excel-Dateien , zum Öffnen von Arbeitsblättern und zum Lesen von XLSX-Dateien . Sie können auch mit VB.NET Excel-Dateien arbeiten, wenn Ihr Projekt eine Visual Basic-Integration erfordert.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten

Bereit, Ihre C# Excel-Exports zu vereinfachen? Laden Sie IronXL jetzt herunter, das sich mit Ihren Bedürfnissen skaliert. In unserer ausführlichen Dokumentation finden Sie weitere Anleitungen und Beispiele. In der API-Referenz finden Sie detaillierte technische Spezifikationen. Entdecken Sie außerdem, wie IronXL Ihre Excel-Automatisierungs-Workflows verändern kann.