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

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 d'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 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. La bibliothèque s'intègre parfaitement aux applications .NET MAUI et prend en charge le déploiement sur les plateformes cloud Azure et AWS .

Lorsqu'on travaille avec de grands ensembles de données, les méthodes traditionnelles rencontrent souvent des difficultés en matière de gestion de la mémoire et de performances. IronXL répond à ces préoccupations grâce à des structures de données internes optimisées qui gèrent efficacement la conversion entre différents formats de feuilles de calcul tout en conservant d'excellentes performances.

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

Une fois installé, vous pouvez immédiatement commencer à créer des feuilles de calcul Excel à partir de vos structures de données C#. Voyons 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");
    }
}

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 écrit 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 enregistré sous le nom EmployeeReport , offrant ainsi un moyen simple et efficace de transformer des données C# structurées en un rapport Excel professionnel.

L'approche présentée ci-dessus constitue un modèle de base qui peut être étendu à des scénarios plus complexes. Par exemple, vous pourriez avoir besoin d' exporter des ensembles de données et des tables de données à partir de requêtes de bases de données existantes ou d'importer des données Excel à partir de sources externes. IronXL propose des méthodes complètes pour les deux scénarios, ce qui en fait un outil polyvalent pour les opérations d'échange de données.

Feuille de calcul Excel affichant les données exportées des employés avec des colonnes pour l'identifiant, le nom, le département, le salaire et la date d'embauche, montrant 3 exemples d'enregistrements d'employés avec une mise en forme correcte des données.

Comment exporter des objets métier complexes ?

Les applications .NET du monde réel impliquent souvent des structures de données plus complexes. Lorsque vous traitez des propriétés imbriquées, des champs calculés ou des données hiérarchiques, une approche plus sophistiquée est nécessaire. IronXL excelle dans la gestion de ces scénarios, offrant une prise en charge robuste du traitement des données dans différents formats. Voici comment exporter un inventaire de produits avec des propriétés imbriquées :

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");
    }
}

Ce code montre comment générer un rapport d'inventaire de produits dynamique dans Excel à l'aide d'IronXL. Il construit une liste d'objets Product contenant des détails tels que le SKU, le prix, le niveau de stock et la date de réapprovisionnement, puis calcule une CalculatedValue dérivée pour chaque article. Les données sont converties en DataTable, écrites dans une feuille de calcul Excel avec des en-têtes, et formatées pour la lisibilité en utilisant des colonnes de 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 , fournit une exportation d'inventaire propre et basée sur les données, idéale pour les rapports ou analyses d'entreprise.

Lorsque vous travaillez avec des objets complexes, vous pouvez également avoir besoin de gérer des feuilles de calcul pour différentes catégories de données ou de créer plusieurs feuilles dans un seul classeur. IronXL prend en charge les opérations avancées sur les feuilles de calcul, vous permettant d'organiser vos données exportées de manière logique. De plus, vous pouvez sélectionner des plages spécifiques pour des opérations de données ciblées ou trier les cellules pour présenter les données dans un ordre logique.

Feuille de calcul Excel affichant l'exportation de l'inventaire des produits avec des colonnes pour la référence (SKU), le nom du produit, la catégorie, le prix, le niveau de stock, le statut " Actif ", la date du dernier réapprovisionnement et la valeur calculée, présentant divers produits électroniques et fournitures de bureau.

Comment ajouter une mise en forme professionnelle ?

Transformez vos exportations de base en rapports soignés grâce aux fonctionnalités de style complètes d'IronXL . La mise en forme professionnelle transforme vos exportations Excel, qui ne sont plus de simples extractions de données, en rapports prêts à être présentés à la direction et qui communiquent efficacement les informations clés. IronXL offre de nombreuses options de mise en forme, notamment la personnalisation de la police et de la taille des cellules , les motifs et les couleurs d'arrière-plan , ainsi que les paramètres de bordure et d'alignement :

// 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");

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.

Au-delà de la mise en forme de base, IronXL prend en charge des fonctionnalités avancées telles que la création de graphiques Excel pour visualiser vos données exportées. Vous pouvez également ajouter des hyperliens pour connecter des points de données connexes ou des ressources externes, figer des volets pour une meilleure navigation dans de grands ensembles de données, et même fusionner des cellules pour créer des mises en page de rapports sophistiquées.

Modèle Excel d'inventaire avec mise en forme professionnelle affichant les colonnes SKU, Nom du produit, Catégorie, Prix, Niveau de stock (avec mise en forme conditionnelle indiquant un stock nul en rouge), Statut Actif, Date de dernier réapprovisionnement et Valeur calculée

Quelle est la meilleure façon de débuter avec IronXL ?

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 qui répondent aux exigences de l'entreprise. 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.

La prise en main d'IronXL est simple. La bibliothèque prend en charge différents scénarios de déploiement, notamment les conteneurs Docker , les environnements Linux et les systèmes macOS . Pour les déploiements en entreprise, IronXL propose des options de licence complètes avec une gestion flexible des clés de licence .

La bibliothèque excelle également dans les opérations d'échange de données. Vous pouvez convertir des fichiers XLSX en CSV , écrire des fichiers CSV , lire des données CSV et même convertir des DataTables au format CSV . Pour les applications web, IronXL s'intègre parfaitement aux frameworks ASP.NET MVC et Blazor .

Lors de la manipulation de fichiers Excel existants, IronXL offre des fonctionnalités puissantes pour modifier les fichiers Excel , ouvrir les feuilles de calcul et lire les fichiers XLSX . Vous pouvez également travailler avec des fichiers Excel VB.NET si votre projet nécessite une intégration Visual Basic.

Commencez avec IronXL maintenant.

Commencer gratuitement

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. Consultez la documentation de l'API pour obtenir des spécifications techniques détaillées et découvrez comment IronXL peut transformer vos flux de travail d'automatisation Excel.