Skip to footer content
  1. IronXL
  2. IronXL Blog
  3. Using IronXL
  4. C# Export List Object to Excel
USING IRONXL

How to Export a List of Objects to Excel in C#

Jordi Bardia
Jordi Bardia
Updated:

IronXL lets developers export Listobjects directly to Excel files in C# without MS Office dependencies, automatically handling type conversion and property mapping through simple ImportData methods that transform collections into professional XLSX spreadsheets.

Exporting collections of objects to Excel files is a fundamental requirement in business applications. Whether you're generating reports, sharing insights, or creating backups, you need a reliable way to transform List<T> objects into professional spreadsheets. IronXL provides a streamlined solution that eliminates the traditional complexities of creating Excel files in .NET, .NET Core, or the .NET Framework.

Why Is Exporting Lists to Excel Files Challenging?

Traditional approaches to export data to Excel often involve Microsoft Office Interop, which requires Excel installation on the server and creates deployment headaches. Manual cell-by-cell population using reflection is time-consuming and error-prone. IronXL's powerful data import features solve these problems with intelligent property mapping between data sources and Excel column headers, without requiring MS Office or complex reflection code.

The library handles type conversion automatically, supports nested objects, and maintains data integrity across different formats like CSV files and XLSX files. For developers working with C# Excel operations without Interop, IronXL is ideal for modern .NET projects that need robust Excel generation and data import/export capabilities. The library seamlessly integrates with .NET MAUI applications and supports deployment to Azure and AWS cloud platforms.

When working with large datasets, traditional methods often struggle with memory management and performance. IronXL addresses these concerns with optimized internal data structures that efficiently handle converting between different spreadsheet formats while maintaining excellent performance characteristics.

How to Export Simple List Data to Excel?

Getting started with IronXL requires minimal setup. First, install the library through the NuGet Package Manager Console:

Install-Package IronXL.Excel

Once installed, you can immediately begin creating Excel spreadsheets from your C# data structures. Let's explore how to export data using an Employee model:

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

This sample code demonstrates how to export data to Excel from a List<Employee> using IronXL. It first converts the employee list into a DataTable, then manually writes column headers and rows into a worksheet. IronXL handles data types like int, string, and DateTime automatically, ensuring clean formatting in the generated spreadsheet. Finally, the Excel save function produces an XLSX file saved as EmployeeReport.xlsx, providing a simple and efficient way to turn structured C# data into a professional Excel report.

The approach shown above represents a foundational pattern that can be extended for more complex scenarios. For instance, you might need to export datasets and datatables from existing database queries or import Excel data from external sources. IronXL provides comprehensive methods for both scenarios, making it a versatile tool for data interchange operations.

Excel spreadsheet displaying exported employee data with columns for Id, Name, Department, Salary, and HireDate, showing 3 sample employee records with proper data formatting

How to Export Complex Business Objects?

Real-world .NET applications often involve more complex data structures. When dealing with nested properties, calculated fields, or hierarchical data, you need a more sophisticated approach. IronXL excels at handling these scenarios, providing robust support for working with data in various formats. Here's how to export a product inventory with nested properties:

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

This code demonstrates how to generate a dynamic product inventory report in Excel using IronXL. It builds a list of Product objects containing details like SKU, price, stock level, and restock date, then calculates a derived CalculatedValue for each item. The data is converted into a DataTable, written to an Excel worksheet with headers, and formatted for readability using auto-sized columns. IronXL seamlessly handles data types such as decimals, booleans, and dates, ensuring professional spreadsheet output. The result, ProductInventory.xlsx, provides a clean, data-driven inventory export ideal for business reporting or analytics.

When working with complex objects, you might also need to manage worksheets for different data categories or create multiple sheets within a single workbook. IronXL supports advanced worksheet operations, allowing you to organize your exported data logically. Additionally, you can select specific ranges for targeted data operations or sort cells to present data in a meaningful order.

Excel spreadsheet displaying product inventory export with columns for SKU, ProductName, Category, Price, StockLevel, IsActive status, LastRestocked date, and CalculatedValue showing various electronics and office supplies

How to Add Professional Formatting?

Transform basic exports into polished reports with IronXL's comprehensive styling capabilities. Professional formatting elevates your Excel exports from simple data dumps to executive-ready reports that communicate insights effectively. IronXL provides extensive formatting options including cell font and size customization, background patterns and colors, and border and alignment settings:

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

These styling options transform raw data exports into executive-ready reports. Bold headers with background colors create visual hierarchy when exporting collections to Excel. Number formatting ensures currency values display professionally. Conditional formatting highlights critical business metrics, such as low stock levels, making the exported Excel spreadsheet immediately actionable for inventory management. Learn more about advanced cell formatting and border styles to enhance your exports further.

Beyond basic formatting, IronXL supports advanced features like creating Excel charts to visualize your exported data. You can also add hyperlinks to connect related data points or external resources, freeze panes for better navigation of large datasets, and even merge cells for creating sophisticated report layouts.

Excel inventory spreadsheet with professional formatting showing SKU, ProductName, Category, Price, StockLevel with conditional formatting highlighting zero stock in red, IsActive status, LastRestocked dates, and CalculatedValue columns

What's the Best Way to Get Started with IronXL?

IronXL transforms the complex task of Excel generation into simple, maintainable code. Its intelligent ImportData method eliminates the need for Microsoft Office dependencies while providing professional results that meet enterprise requirements. The library's comprehensive feature set handles everything from basic list exports to complex data transformations with styling and formatting.

Getting started with IronXL is straightforward. The library supports various deployment scenarios including Docker containers, Linux environments, and macOS systems. For enterprise deployments, IronXL provides comprehensive licensing options with flexible license key management.

The library also excels at data interchange operations. You can convert XLSX to CSV, write CSV files, read CSV data, and even convert DataTables to CSV format. For web applications, IronXL integrates seamlessly with ASP.NET MVC and Blazor frameworks.

When working with existing Excel files, IronXL provides powerful features to edit Excel files, open worksheets, and read XLSX files. You can also work with VB.NET Excel files if your project requires Visual Basic integration.

Get stated with IronXL now.
green arrow pointer

Ready to streamline your C# Excel exports? Download IronXL now that scale with your needs. Visit our comprehensive documentation for more tutorials and examples. Explore the API reference for detailed technical specifications and discover how IronXL can transform your Excel automation workflows.

Frequently Asked Questions

What is the primary function of IronXL?

IronXL provides a streamlined solution for exporting collections of objects, such as List, to Excel files in .NET environments without the complexities of traditional methods.

How does IronXL simplify exporting data to Excel?

IronXL simplifies the process by offering an ImportData method, which allows developers to easily transform C# lists and complex objects into professional Excel spreadsheets without needing Office Interop.

Can IronXL be used with .NET Core?

Yes, IronXL is compatible with .NET Core, as well as .NET and the .NET Framework, making it versatile for various development environments.

Is Office Interop required when using IronXL?

No, IronXL does not require Office Interop, which simplifies the process and reduces dependencies when exporting data to Excel.

What types of C# lists can be exported using IronXL?

IronXL can export both generic lists and complex objects to Excel, providing flexible options for developers handling various data structures.

Why is exporting data to Excel important for business applications?

Exporting data to Excel is crucial for generating reports, sharing insights, and creating backups, all of which are fundamental for effective business operations and decision-making.

Does IronXL support creating professional spreadsheets?

Yes, IronXL is designed to transform C# lists into professional-quality Excel spreadsheets, suitable for business reporting and data analysis.

What benefit does IronXL provide over traditional Excel file creation methods?

IronXL eliminates traditional complexities and dependencies involved in creating Excel files, offering a more efficient and reliable approach for developers.

Jordi Bardia
Jordi Bardia
  Chat with engineering team now
Software Engineer
Jordi is most proficient in Python, C# and C++, when he isn’t leveraging his skills at Iron Software; he’s game programming. Sharing responsibilities for product testing, product development and research, Jordi adds immense value to continual product improvement. The varied experience keeps him challenged and engaged, and he ...
Read More

Related Articles

30-day trial → Full product. No limits. No card. Start Free Trial