Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. C# Exporter un objet de la liste vers Excel
UTILISATION D'IRONXL

Comment exporter une liste d'objets vers Excel en C#

Jordi Bardia
Jordi Bardia
Publié:

L'exportation de collections d'objets vers des fichiers Excel est une exigence fondamentale dans les applications d'entreprise. Que ce soit pour générer des rapports, exporter des données pour partager des informations ou créer des feuilles de calcul Excel pour des sauvegardes, les développeurs ont besoin d'une méthode fiable pour transformer des objets List en tableaux professionnels. IronXL offre une solution simplifiée qui élimine les complexités traditionnelles liées à la création de fichiers Excel sous .NET, .NET Core ou .NET Framework.

Pourquoi l'exportation de listes vers des fichiers Excel est-elle complexe ?

Les méthodes traditionnelles d'exportation de données vers Excel impliquent souvent Microsoft Office Interop, ce qui nécessite l'installation de MS Excel sur le serveur et engendre des difficultés de déploiement. Le peuplement manuel cellule par cellule par réflexion est long et sujet aux erreurs. Les puissantes fonctionnalités d'importation de données d'IronXL résolvent ces problèmes grâce à un mappage intelligent des propriétés entre les sources de données et les en-têtes de colonnes Excel, sans nécessiter MS Office ni code de réflexion complexe.

La bibliothèque gère automatiquement la conversion de type, prend en charge les objets imbriqués et maintient l'intégrité des données dans différents formats tels que les fichiers CSV et XLSX. Pour les développeurs travaillant avec des opérations Excel en C# sans interopérabilité , IronXL est le choix idéal pour les projets .NET modernes nécessitant des capacités robustes de génération Excel et d'importation/exportation de données.

Comment exporter des données de liste simples vers Excel ?

Commencer avec IronXL nécessite une configuration minimale. Tout d'abord, installez la bibliothèque via la console du Gestionnaire de packages NuGet :

Install-Package IronXL.Excel

Dans l'exemple de code suivant, nous verrons comment exporter des données à l'aide d'un modèle Employee :

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

Cet exemple de code montre comment exporter des données d'une List<Employee> vers Excel. List<Employee> utilisation d'IronXL. Il convertit d'abord la liste des employés en un DataTable, puis inscrit manuellement les en-têtes de colonnes et les lignes dans une feuille de calcul. IronXL gère automatiquement les types de données tels que int, string et DateTime, garantissant ainsi une mise en forme propre dans la feuille de calcul générée. Enfin, la fonction d'enregistrement Excel produit un fichier XLSX, qui peut être enregistré sous le nom EmployeeReport.xlsx , offrant ainsi un moyen simple et efficace de transformer des données C# structurées en un rapport Excel professionnel.

Comment exporter une liste d'objets vers Excel en C# : Figure 1

Comment exporter des objets métier complexes ?

Les applications .NET du monde réel impliquent souvent des structures de données plus complexes. Voici comment exporter un inventaire de produits avec des propriétés imbriquées, en utilisant la fonction C# d'exportation de liste d'objets vers 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

Ce code montre comment générer un rapport d'inventaire de produits dynamique dans Excel à l'aide d'IronXL. Il crée une liste d'objets Produit contenant des détails tels que la référence, le prix, le niveau de stock et la date de réapprovisionnement, puis calcule une valeur calculée dérivée pour chaque article. Les données sont converties en un DataTable, écrites dans une feuille de calcul Excel avec des en-têtes et formatées pour une meilleure lisibilité grâce à des colonnes à taille automatique. IronXL gère parfaitement les types de données tels que les décimales, les booléens et les dates, garantissant ainsi des résultats de type tableur de qualité professionnelle. Le résultat, ProductInventory.xlsx , fournit une exportation d'inventaire propre et basée sur les données, idéale pour les rapports ou analyses d'entreprise.

Comment exporter une liste d'objets vers Excel en C# : Figure 2 - Exemple de sortie pour des objets métier complexes

Comment ajouter une mise en forme professionnelle ?

Transformez vos exportations de base en rapports soignés grâce aux fonctionnalités de mise en forme complètes d'IronXL :

// 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

Ces options de mise en forme transforment les données brutes exportées en rapports prêts à être présentés aux dirigeants. Les en-têtes en gras avec des couleurs de fond créent une hiérarchie visuelle lors de l'exportation des collections vers Excel. La mise en forme des nombres garantit un affichage professionnel des valeurs monétaires. La mise en forme conditionnelle met en évidence les indicateurs clés de performance de l'entreprise, tels que les faibles niveaux de stock, rendant ainsi la feuille de calcul Excel exportée immédiatement exploitable pour la gestion des stocks. Apprenez-en davantage sur la mise en forme avancée des cellules et les styles de bordure pour améliorer encore vos exportations.

Comment exporter une liste d'objets vers Excel en C# : Figure 3 - Feuille de calcul formatée

Commencez dès aujourd'hui à exporter vos listes vers Excel.

IronXL transforme la tâche complexe de génération de fichiers Excel en un code simple et facile à maintenir. Sa méthode intelligente ImportData élimine le besoin de dépendances à Microsoft Office tout en fournissant des résultats professionnels répondant aux exigences des entreprises. La bibliothèque offre un ensemble complet de fonctionnalités permettant de gérer toutes les opérations, des exportations de listes basiques aux transformations de données complexes avec mise en forme et style.

Commencez avec IronXL maintenant.
green arrow pointer

Prêt à optimiser vos exportations Excel C# ? Téléchargez IronXL dès maintenant et adaptez-le à vos besoins. Consultez notre documentation complète pour plus de tutoriels et d'exemples.

Questions Fréquemment Posées

Quelle est la fonction principale d'IronXL ?

IronXL fournit une solution simplifiée pour exporter des collections d'objets, telles que List, vers des fichiers Excel dans les environnements .NET sans les complexités des méthodes traditionnelles.

Comment IronXL simplifie-t-il l'exportation de données vers Excel ?

IronXL simplifie le processus en offrant une méthode ImportData, qui permet aux développeurs de transformer facilement des listes C# et des objets complexes en feuilles de calcul Excel professionnelles sans avoir besoin d'Office Interop.

IronXL peut-il être utilisé avec .NET Core ?

Oui, IronXL est compatible avec .NET Core, ainsi qu'avec .NET et le .NET Framework, ce qui le rend polyvalent pour divers environnements de développement.

Est-ce que l'Office Interop est requis lors de l'utilisation d'IronXL ?

Non, IronXL ne nécessite pas d'Office Interop, ce qui simplifie le processus et réduit les dépendances lors de l'exportation de données vers Excel.

Quels types de listes C# peuvent être exportés avec IronXL ?

IronXL peut exporter à la fois des listes génériques et des objets complexes vers Excel, offrant des options flexibles pour les développeurs traitant divers types de structures de données.

Pourquoi l'exportation vers Excel est-elle cruciale pour les applications commerciales ?

L'exportation de données vers Excel est cruciale pour générer des rapports, partager des informations et créer des sauvegardes, tous essentiels pour un fonctionnement et une prise de décision commerciaux efficaces.

IronXL prend-il en charge la création de feuilles de calcul professionnelles ?

Oui, IronXL est conçu pour transformer des listes C# en feuilles de calcul Excel de qualité professionnelle, adaptées aux rapports commerciaux et à l'analyse des données.

Quel avantage IronXL offre-t-il par rapport aux méthodes traditionnelles de création de fichiers Excel ?

IronXL élimine les complexités et dépendances traditionnelles impliquées dans la création de fichiers Excel, offrant une approche plus efficace et fiable pour les développeurs.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit