How to Easily Import, Read, and Manipulate MS Excel File Data in C# Using IronXL

How Do I Get Started with C# Import Excel Data?

Getting started with Excel import in C# takes just minutes with IronXL. The Excel library handles both legacy XLS and modern XLSX formats seamlessly, along with CSV, TSV, and other spreadsheet formats. Unlike solutions that rely on Microsoft.Office.Interop.Excel, IronXL runs independently on any .NET or .NET Core platform.

First, install IronXL via NuGet Package Manager or select Manage NuGet packages in Visual Studio:

Install-Package IronXL.Excel

Once installed, importing Excel data becomes remarkably simple:

using IronXL;
static void Main(string[] args)
{
 // Load any Excel file
 WorkBook workBook = WorkBook.Load("ProductData.xlsx");
 // Access the first worksheet
 WorkSheet sheet = workBook.WorkSheets[0];
 // Read a cell value
 string value = sheet["B1"].StringValue;
 Console.WriteLine(value);
}

using IronXL;
static void Main(string[] args)
{
 // Load any Excel file
 WorkBook workBook = WorkBook.Load("ProductData.xlsx");
 // Access the first worksheet
 WorkSheet sheet = workBook.WorkSheets[0];
 // Read a cell value
 string value = sheet["B1"].StringValue;
 Console.WriteLine(value);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

This code demonstrates the core workflow: loading a workbook, accessing a worksheet, and reading cell values. The WorkBook.Load() method automatically detects the file format, whether it's XLS, XLSX, or even CSV. The intuitive indexer syntax sheet["B1"] makes accessing cells as natural as working with arrays. For more complex operations, check the IronXL API reference for comprehensive documentation.

How Can I Read Excel Data into C# Objects?

Real applications need more than single-cell values. IronXL excels at importing entire datasets and converting them into usable C# objects. When you need to import Excel files with structured data, the library provides multiple approaches.

// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Read a range of cells
 var products = new List<Product>();
 foreach (var row in sheet.Rows)
 {
     var product = new Product
     {
         Id = row.Columns[0].IntValue,
         Name = row.Columns[1].StringValue,
         Price = row.Columns[2].DecimalValue,
         IsAvailable = row.Columns[3].BoolValue
     };
     products.Add(product);
 }
 foreach (var product in products)
 {
     Console.WriteLine($"Id: {product.Id}, Name: {product.Name}, Price: {product.Price}, Available: {product.IsAvailable}");
 }

// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Read a range of cells
 var products = new List<Product>();
 foreach (var row in sheet.Rows)
 {
     var product = new Product
     {
         Id = row.Columns[0].IntValue,
         Name = row.Columns[1].StringValue,
         Price = row.Columns[2].DecimalValue,
         IsAvailable = row.Columns[3].BoolValue
     };
     products.Add(product);
 }
 foreach (var product in products)
 {
     Console.WriteLine($"Id: {product.Id}, Name: {product.Name}, Price: {product.Price}, Available: {product.IsAvailable}");
 }

IRON VB CONVERTER ERROR developers@ironsoftware.com

This example shows how to iterate through rows and map Excel data to strongly-typed C# objects. The typed properties like IntValue, StringValue, and DecimalValue handle type conversion automatically. This approach eliminates manual parsing and reduces errors when working with different data types. Many developers on Stack Overflow appreciate this type-safe approach to Excel data import.

// Read specific ranges of ProductData.xlsx file
Range dataRange = sheet["A1:D5"];
// Calculate aggregates directly
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");
decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");
// Use LINQ for filtering
var highValueOrders = dataRange
    .Where(cell => cell.DecimalValue > 100)
    .Select(cell => cell.Value)
    .ToList();
Console.WriteLine("High value orders (>100):");
// Print the high value orders to the console
foreach (var order in highValueOrders)
{
    Console.WriteLine(order);
}

// Read specific ranges of ProductData.xlsx file
Range dataRange = sheet["A1:D5"];
// Calculate aggregates directly
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");
decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");
// Use LINQ for filtering
var highValueOrders = dataRange
    .Where(cell => cell.DecimalValue > 100)
    .Select(cell => cell.Value)
    .ToList();
Console.WriteLine("High value orders (>100):");
// Print the high value orders to the console
foreach (var order in highValueOrders)
{
    Console.WriteLine(order);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

How Do I Convert Excel to DataTable?

DataTable conversion is essential for database operations and data binding scenarios. IronXL provides built-in methods that efficiently handle the conversion from Excel to DataTable.This feature is particularly useful when you need to import Excel spreadsheets into SQL Server or other databases.

using System.Data;
// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select first Excel worksheet
WorkSheet sheet = workBook.WorkSheets.First();
// Convert to DataTable with headers
DataTable dataTable = sheet.ToDataTable(true);
// The DataTable is ready for database operations
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
    bulkCopy.DestinationTableName = "Inventory";
    bulkCopy.WriteToServer(dataTable);
}

using System.Data;
// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select first Excel worksheet
WorkSheet sheet = workBook.WorkSheets.First();
// Convert to DataTable with headers
DataTable dataTable = sheet.ToDataTable(true);
// The DataTable is ready for database operations
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
    bulkCopy.DestinationTableName = "Inventory";
    bulkCopy.WriteToServer(dataTable);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

The ToDataTable() method accepts a boolean parameter indicating whether the first row contains headers. When set to true, IronXL automatically uses the first row values as column names in the DataTable. This DataTable integrates seamlessly with ADO.NET operations, Entity Framework, and data binding controls. Microsoft's documentation on SqlBulkCopy shows how efficiently this pattern handles large-scale data imports.

For more control over the conversion process:

// Custom DataTable conversion
DataTable customTable = new DataTable();
// Define columns based on Excel structure
for (int col = 0; col < sheet.ColumnCount; col++)
{
    customTable.Columns.Add($"Column{col + 1}", typeof(string));
}
// Import data with validation
foreach (var row in sheet.Rows)
{
    var dataRow = customTable.NewRow();
    for (int col = 0; col < sheet.ColumnCount; col++)
    {
        dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
    }
    customTable.Rows.Add(dataRow);
}
// Print column headers
foreach (DataColumn column in customTable.Columns)
{
    Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();
// Print each row
foreach (DataRow row in customTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

// Custom DataTable conversion
DataTable customTable = new DataTable();
// Define columns based on Excel structure
for (int col = 0; col < sheet.ColumnCount; col++)
{
    customTable.Columns.Add($"Column{col + 1}", typeof(string));
}
// Import data with validation
foreach (var row in sheet.Rows)
{
    var dataRow = customTable.NewRow();
    for (int col = 0; col < sheet.ColumnCount; col++)
    {
        dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
    }
    customTable.Rows.Add(dataRow);
}
// Print column headers
foreach (DataColumn column in customTable.Columns)
{
    Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();
// Print each row
foreach (DataRow row in customTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

This approach provides flexibility for data transformation during import. Null values are handled gracefully by converting them to DBNull.Value, ensuring compatibility with database operations.

What Advanced Features Support Data Manipulation?

IronXL goes beyond basic reading with powerful features for complex scenarios. The library preserves Excel formulas, allowing calculations to update dynamically. For developers working with complex Excel workbooks, this maintains data integrity throughout the import process.

// Read calculated values from formulas
WorkSheet sheet = workBook.GetWorkSheet("Reports");
decimal calculatedTotal = sheet["E10"].DecimalValue; // Reads formula result
// Formulas remain intact
string formula = sheet["E10"].Formula; // Returns "=SUM(E2:E9)"

// Read calculated values from formulas
WorkSheet sheet = workBook.GetWorkSheet("Reports");
decimal calculatedTotal = sheet["E10"].DecimalValue; // Reads formula result
// Formulas remain intact
string formula = sheet["E10"].Formula; // Returns "=SUM(E2:E9)"

IRON VB CONVERTER ERROR developers@ironsoftware.com

Formula support means importing Excel files with complex calculations works without recreating business logic. The library evaluates formulas automatically, returning calculated values while preserving the original formula structure. This feature proves invaluable when you need to read Excel files containing financial models or reporting templates.

Cross-platform compatibility ensures consistent behavior across Windows, Linux, macOS, and container environments. This flexibility makes IronXL ideal for cloud deployments and microservices architectures where Office installation isn't feasible. The .NET Foundation's documentation highlights how modern .NET applications benefit from this platform independence when importing Excel data.

Entity Framework integration streamlines database workflows for C# Excel import scenarios:

var products = sheet.Rows.Skip(1)
    .Select(row => new Product
    {
        Name = row.Columns[0].StringValue,
        Price = row.Columns[1].DecimalValue
    })
    .ToList();
using (var context = new AppDbContext())
{
    context.Products.AddRange(products);
    await context.SaveChangesAsync();
}

var products = sheet.Rows.Skip(1)
    .Select(row => new Product
    {
        Name = row.Columns[0].StringValue,
        Price = row.Columns[1].DecimalValue
    })
    .ToList();
using (var context = new AppDbContext())
{
    context.Products.AddRange(products);
    await context.SaveChangesAsync();
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

This pattern enables direct Excel-to-database pipelines with minimal code, perfect for data migration and ETL processes. For comprehensive Excel manipulation capabilities, download IronXL to streamline your data import workflows.

Conclusion

IronXL transforms Excel data import from a complex challenge into straightforward C# code. The library's intuitive API, comprehensive format support, and cross-platform compatibility make it the practical choice for production applications requiring Excel file manipulation.

Ready to import Excel files into your C# projects? Start your free trial to explore IronXL's full capabilities. For detailed implementation guidance, visit the complete documentation or explore more Excel tutorials for advanced scenarios. For production deployments, view licensing options to find the right fit for your team.