IronXL lets you open and read Excel files in C# without Microsoft Office installed -- just install the NuGet package, load a workbook with WorkBook.Load("file.xlsx"), and access any worksheet, cell, or range with typed values and automatic format detection.
If you have ever tried opening Excel files programmatically without Microsoft Office, you know how tricky the traditional Interop approach can be. Interop relies on Excel itself being installed, requires complex COM references, and often causes version conflicts -- especially on servers or cloud environments where Office is unavailable.
IronXL is a modern .NET library that lets you read XLSX, XLS, CSV, and TSV files directly, with no Office dependency required. You can write clean, reliable C# code, process Excel files on Windows, Linux, or in the cloud, and skip all the friction of COM automation. This guide walks through everything from installation to production-ready patterns for opening and reading Excel workbooks.
Getting started takes only a few seconds. Open your project and use one of the following package managers:
Alternatively, open Visual Studio, right-click your project, select "Manage NuGet Packages," search for "IronXL," and click Install. The installation guide covers all supported environments including Docker and Azure.
Once installed, add the namespace at the top of your file:
using IronXL;Imports IronXLThat single line is all you need. There are no complex COM references, no Office dependencies, and no version-specific assemblies. For a free evaluation key, visit the IronXL trial license page.
Traditional Excel Interop requires Microsoft Office on every machine that runs your code. That is impractical for server deployments, AWS Lambda functions, and containerized applications. IronXL handles all Excel file parsing internally, providing a clean API that works without any external dependencies.
With Interop, you also need to manage COM object lifetimes carefully to prevent memory leaks -- every Application, Workbook, and Worksheet object must be explicitly released, otherwise Excel processes accumulate in the background. IronXL uses standard .NET garbage collection, so you never need to think about COM cleanup.
The library supports .NET Framework 4.6.2 and above, as well as .NET 5, 6, 7, 8, and 10. It runs on Windows, macOS, and Linux without modification. If you are targeting cross-platform scenarios, this alone makes IronXL a substantially better fit than Office Interop, which is Windows-only.
After installation, create a simple test by loading any Excel file and printing a cell value. If the project builds without errors and the output matches expected data, the setup is complete. The IronXL documentation includes a quick-start section that walks through this verification step in detail.
A common mistake during setup is forgetting to apply a license key before loading a workbook in production. In trial mode the library adds a small watermark to any generated files. Set IronXL.License.LicenseKey at application startup so all operations run under the correct license from the beginning.
The core API is straightforward. Load a workbook, select a worksheet, and access cells by address or by iteration.
using IronXL;
// Load any Excel file -- XLSX, XLS, CSV, or TSV
WorkBook workbook = WorkBook.Load("example.xlsx");
// Access the second worksheet (zero-indexed)
WorkSheet worksheet = workbook.WorkSheets[1];
// Read a specific cell value
decimal revenue = worksheet["E2"].DecimalValue;
Console.WriteLine($"Order Total: {revenue}");
// Iterate over a range of cells
foreach (var cell in worksheet["C2:C6"])
{
Console.WriteLine($"Product: {cell.Text}");
}Imports IronXL
' Load any Excel file -- XLSX, XLS, CSV, or TSV
Dim workbook As WorkBook = WorkBook.Load("example.xlsx")
' Access the second worksheet (zero-indexed)
Dim worksheet As WorkSheet = workbook.WorkSheets(1)
' Read a specific cell value
Dim revenue As Decimal = worksheet("E2").DecimalValue
Console.WriteLine($"Order Total: {revenue}")
' Iterate over a range of cells
For Each cell In worksheet("C2:C6")
Console.WriteLine($"Product: {cell.Text}")
NextWorkBook.Load() automatically detects the file format -- no need to specify whether the file is XLS or XLSX. Access worksheets by index or by name using workbook.GetWorkSheet("Sheet1"). Each cell exposes typed properties such as IntValue, DecimalValue, DateTimeValue, and Text.
For more options on opening files, see the open workbook how-to guide.
Using worksheet names is more maintainable than numeric indexes, especially when workbooks are edited by others. The following example shows how to look up a sheet by name and iterate through all sheets:
using IronXL;
WorkBook workbook = WorkBook.Load("inventory.xlsx");
// Access worksheet by exact name
WorkSheet salesSheet = workbook.GetWorkSheet("Sales Data");
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}");
// Iterate all worksheets in the workbook
foreach (WorkSheet sheet in workbook.WorkSheets)
{
if (sheet.Name.Contains("Inventory"))
{
Console.WriteLine($"Found inventory sheet: {sheet.Name}");
}
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
' Access worksheet by exact name
Dim salesSheet As WorkSheet = workbook.GetWorkSheet("Sales Data")
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}")
' Iterate all worksheets in the workbook
For Each sheet As WorkSheet In workbook.WorkSheets
If sheet.Name.Contains("Inventory") Then
Console.WriteLine($"Found inventory sheet: {sheet.Name}")
End If
NextThe read Excel file guide explains additional worksheet access patterns, including working with workbooks that have dynamically generated sheet names.
IronXL exposes typed accessors for every common Excel data type. You can read strings, integers, decimals, dates, booleans, and formula results without any manual parsing.
using IronXL;
WorkBook wb = WorkBook.Load(@"C:\Data\Inventory.xlsx");
WorkSheet ws = wb.GetWorkSheet("Products");
// Read different data types directly
string productName = ws["A2"].StringValue;
int quantity = ws["B2"].IntValue;
decimal price = ws["C2"].DecimalValue;
DateTime updated = ws["D2"].DateTimeValue;
// Use aggregate functions on ranges for performance
decimal totalStock = ws["B2:B100"].Sum();
decimal maxPrice = ws["C2:C100"].Max();
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}");Imports IronXL
Dim wb As WorkBook = WorkBook.Load("C:\Data\Inventory.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Products")
' Read different data types directly
Dim productName As String = ws("A2").StringValue
Dim quantity As Integer = ws("B2").IntValue
Dim price As Decimal = ws("C2").DecimalValue
Dim updated As DateTime = ws("D2").DateTimeValue
' Use aggregate functions on ranges for performance
Dim totalStock As Decimal = ws("B2:B100").Sum()
Dim maxPrice As Decimal = ws("C2:C100").Max()
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}")
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}")The table below summarizes the available typed accessors:
| Accessor | Return Type | Notes |
|---|---|---|
StringValue | string | Always returns a string, even for numeric cells |
IntValue | int | Truncates decimal values |
DecimalValue | decimal | Best for financial data |
DoubleValue | double | For scientific or floating-point values |
DateTimeValue | DateTime | Parses Excel serial date numbers automatically |
BoolValue | bool | Reads TRUE/FALSE cells |
Formula | string | Returns the formula text, e.g. =SUM(A2:D2) |
For full details on reading and writing cell data, see the cell formatting guide and the import data how-to.
Empty cells are common in real-world Excel files. Use the IsEmpty property or check Value for null before reading typed accessors:
using IronXL;
WorkBook workbook = WorkBook.Load("data.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;
// Check if a cell is empty before reading
if (!ws["A1"].IsEmpty)
{
Console.WriteLine(ws["A1"].StringValue);
}
// Provide a fallback value using a null-coalescing pattern
string cellText = ws["A1"].StringValue ?? "Default Value";
// Iterate a range and skip empty cells
foreach (var cell in ws["A1:A20"])
{
if (!cell.IsEmpty)
{
Console.WriteLine(cell.Text);
}
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Check if a cell is empty before reading
If Not ws("A1").IsEmpty Then
Console.WriteLine(ws("A1").StringValue)
End If
' Provide a fallback value using a null-coalescing pattern
Dim cellText As String = If(ws("A1").StringValue, "Default Value")
' Iterate a range and skip empty cells
For Each cell In ws("A1:A20")
If Not cell.IsEmpty Then
Console.WriteLine(cell.Text)
End If
NextThe read Excel file documentation covers additional patterns for handling sparse data, including how to detect the last used row and column in a worksheet.
Another consideration when dealing with empty cells is the difference between a truly blank cell and a cell that holds an empty string. IsEmpty returns true only when the cell contains no value at all, while StringValue returns an empty string for both blank cells and cells explicitly set to "". If your data has cells formatted as text that appear empty, check both IsEmpty and string.IsNullOrWhiteSpace(cell.StringValue) for the most accurate result.
A real-world Excel reader needs file validation, error handling, multi-sheet support, and optional output generation. The following example demonstrates all of these patterns in a single class:
using IronXL;
using System.IO;
// Validate and load the file
static List<string> CheckLowStock(string filePath)
{
var lowStockItems = new List<string>();
if (!File.Exists(filePath))
{
Console.WriteLine($"File not found: {filePath}");
return lowStockItems;
}
string ext = Path.GetExtension(filePath).ToLower();
if (ext is not (".xlsx" or ".xls" or ".csv"))
{
Console.WriteLine($"Unsupported file type: {ext}");
return lowStockItems;
}
try
{
WorkBook workbook = WorkBook.Load(filePath);
foreach (WorkSheet sheet in workbook.WorkSheets)
{
Console.WriteLine($"Checking sheet: {sheet.Name}");
for (int row = 2; row <= sheet.RowCount; row++)
{
string itemName = sheet[$"A{row}"].StringValue;
int stockLevel = sheet[$"B{row}"].IntValue;
if (stockLevel < 10 && !string.IsNullOrEmpty(itemName))
{
lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})");
}
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Error reading Excel file: {ex.Message}");
}
return lowStockItems;
}
// Export results to a new workbook
static void ExportReport(List<string> items, string outputPath)
{
WorkBook report = WorkBook.Create();
WorkSheet sheet = report.CreateWorkSheet("Low Stock Report");
sheet["A1"].Value = "Item Description";
sheet["B1"].Value = "Source Sheet";
sheet["A1:B1"].Style.Font.Bold = true;
sheet["A1:B1"].Style.BackgroundColor = "#4472C4";
sheet["A1:B1"].Style.Font.Color = "#FFFFFF";
int rowIndex = 2;
foreach (string item in items)
{
sheet[$"A{rowIndex}"].Value = item;
rowIndex++;
}
report.SaveAs(outputPath);
Console.WriteLine($"Report saved to: {outputPath}");
}
// Run
var lowStockItems = CheckLowStock("inventory.xlsx");
ExportReport(lowStockItems, "low-stock-report.xlsx");Imports IronXL
Imports System.IO
' Validate and load the file
Private Shared Function CheckLowStock(filePath As String) As List(Of String)
Dim lowStockItems As New List(Of String)()
If Not File.Exists(filePath) Then
Console.WriteLine($"File not found: {filePath}")
Return lowStockItems
End If
Dim ext As String = Path.GetExtension(filePath).ToLower()
If ext <> ".xlsx" AndAlso ext <> ".xls" AndAlso ext <> ".csv" Then
Console.WriteLine($"Unsupported file type: {ext}")
Return lowStockItems
End If
Try
Dim workbook As WorkBook = WorkBook.Load(filePath)
For Each sheet As WorkSheet In workbook.WorkSheets
Console.WriteLine($"Checking sheet: {sheet.Name}")
For row As Integer = 2 To sheet.RowCount
Dim itemName As String = sheet($"A{row}").StringValue
Dim stockLevel As Integer = sheet($"B{row}").IntValue
If stockLevel < 10 AndAlso Not String.IsNullOrEmpty(itemName) Then
lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})")
End If
Next
Next
Catch ex As Exception
Console.WriteLine($"Error reading Excel file: {ex.Message}")
End Try
Return lowStockItems
End Function
' Export results to a new workbook
Private Shared Sub ExportReport(items As List(Of String), outputPath As String)
Dim report As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = report.CreateWorkSheet("Low Stock Report")
sheet("A1").Value = "Item Description"
sheet("B1").Value = "Source Sheet"
sheet("A1:B1").Style.Font.Bold = True
sheet("A1:B1").Style.BackgroundColor = "#4472C4"
sheet("A1:B1").Style.Font.Color = "#FFFFFF"
Dim rowIndex As Integer = 2
For Each item As String In items
sheet($"A{rowIndex}").Value = item
rowIndex += 1
Next
report.SaveAs(outputPath)
Console.WriteLine($"Report saved to: {outputPath}")
End Sub
' Run
Dim lowStockItems As List(Of String) = CheckLowStock("inventory.xlsx")
ExportReport(lowStockItems, "low-stock-report.xlsx")This example uses top-level statements and covers the full workflow: validate the file path and extension, load the workbook, iterate all worksheets, apply business logic, and write results to a new file. For more about writing and saving workbooks, see the write Excel file guide and the export Excel how-to.
Notice that the ExportReport method creates a new workbook with WorkBook.Create() rather than modifying the source file. Keeping source and output files separate is a good practice for audit trails and avoids accidentally overwriting data that other processes depend on. If you need to append data to an existing workbook instead, load it with WorkBook.Load(), add rows to the appropriate worksheet, and call SaveAs() to a new path or overwrite in place.
For files with thousands of rows, aggregate functions outperform manual loops because they operate internally without materializing each cell as a separate object:
using IronXL;
WorkBook workbook = WorkBook.Load("large-dataset.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;
// Fast: aggregate functions operate on the range directly
decimal total = ws["B2:B5000"].Sum();
decimal average = ws["B2:B5000"].Avg();
int count = ws["B2:B5000"].Count();
Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}");
// Export the worksheet to a DataSet for LINQ or database operations
var dataSet = workbook.ToDataSet();
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("large-dataset.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Fast: aggregate functions operate on the range directly
Dim total As Decimal = ws("B2:B5000").Sum()
Dim average As Decimal = ws("B2:B5000").Avg()
Dim count As Integer = ws("B2:B5000").Count()
Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}")
' Export the worksheet to a DataSet for LINQ or database operations
Dim dataSet = workbook.ToDataSet()
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}")Converting to a DataSet is particularly effective when you need to run LINQ queries across multiple sheets or load data into a relational database. Each worksheet becomes a DataTable inside the DataSet, making it straightforward to work with existing data-access code. See the Excel to DataSet guide for full details.
IronXL is a commercial library with a free trial that allows full functionality during development and testing. For production deployments, you will need a valid license key. Details on licensing tiers, including developer, team, and enterprise options, are on the IronXL licensing page.
To apply a license key, set it before any IronXL calls:
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"The IronXL features overview summarizes all capabilities, from reading and writing files to creating charts, applying conditional formatting, and working with named ranges. The create Excel file guide and merge cells how-to are useful starting points for writing new workbooks.
For community discussions and questions about C# Excel automation, the Microsoft Q&A forums and Stack Overflow are good resources. The official NuGet package page provides version history and download statistics.
IronXL removes the dependency on Microsoft Office entirely, making it practical to process Excel files on servers, in containers, and in cloud functions. The API follows a simple pattern: load a workbook, access worksheets by name or index, and read cells using typed accessors. Aggregate functions like Sum(), Avg(), and Max() handle large datasets without the overhead of manual iteration.
The library supports XLSX, XLS, CSV, and TSV formats, runs on .NET 10 and all recent .NET versions, and works cross-platform. Error handling is straightforward because IronXL throws standard .NET exceptions that you can catch with familiar try/catch patterns -- no COM interop error codes to decode. To explore all available options, start with the IronXL documentation home or try the open workbook how-to for a step-by-step reference.
Start a free IronXL trial to evaluate the library in your own projects without any commitment.
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
IronXL is a part of IRONSUITE
10 .NET API products for your office documents
The Excel API you need, without the Office Interop hassle.
