Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronXL
  2. IronXL Blog
  3. IronXL verwenden
  4. C# Listenobjekt nach Excel exportieren
IRONXL VERWENDEN

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

Jordi Bardia
Jordi Bardia
Veröffentlicht:

Das Exportieren von Objektkollektionen in Excel-Dateien ist eine grundlegende Anforderung in Geschäftsanwendungen. Ob bei der Erstellung von Berichten, dem Exportieren von Daten zum Teilen von Erkenntnissen oder der Erstellung von Excel-Arbeitsblättern für Backups, Entwickler benötigen eine zuverlässige Möglichkeit, List<T> Objekte in professionelle Tabellenkalkulationen umzuwandeln. IronXL bietet eine optimierte Lösung, die die traditionellen Komplexitäten bei der Erstellung von Excel-Dateien in .NET, .NET Core oder dem .NET Framework eliminiert.

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

Traditionelle Ansätze zum Exportieren von Daten nach Excel beinhalten oft Microsoft Office Interop, das die Installation von MS Excel auf dem Server erfordert und zu Bereitstellungsschwierigkeiten führt. Die manuelle Zellen-für-Zelle-Befüllung mithilfe von Reflection ist zeitaufwendig und fehleranfällig. IronXLs leistungsstarke Datenimportfunktionen lösen diese Probleme mit intelligenter Eigenschaftszuordnung zwischen Datenquellen und Excel-Spaltenüberschriften, ohne dass MS Office oder komplexer Reflection-Code 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 C# Excel-Operationen ohne Interop durchführen, ist IronXL die ideale Wahl für moderne .NET-Projekte, die robuste Excel-Erzeugung und Datenimport-/export-Fähigkeiten benötigen.

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

Im folgenden Codebeispiel erkunden wir, wie Sie Daten mit einem Employee-Modell exportieren können:

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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieses Beispielcode zeigt, wie man Daten mit IronXL aus einer List<Employee> nach Excel exportiert. Es konvertiert zuerst die Mitarbeiterliste in eine DataTable und schreibt dann manuell Spaltenüberschriften und Zeilen in ein Arbeitsblatt. IronXL behandelt Datentypen wie int, string und DateTime automatisch und sorgt für saubere Formatierung in der erzeugten Tabellenkalkulation. Schließlich erzeugt die Excel-Speicherfunktion eine XLSX-Datei, die als EmployeeReport.xlsx gespeichert werden kann, um eine einfache und effiziente Möglichkeit zu bieten, strukturierte C#-Daten in einen professionellen Excel-Bericht zu verwandeln.

Wie exportiert man eine Liste von Objekten nach Excel in C#: Abbildung 1

Wie exportiert man komplexe Geschäftsobjekte?

Echte .NET-Anwendungen beinhalten oft komplexere Datenstrukturen. Hier ist, wie man ein Produktinventar mit verschachtelten Eigenschaften exportiert, durch C# Exportliste von Objekten nach Excel:

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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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 Nachlieferdatum und berechnet dann einen abgeleiteten CalculatedValue für jeden Artikel. Die Daten werden in eine DataTable konvertiert, in ein Excel-Arbeitsblatt mit Überschriften geschrieben und für die Lesbarkeit mithilfe von autosizing columns formatiert. IronXL verarbeitet nahtlos Datentypen wie Dezimalzahlen, boolesche Werte und Daten und sorgt für eine professionelle Tabellenkalkulation. Das Ergebnis, ProductInventory.xlsx, bietet einen sauberen, datenorientierten Inventarexport, ideal für Geschäftsberichte oder Analysen.

Wie exportiert man eine Liste von Objekten nach Excel in C#: Abbildung 2 - Beispielausgabe für komplexe Geschäftsobjekte

Wie fügt man professionelle Formatierung hinzu?

Verwandeln Sie grundlegende Exporte in ansprechende Berichte mit IronXLs umfassenden Styling-Fähigkeiten:

// 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");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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. Zahlenformatierung stellt sicher, dass Währungswerte professionell angezeigt werden. Bedingte Formatierung hebt wichtige Geschäftsmetriken hervor, wie niedrige Lagerbestände, und macht die exportierte Excel-Tabelle unmittelbar für das Bestandsmanagement umsetzbar. Learn more about advanced cell formatting and border styles to enhance your exports further.

Wie exportiert man eine Liste von Objekten nach Excel in C#: Abbildung 3 - Formatiertes Arbeitsblatt

Beginnen Sie noch heute mit dem Exportieren von Listen nach Excel

IronXL verwandelt die komplexe Aufgabe der Excel-Erzeugung in einfachen, wartbaren Code. Seine intelligente ImportData-Methode eliminiert die Notwendigkeit von Microsoft Office-Abhängigkeiten und liefert gleichzeitig 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.

Starten Sie jetzt mit IronXL.
green arrow pointer

Bereit, Ihre C# Excel-Exports zu vereinfachen? Laden Sie IronXL jetzt herunter, das sich mit Ihren Bedürfnissen skaliert. Besuchen Sie unsere umfassende Dokumentation für weitere Tutorials und Beispiele.

Häufig gestellte Fragen

Was ist die Hauptfunktion von IronXL?

IronXL bietet eine optimierte Lösung zum Exportieren von Objektsammlungen, wie List, in Excel-Dateien in .NET-Umgebungen, ohne die Komplexitäten traditioneller Methoden.

Wie vereinfacht IronXL das Exportieren von Daten nach Excel?

IronXL vereinfacht den Prozess, indem es eine ImportData-Methode anbietet, mit der Entwickler C#-Listen und komplexe Objekte problemlos in professionelle Excel-Tabellen umwandeln können, ohne Office Interop zu benötigen.

Kann IronXL mit .NET Core verwendet werden?

Ja, IronXL ist mit .NET Core sowie .NET und dem .NET Framework kompatibel und somit vielseitig für verschiedene Entwicklungsumgebungen einsetzbar.

Ist Office Interop erforderlich, wenn man IronXL verwendet?

Nein, IronXL erfordert kein Office Interop, was den Prozess vereinfacht und Abhängigkeiten beim Exportieren von Daten nach Excel reduziert.

Welche Arten von C#-Listen können mit IronXL exportiert werden?

IronXL kann sowohl generische Listen als auch komplexe Objekte nach Excel exportieren und bietet flexible Optionen für Entwickler, die verschiedene Datenstrukturen handhaben.

Warum ist der Export von Daten nach Excel für Geschäftsanwendungen wichtig?

Das Exportieren von Daten nach Excel ist entscheidend für die Erstellung von Berichten, das Teilen von Erkenntnissen und das Erstellen von Backups, die alle für effektive Geschäftsabläufe und Entscheidungsfindung grundlegend sind.

Unterstützt IronXL das Erstellen professioneller Tabellen?

Ja, IronXL ist darauf ausgelegt, C#-Listen in professionelle Excel-Tabellen von hoher Qualität zu verwandeln, die für Geschäftsberichte und Datenanalysen geeignet sind.

Welchen Vorteil bietet IronXL gegenüber herkömmlichen Methoden zur Erstellung von Excel-Dateien?

IronXL beseitigt traditionelle Komplexitäten und Abhängigkeiten bei der Erstellung von Excel-Dateien und bietet einen effizienteren und zuverlässigeren Ansatz für Entwickler.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion