Why can't StreamReader be used to read Excel files?

StreamReader is designed for reading text files and cannot interpret the binary structures or ZIP-compressed XML formats found in Excel files. IronXL, on the other hand, understands Excel's internal structure and provides a clean way to access spreadsheet data.

What is the benefit of using IronXL for reading Excel files in C#?

IronXL offers a simple API for reading and writing Excel files, supports multiple formats like XLSX, XLS, and CSV, and does not require Microsoft Excel to be installed. It handles Excel's complex structures natively, making it ideal for .NET developers.

How can IronXL be installed in a .NET project?

IronXL can be installed via NuGet by using the command `dotnet add package IronXL`. Adding the directive `using IronXL;` in your code files allows you to start working with Excel documents immediately.

Is it possible to read Excel files from a memory stream using IronXL?

Yes, IronXL can process Excel files from streams, such as MemoryStream or FileStream, using the WorkBook.FromStream method. This is useful for handling file uploads or reading files from cloud storage without saving them to disk.

How does IronXL facilitate conversion between Excel and CSV formats?

IronXL allows easy format conversion by using methods like `WorkBook.SaveAsCsv` to export Excel data to CSV and `WorkBook.LoadCSV` to import CSV data into an Excel workbook, preserving data integrity.

Can IronXL handle event-driven Excel reading in C# applications?

Yes, IronXL integrates seamlessly with event-driven architectures, such as ASP.NET or Windows Forms, allowing Excel processing logic to be used within event handlers, without dependency on a UI thread.

How are Excel files created and formatted with IronXL?

IronXL supports the creation and formatting of Excel files. It enables defining cell styles, applying formats like bold and colors, and merging cells, making it a versatile tool for generating professional Excel reports.

What licensing options are available for deploying IronXL?

IronXL offers Developer, Team, and Organization licensing options suitable for various deployment requirements. A license key must be applied in the code, or an environment variable can be set for production use.

Is IronXL compatible with different operating systems and environments?

Yes, IronXL supports Windows, Linux, macOS, and Docker. Its compatibility with different platforms makes it suitable for cloud-native applications and microservices architectures.

Does IronXL require Microsoft Excel to be installed for its operations?

No, IronXL operates independently of Microsoft Excel, eliminating the need for the software to be installed on servers, which simplifies deployment across various environments.

The C# Excel Library

Explore IronXL Excel Spreadsheet Library for C# .NET Start Free Trial

Read Excel Files without Interop

See All Code Examples

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

USING IRONXL

How to Read Excel Files in C# Instead of Using StreamReader

Curtis Chau

Updated: June 28, 2026

Many C# developers encounter a frustrating challenge when working with Excel files: the StreamReader class, which handles text files reliably, fails completely when pointed at an Excel document. If you have tried to read an Excel file using StreamReader in C# only to see garbled characters, binary noise, or unexpected exceptions, you are in good company. This guide explains exactly why StreamReader cannot handle Excel files and shows you how to solve the problem correctly using IronXL -- a dedicated Excel library for .NET that requires no Excel installation.

The confusion often arises because CSV files -- which Excel can open and save -- work fine with StreamReader. True Excel files (XLSX, XLS, XLSM) require a fundamentally different approach. Understanding this distinction will save you hours of debugging and direct you to the right tool for the job.

Alternative to Read Excel File Using StreamReader in C# - IronXL: Image 1 - IronXL

Why Can't StreamReader Read Excel Files?

StreamReader is a text-based reader. It reads character data line by line using a specified encoding (UTF-8, ASCII, etc.) and has no awareness of binary structures or compressed archives. The official .NET StreamReader documentation confirms that this class is designed exclusively for character-encoded text. Excel files, despite looking like simple spreadsheets, are actually complex binary or ZIP-compressed XML structures that StreamReader cannot interpret.

When you open an XLSX file with StreamReader, you are essentially trying to read a ZIP archive as plain text. The result is a stream of binary noise rather than your spreadsheet data.

// This code will NOT work -- demonstrates the problem
using StreamReader reader = new StreamReader("ProductData.xlsx");
string content = reader.ReadLine();
Console.WriteLine(content); // Outputs garbled binary data like "PK♥♦"

// This code will NOT work -- demonstrates the problem
using StreamReader reader = new StreamReader("ProductData.xlsx");
string content = reader.ReadLine();
Console.WriteLine(content); // Outputs garbled binary data like "PK♥♦"

Imports System.IO

' This code will NOT work -- demonstrates the problem
Using reader As New StreamReader("ProductData.xlsx")
    Dim content As String = reader.ReadLine()
    Console.WriteLine(content) ' Outputs garbled binary data like "PK♥♦"
End Using

Imports System.IO

' This code will NOT work -- demonstrates the problem
Using reader As New StreamReader("ProductData.xlsx")
    Dim content As String = reader.ReadLine()
    Console.WriteLine(content) ' Outputs garbled binary data like "PK♥♦"
End Using

When you run this snippet, instead of seeing your spreadsheet rows, you encounter binary characters such as PK♥♦ or similar noise. This happens because:

XLSX files are ZIP archives containing multiple XML files: worksheets, styles, shared strings, relationships. The Open XML SDK documentation provides a detailed breakdown of this structure.
XLS files use a proprietary binary format (BIFF -- Binary Interchange File Format)
StreamReader applies a character encoding to whatever bytes it reads, producing meaningless output for both formats

Sample Input

Alternative to Read Excel File Using StreamReader in C# - IronXL: Image 2 - Excel Input

Garbled Output When Using StreamReader

Alternative to Read Excel File Using StreamReader in C# - IronXL: Image 3 - Console Output

Why CSV Works But XLSX Does Not

CSV (Comma-Separated Values) is a plain-text format. Each row is a line of text, and each column is separated by a comma. StreamReader reads CSV files without issue because they contain no binary data or compressed archives. XLSX is fundamentally different: it packages multiple XML documents inside a ZIP container with metadata, themes, and style definitions. There is no simple line-by-line reading possible.

This distinction matters when choosing your tooling. For CSV files, StreamReader or File.ReadAllLines are perfectly adequate. For true Excel workbooks, you need a library that understands the format at a structural level.

How Do You Install IronXL in a .NET Project?

IronXL is a .NET library that reads, writes, and creates Excel files without requiring Microsoft Excel to be installed. It supports XLSX, XLS, XLSM, CSV, and TSV formats, and runs on Windows, Linux, macOS, and Docker containers.

To install IronXL, use either the NuGet Package Manager Console or the .NET CLI. The package is published on NuGet.org as IronXL:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

After installation, add the using IronXL; directive to your file and you are ready to work with Excel documents.

Alternative to Read Excel File Using StreamReader in C# - IronXL: Image 5 - Installation

For detailed installation steps and NuGet configuration options, see the IronXL NuGet installation guide. A free trial license is available so you can evaluate IronXL in your project before purchasing.

Alternative to Read Excel File Using StreamReader in C# - IronXL: Image 4 - Cross Platform

How Do You Read Excel Files with IronXL?

IronXL provides an intuitive API for reading Excel files in C#. Unlike StreamReader, IronXL understands Excel's internal structure and gives you clean access to rows, columns, and cell values. The IronXL documentation provides full API references for all supported operations.

Here is how to read an Excel file using IronXL with top-level statements:

using IronXL;

// Load the Excel file from disk
WorkBook workbook = WorkBook.Load("ProductData.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Read a specific cell by address
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Iterate over a range of cells
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Read a numeric value
decimal price = worksheet["B2"].DecimalValue;
Console.WriteLine($"Price: {price:C}");

using IronXL;

// Load the Excel file from disk
WorkBook workbook = WorkBook.Load("ProductData.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Read a specific cell by address
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Iterate over a range of cells
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Read a numeric value
decimal price = worksheet["B2"].DecimalValue;
Console.WriteLine($"Price: {price:C}");

Imports IronXL

' Load the Excel file from disk
Dim workbook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell by address
Dim cellValue As String = worksheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")

' Iterate over a range of cells
For Each cell In worksheet("A1:C10")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

' Read a numeric value
Dim price As Decimal = worksheet("B2").DecimalValue
Console.WriteLine($"Price: {price:C}")

Imports IronXL

' Load the Excel file from disk
Dim workbook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell by address
Dim cellValue As String = worksheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")

' Iterate over a range of cells
For Each cell In worksheet("A1:C10")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

' Read a numeric value
Dim price As Decimal = worksheet("B2").DecimalValue
Console.WriteLine($"Price: {price:C}")

The WorkBook.Load method automatically detects the file format (XLSX, XLS, XLSM, CSV) and handles all the complex parsing. You access cells using standard Excel notation such as "A1" or ranges such as "A1:C10", which makes the code immediately readable to anyone familiar with spreadsheets.

Accessing Multiple Worksheets

Many workbooks contain more than one sheet. IronXL lets you open and navigate workbooks with full worksheet enumeration:

using IronXL;

WorkBook workbook = WorkBook.Load("MultiSheet.xlsx");

// List all worksheets
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}");
}

// Access a sheet by name
WorkSheet summary = workbook.GetWorkSheet("Summary");
string totalRevenue = summary["B20"].StringValue;
Console.WriteLine($"Total Revenue: {totalRevenue}");

// Access a sheet by index
WorkSheet firstSheet = workbook.WorkSheets[0];
int lastRow = firstSheet.RowCount;
Console.WriteLine($"Last row in first sheet: {lastRow}");

using IronXL;

WorkBook workbook = WorkBook.Load("MultiSheet.xlsx");

// List all worksheets
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}");
}

// Access a sheet by name
WorkSheet summary = workbook.GetWorkSheet("Summary");
string totalRevenue = summary["B20"].StringValue;
Console.WriteLine($"Total Revenue: {totalRevenue}");

// Access a sheet by index
WorkSheet firstSheet = workbook.WorkSheets[0];
int lastRow = firstSheet.RowCount;
Console.WriteLine($"Last row in first sheet: {lastRow}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("MultiSheet.xlsx")

' List all worksheets
For Each sheet As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}")
Next

' Access a sheet by name
Dim summary As WorkSheet = workbook.GetWorkSheet("Summary")
Dim totalRevenue As String = summary("B20").StringValue
Console.WriteLine($"Total Revenue: {totalRevenue}")

' Access a sheet by index
Dim firstSheet As WorkSheet = workbook.WorkSheets(0)
Dim lastRow As Integer = firstSheet.RowCount
Console.WriteLine($"Last row in first sheet: {lastRow}")

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("MultiSheet.xlsx")

' List all worksheets
For Each sheet As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}")
Next

' Access a sheet by name
Dim summary As WorkSheet = workbook.GetWorkSheet("Summary")
Dim totalRevenue As String = summary("B20").StringValue
Console.WriteLine($"Total Revenue: {totalRevenue}")

' Access a sheet by index
Dim firstSheet As WorkSheet = workbook.WorkSheets(0)
Dim lastRow As Integer = firstSheet.RowCount
Console.WriteLine($"Last row in first sheet: {lastRow}")

This approach is far cleaner than any attempt to parse Excel with StreamReader or string manipulation.

How Do You Read Excel Data from a Memory Stream?

Real-world applications often need to process Excel files from streams rather than disk files. Common scenarios include handling file uploads from web forms, retrieving workbooks from a database BLOB column, or processing files downloaded from cloud storage (Azure Blob Storage, AWS S3). IronXL handles these scenarios through WorkBook.FromStream:

using IronXL;
using System.IO;

// Simulate reading file bytes (e.g., from a database or web upload)
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");

using MemoryStream stream = new MemoryStream(fileBytes);
WorkBook workbook = WorkBook.FromStream(stream);
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Get row and column counts
Console.WriteLine($"Rows: {worksheet.RowCount}, Columns: {worksheet.ColumnCount}");

// Convert to DataTable for database or grid binding
var dataTable = worksheet.ToDataTable(useHeaderRow: true);
Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");

foreach (System.Data.DataRow row in dataTable.Rows)
{
    string productName = row["ProductName"]?.ToString() ?? string.Empty;
    string sku = row["SKU"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Product: {productName}, SKU: {sku}");
}

using IronXL;
using System.IO;

// Simulate reading file bytes (e.g., from a database or web upload)
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");

using MemoryStream stream = new MemoryStream(fileBytes);
WorkBook workbook = WorkBook.FromStream(stream);
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Get row and column counts
Console.WriteLine($"Rows: {worksheet.RowCount}, Columns: {worksheet.ColumnCount}");

// Convert to DataTable for database or grid binding
var dataTable = worksheet.ToDataTable(useHeaderRow: true);
Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");

foreach (System.Data.DataRow row in dataTable.Rows)
{
    string productName = row["ProductName"]?.ToString() ?? string.Empty;
    string sku = row["SKU"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Product: {productName}, SKU: {sku}");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

IRON VB CONVERTER ERROR developers@ironsoftware.com

WorkBook.FromStream accepts any Stream -- MemoryStream, FileStream, or a network stream. This flexibility means you never have to write temporary files to disk just to read Excel data. The conversion to DataTable also integrates directly with SqlBulkCopy, data-binding controls, and reporting frameworks.

Output from Stream Processing

Alternative to Read Excel File Using StreamReader in C# - IronXL: Image 6 - Read Excel from MemoryStream Output

When Do You Use Event-Driven Excel Reading?

In event-driven architectures -- for example, a file upload button in Windows Forms or an ASP.NET controller action -- the method signature often includes object sender and EventArgs e parameters. The Excel processing logic still uses the same IronXL API, but it is called from within the event handler rather than a top-level statement. IronXL integrates cleanly into any event-driven or async workflow because it has no dependency on a UI thread.

Alternative to Read Excel File Using StreamReader in C# - IronXL: Image 7 - Features

How Do You Convert Between Excel and CSV Formats?

While StreamReader can handle CSV files, production applications often need to move data between Excel and CSV. IronXL makes format conversion straightforward. You can export Excel data to CSV or import CSV data into a workbook in just a few lines:

using IronXL;

// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
workbook.SaveAsCsv("output.csv");

// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("legacy-report.csv");
csvWorkbook.SaveAs("converted.xlsx");

// Export a specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("sheet1-export.csv");

using IronXL;

// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
workbook.SaveAsCsv("output.csv");

// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("legacy-report.csv");
csvWorkbook.SaveAs("converted.xlsx");

// Export a specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("sheet1-export.csv");

IRON VB CONVERTER ERROR developers@ironsoftware.com

IRON VB CONVERTER ERROR developers@ironsoftware.com

These conversions preserve your data while changing the container format. When converting Excel to CSV, IronXL exports the first worksheet by default; you can specify any sheet you choose. Converting CSV to Excel creates a properly structured workbook that you can then format, add formulas to, and write additional data into.

What Are the Format Support Differences?

Comparison of StreamReader and IronXL for reading different file formats
File Format	StreamReader	IronXL	Notes
CSV (.csv)	Yes	Yes	Plain text; StreamReader works fine
XLSX (.xlsx)	No	Yes	ZIP-compressed XML; requires library
XLS (.xls)	No	Yes	Binary BIFF format; requires library
XLSM (.xlsm)	No	Yes	Macro-enabled workbook
TSV (.tsv)	Yes	Yes	Tab-separated plain text

How Do You Create and Format Excel Files with IronXL?

Reading Excel data is only part of the workflow. Many applications also need to create new Excel files and apply formatting. IronXL supports cell formatting including fonts, colors, borders, number formats, and cell merging:

using IronXL;

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");

// Write headers with formatting
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Apply bold formatting to header row
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.SetBackgroundColor("#4472C4");
sheet["A1:C1"].Style.Font.Color = "#FFFFFF";

// Write data rows
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] units = { 120, 85, 210 };
decimal[] revenues = { 2400.00m, 1700.00m, 4200.00m };

for (int i = 0; i < products.Length; i++)
{
    sheet[$"A{i + 2}"].Value = products[i];
    sheet[$"B{i + 2}"].Value = units[i];
    sheet[$"C{i + 2}"].Value = revenues[i];
    sheet[$"C{i + 2}"].FormatString = "$#,##0.00";
}

// Save the workbook
workbook.SaveAs("FormattedReport.xlsx");
Console.WriteLine("Report created successfully.");

using IronXL;

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");

// Write headers with formatting
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Apply bold formatting to header row
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.SetBackgroundColor("#4472C4");
sheet["A1:C1"].Style.Font.Color = "#FFFFFF";

// Write data rows
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] units = { 120, 85, 210 };
decimal[] revenues = { 2400.00m, 1700.00m, 4200.00m };

for (int i = 0; i < products.Length; i++)
{
    sheet[$"A{i + 2}"].Value = products[i];
    sheet[$"B{i + 2}"].Value = units[i];
    sheet[$"C{i + 2}"].Value = revenues[i];
    sheet[$"C{i + 2}"].FormatString = "$#,##0.00";
}

// Save the workbook
workbook.SaveAs("FormattedReport.xlsx");
Console.WriteLine("Report created successfully.");

Imports IronXL

' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")

' Write headers with formatting
sheet("A1").Value = "Product"
sheet("B1").Value = "Units Sold"
sheet("C1").Value = "Revenue"

' Apply bold formatting to header row
sheet("A1:C1").Style.Font.Bold = True
sheet("A1:C1").Style.SetBackgroundColor("#4472C4")
sheet("A1:C1").Style.Font.Color = "#FFFFFF"

' Write data rows
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim units As Integer() = {120, 85, 210}
Dim revenues As Decimal() = {2400.0D, 1700.0D, 4200.0D}

For i As Integer = 0 To products.Length - 1
    sheet($"A{i + 2}").Value = products(i)
    sheet($"B{i + 2}").Value = units(i)
    sheet($"C{i + 2}").Value = revenues(i)
    sheet($"C{i + 2}").FormatString = "$#,##0.00"
Next

' Save the workbook
workbook.SaveAs("FormattedReport.xlsx")
Console.WriteLine("Report created successfully.")

Imports IronXL

' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")

' Write headers with formatting
sheet("A1").Value = "Product"
sheet("B1").Value = "Units Sold"
sheet("C1").Value = "Revenue"

' Apply bold formatting to header row
sheet("A1:C1").Style.Font.Bold = True
sheet("A1:C1").Style.SetBackgroundColor("#4472C4")
sheet("A1:C1").Style.Font.Color = "#FFFFFF"

' Write data rows
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim units As Integer() = {120, 85, 210}
Dim revenues As Decimal() = {2400.0D, 1700.0D, 4200.0D}

For i As Integer = 0 To products.Length - 1
    sheet($"A{i + 2}").Value = products(i)
    sheet($"B{i + 2}").Value = units(i)
    sheet($"C{i + 2}").Value = revenues(i)
    sheet($"C{i + 2}").FormatString = "$#,##0.00"
Next

' Save the workbook
workbook.SaveAs("FormattedReport.xlsx")
Console.WriteLine("Report created successfully.")

This ability to both read existing workbooks and create new formatted files makes IronXL a complete Excel solution for .NET applications. Review the full IronXL features page for a detailed breakdown of supported operations.

Exporting Data to Other Formats

IronXL also supports exporting workbook data to DataSet objects, which is particularly useful when loading multiple worksheets into memory for cross-sheet calculations or database bulk-insert operations. The ToDataSet method returns a DataSet where each worksheet becomes a DataTable.

How Do You License and Deploy IronXL in Production?

IronXL is free for development and testing. For production applications, a license is required. You can explore IronXL licensing options on the product page, which covers Developer, Team, and Organization tiers depending on your deployment requirements.

After purchasing, apply your license key in code before any IronXL calls:

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Alternatively, set the IRONXL_LICENSE_KEY environment variable in your deployment environment and IronXL will pick it up automatically. This is the preferred approach for containerized deployments (Docker, Kubernetes) and cloud environments where hardcoding keys is not acceptable.

For evaluation purposes, a free trial license provides full functionality so you can validate IronXL against your specific workloads before committing to a purchase. The trial is available without a credit card and activates immediately.

Compared to alternatives such as Microsoft.Office.Interop.Excel, IronXL has several deployment advantages:

No requirement for Microsoft Excel to be installed on the server
Compatible with Linux and Docker -- critical for cloud-native applications
No COM object lifecycle management or apartment threading issues
Faster startup and lower memory usage in server contexts
Consistent behavior across all supported platforms

These qualities make IronXL a practical choice for any .NET application that needs to process Excel files in production, whether on-premises or in the cloud.

Curtis Chau

Chat with engineering team now

Technical Writer

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.

...