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

C# Exportieren Sie eine Liste von Objekten nach Excel mit IronXL

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 Objekte in professionelle Tabellenkalkulationen umzuwandeln. IronXL bietet eine optimierte Lösung, die die traditionelle Komplexität der Erstellung von Excel-Dateien in .NET, .NET Core oder dem .NET Framework beseitigt.

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. Die leistungsstarken Datenimportfunktionen von IronXL lösen diese Probleme mit intelligenter Eigenschaftszuordnung zwischen Datenquellen und Excel-Spaltenüberschriften, ohne dass MS Office oder komplexer Reflexionscode erforderlich sind.

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 die ideale Wahl für moderne .NET-Projekte, die robuste Excel-Generierungs- und Datenimport-/exportfunktionen 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
Install-Package IronXL.Excel
SHELL

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

using IronXL;
using System;
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;
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 zunächst die Mitarbeiterliste in eine DataTable und schreibt dann manuell Spaltenüberschriften und Zeilen in ein Arbeitsblatt. IronXL verarbeitet Datentypen wie int, string und DateTime automatisch und sorgt so für eine saubere Formatierung im generierten Arbeitsblatt. Schließlich erzeugt die Excel-Speicherfunktion eine XLSX-Datei, die als EmployeeReport.xlsx gespeichert werden kann und eine einfache und effiziente Möglichkeit bietet, strukturierte C#-Daten in einen professionellen Excel-Bericht zu verwandeln.

C# Export List of Objects to Excel with IronXL: Image 1 - Image 1 of 3 related to C# Export List of Objects to Excel with IronXL

Wie exportiert man komplexe Geschäftsobjekte?

Echte .NET-Anwendungen beinhalten oft komplexere Datenstrukturen. So exportieren Sie ein Produktinventar mit verschachtelten Eigenschaften, indem Sie C# verwenden, um eine Liste von Objekten nach Excel zu exportieren:

using IronXL;
using System;
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
            );
        }

        // Set header values
        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;
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
            );
        }

        // Set header values
        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 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 sauberen, datengesteuerten Inventarexport, der sich ideal für Geschäftsberichte oder Analysen eignet.

C# Export List of Objects to Excel with IronXL: Image 2 - Example output for complex business objects

Wie fügt man professionelle Formatierung hinzu?

Verwandeln Sie einfache Exporte in ausgefeilte Berichte mit IronXLs umfassenden Styling-Funktionen:

// 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 sorgt für eine professionelle Darstellung von Währungswerten. Bedingte Formatierung hebt wichtige Geschäftsmetriken hervor, wie niedrige Lagerbestände, und macht die exportierte Excel-Tabelle unmittelbar für das Bestandsmanagement umsetzbar. Erfahren Sie mehr über erweiterte Zellformatierung und border styles, um Ihre Exporte weiter zu verbessern.

C# Export List of Objects to Excel with IronXL: Image 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. 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.

Starten Sie jetzt mit IronXL.
green arrow pointer

Bereit, Ihre C# Excel-Exports zu vereinfachen? Laden Sie IronXL jetzt herunter und erleben Sie, wie einfach Sie Listenobjekte in Ihren .NET-Anwendungen in Excel konvertieren können. Für den produktiven Einsatz können Sie unsere flexiblen Lizenzierungsoptionen nutzen, die sich an Ihre Bedürfnisse anpassen. Besuchen Sie unsere umfassende Dokumentation für weitere Tutorials und Beispiele.

Häufig gestellte Fragen

Wie kann ich eine C#-Liste in eine Excel-Datei exportieren?

Sie können eine C#-Liste in eine Excel-Datei exportieren, indem Sie die ImportData-Methode von IronXL verwenden, die den Prozess vereinfacht, ohne Office Interop zu benötigen.

Warum sollte ich IronXL für den Export von Daten nach Excel verwenden?

IronXL bietet eine optimierte Lösung für den Export von Daten nach Excel, indem es herkömmliche Komplexitäten eliminiert und eine einfache Integration mit .NET, .NET Core oder dem .NET Framework bietet.

Muss ich Microsoft Office installiert haben, um IronXL zu verwenden?

Nein, IronXL erfordert keine Installation von Microsoft Office. Es arbeitet unabhängig und ermöglicht es Ihnen, Excel-Dateien programmatisch zu erstellen und zu bearbeiten.

Kann IronXL beim Exportieren nach Excel komplexe Objekte in Listen verarbeiten?

Ja, IronXL kann sowohl mit allgemeinen Listen als auch mit komplexen Objekten umgehen und bietet Flexibilität beim Export verschiedener Datentypen nach Excel.

Ist IronXL kompatibel mit .NET Core?

IronXL ist sowohl mit .NET Core als auch mit .NET und dem .NET Framework kompatibel und damit vielseitig für verschiedene Entwicklungsumgebungen einsetzbar.

Was ist der Vorteil der ImportData-Methode von IronXL?

Die ImportData-Methode in IronXL vereinfacht die Übertragung von Daten aus C#-Listen nach Excel, reduziert die Komplexität des Codes und verbessert die Produktivität.

Kann ich mit IronXL professionelle Tabellenkalkulationen erstellen?

Absolut, IronXL ermöglicht es Entwicklern, List-Objekte problemlos in professionelle Tabellen zu verwandeln, die sich für Berichte, Datenaustausch oder Backups eignen.

Gibt es Code-Beispiele für die Verwendung von IronXL?

Ja, die IronXL-Dokumentation und -Tutorials bieten einfache Code-Beispiele für den Export von allgemeinen Listen und komplexen Objekten nach Excel.

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. Gratis testen