What are the main differences between IronXL and NPOI when working with Excel files in C#?

IronXL provides a higher level API that simplifies reading, writing, and manipulating Excel files with fewer lines of code compared to NPOI. NPOI requires more boilerplate code and manual iteration for tasks, whereas IronXL offers more streamlined operations and additional features like professional support and regular updates.

Why should I consider using IronXL over NPOI for handling Excel files?

IronXL is preferred for its ease of use, requiring significantly less code to perform the same tasks. This simplicity reduces development time and potential bugs. Additionally, IronXL comes with professional support and the option to request new features.

Can IronXL be installed through NuGet in Visual Studio?

Yes, IronXL can be installed via the NuGet Package Manager in Visual Studio by searching for 'IronXL.Excel' and clicking 'Install'. It can also be installed using the Visual Studio developer command prompt.

Is IronXL compatible with VB.NET in addition to C#?

Yes, IronXL is designed to work with both VB.NET and C#, allowing developers to read, edit, and create Excel files within these .NET languages.

How does IronXL handle Excel file reading differently than NPOI?

IronXL simplifies the process by allowing developers to load an Excel workbook and convert it to a DataTable with just a few lines of code, eliminating the need for manual row and cell iteration required by NPOI.

What kind of support does IronXL offer compared to NPOI?

IronXL provides professional support, consistent updates, and opportunities to request features directly from Iron Software engineers, which enhances its usability and reliability in enterprise environments, unlike the community-driven NPOI.

Can I test IronXL before purchasing?

Yes, you can download a free 30-day trial of IronXL to explore its features and functionality within your projects.

What installation methods are available for NPOI?

NPOI can be installed by downloading it manually from its GitHub page or by using NuGet in Visual Studio through the developer command prompt or the NuGet Package Manager.

Does IronXL require Microsoft Excel to be installed on the server?

No, IronXL operates independently of Microsoft Excel and does not require it to be installed on the server in order to handle Excel files.

How does IronXL ensure ease of maintenance for Excel operations in .NET?

IronXL's concise API reduces code complexity, leading to fewer maintenance challenges and reduced bug occurrence. Its professionally supported updates and feature requests further simplify long-term use.

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

COMPARE TO OTHER COMPONENTS

A Comparison of IronXL and NPOI

Curtis Chau

Updated: July 19, 2026

IronXL and NPOI are both .NET Excel libraries that work without Office.Interop - no Microsoft Excel installation required. This comparison covers their APIs for reading, writing, and manipulating Excel files, with code examples for the operations developers encounter most often.

How to Use NPOI for Excel in C#

Install C# library to read Excel with NPOI
Instantiate XSSFWorkbook object to store Excel file
Get specific worksheet with GetSheetAt method
Access each row by passing row index to GetRow method
Access each cell in the row with GetCell method

What is NPOI?

NPOI is the .NET version of the POI Java project at http://poi.apache.org/. POI is an open-source project that can help you read/write xls, doc, ppt files. It has a wide range of applications.

For example, you can use it to:

Generate an Excel report without Microsoft Office suite installed on your server and more efficiently than calling Microsoft Excel ActiveX in the background
Extract text from Office documents to help you implement a full-text indexing feature (most of the time this feature is used to create search engines)
Extract images from Office documents
Generate Excel sheets that contain formulas

NPOI and Excel

NPOI is a C# port of the POI Java project by Apache. It is free and open-source. Also, it doesn't need Interop, meaning that users will not need to have Excel installed to have the developer's app work with it.

IronXL and Excel

IronXL is an Excel API for VB and C#. With IronXL you can read, edit, and create Excel spreadsheet files in .NET.

How Do NPOI and IronXL Compare?

NPOI	IronXL
Cell Ranges	Cell Ranges
Cell styling (Border, Color, Fill, Font, Number, Alignments)	Cell visual styles Font, Size, Background pattern, Border, Alignment, and Number formats.
Formula calculation	Formulas
Data Validation	Data Validation
Conditional formatting	Conditional formatting
Images	Images
Charts	Charts

Table 1 - Feature Comparison

Teams evaluating IronXL as an NPOI alternative can test the full API with a free 30-day trial.

Installation of IronXL and NPOI

You can install both libraries by downloading them manually, via NuGet, or with the NuGet Package Manager in Visual Studio. Here is a quick overview; for a step-by-step walkthrough, see the IronXL getting started guide.

NPOI Installation

Installing NPOI with NuGet

To install NPOI through NuGet, open the Visual Studio developer command prompt and enter the following:

PM > Install-Package NPOI -Version x.x.x

Install-Package NPOI -Version x.x.x

Graphical user interfaceDescription automatically generated

Figure 1 - NuGet NPOI Installation

Visual Studio NuGet Package Manager and NPOI

Use the following steps to install IronXL or NPOI via the NuGet Package Manager in Visual Studio:

Right-click the project in the Solution Explorer
Select Manage NuGet Packages
Browse for your Package
Click Install

A screenshot of a computerDescription automatically generated

Figure 2 - NuGet Package Manager for NPOI

IronXL Installation

Downloading IronXL

To download IronXL, navigate to the following URL and click the "Download" button.

Figure 3 - Download IronXL

Installing IronXL with NuGet

To install IronXL through NuGet, open the Visual Studio developer command prompt and enter the following:

PM > Install-Package IronXL.Excel -Version x.x.x

Install-Package IronXL.Excel -Version x.x.x

Figure 4 - NuGet IronXL Installation

Visual Studio NuGet Package Manager and IronXL

Use the following steps to install IronXL via the NuGet Package Manager in Visual Studio:

Right-click the project in the Solution Explorer
Select Manage NuGet Packages
Browse for your Package
Click Install

Figure 5 - NuGet Package Manager for IronXL

Reading from and writing to an Excel file with NPOI and IronXL

Reading an Excel file with NPOI

The following code demonstrates how to read an Excel file and display its contents with NPOI. Add the following code and include the necessary namespaces:

using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using System.Data;
using System.IO;
using System.Collections.Generic;

using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using System.Data;
using System.IO;
using System.Collections.Generic;

Imports NPOI.SS.UserModel
Imports NPOI.XSSF.UserModel
Imports System.Data
Imports System.IO
Imports System.Collections.Generic

Imports NPOI.SS.UserModel
Imports NPOI.XSSF.UserModel
Imports System.Data
Imports System.IO
Imports System.Collections.Generic

The below code reads an existing Excel file and displays it inside a data grid view.

public void ReadExcelNPOI()
{
    DataTable dtTable = new DataTable();
    List<string> lstRows = new List<string>();
    ISheet objWorksheet;
    string strPath = @"c:\temp\NPOI_Test.XLSX";

    // Use FileStream to open the Excel file
    using (var fStream = new FileStream(strPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
    {
        fStream.Position = 0;
        XSSFWorkbook objWorkbook = new XSSFWorkbook(fStream);
        objWorksheet = objWorkbook.GetSheetAt(0);
        IRow objHeader = objWorksheet.GetRow(0);
        int countCells = objHeader.LastCellNum;

        // Add columns to the DataTable based on the header row of Excel
        for (int j = 0; j < countCells; j++)
        {
            ICell objCell = objHeader.GetCell(j);
            if (objCell == null || string.IsNullOrWhiteSpace(objCell.ToString())) continue;
            {
                dtTable.Columns.Add(objCell.ToString());
            }
        }

        // Add rows to the DataTable, looping through each row and cell
        for (int i = (objWorksheet.FirstRowNum + 1); i <= objWorksheet.LastRowNum; i++)
        {
            IRow objRow = objWorksheet.GetRow(i);
            if (objRow == null || objRow.Cells.All(d => d.CellType == CellType.Blank)) continue;

            for (int j = objRow.FirstCellNum; j < countCells; j++)
            {
                ICell cell = objRow.GetCell(j);
                if (cell != null && !string.IsNullOrEmpty(cell.ToString()) && !string.IsNullOrWhiteSpace(cell.ToString()))
                {
                    lstRows.Add(cell.ToString());
                }
            }

            if (lstRows.Count > 0)
                dtTable.Rows.Add(lstRows.ToArray());

            lstRows.Clear();
        }
    }

    // Assuming dataGridView1 is a DataGridView control on a Form
    dataGridView1.DataSource = dtTable;
}

private void button1_Click(object sender, EventArgs e)
{
    ReadExcelNPOI();
}

public void ReadExcelNPOI()
{
    DataTable dtTable = new DataTable();
    List<string> lstRows = new List<string>();
    ISheet objWorksheet;
    string strPath = @"c:\temp\NPOI_Test.XLSX";

    // Use FileStream to open the Excel file
    using (var fStream = new FileStream(strPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
    {
        fStream.Position = 0;
        XSSFWorkbook objWorkbook = new XSSFWorkbook(fStream);
        objWorksheet = objWorkbook.GetSheetAt(0);
        IRow objHeader = objWorksheet.GetRow(0);
        int countCells = objHeader.LastCellNum;

        // Add columns to the DataTable based on the header row of Excel
        for (int j = 0; j < countCells; j++)
        {
            ICell objCell = objHeader.GetCell(j);
            if (objCell == null || string.IsNullOrWhiteSpace(objCell.ToString())) continue;
            {
                dtTable.Columns.Add(objCell.ToString());
            }
        }

        // Add rows to the DataTable, looping through each row and cell
        for (int i = (objWorksheet.FirstRowNum + 1); i <= objWorksheet.LastRowNum; i++)
        {
            IRow objRow = objWorksheet.GetRow(i);
            if (objRow == null || objRow.Cells.All(d => d.CellType == CellType.Blank)) continue;

            for (int j = objRow.FirstCellNum; j < countCells; j++)
            {
                ICell cell = objRow.GetCell(j);
                if (cell != null && !string.IsNullOrEmpty(cell.ToString()) && !string.IsNullOrWhiteSpace(cell.ToString()))
                {
                    lstRows.Add(cell.ToString());
                }
            }

            if (lstRows.Count > 0)
                dtTable.Rows.Add(lstRows.ToArray());

            lstRows.Clear();
        }
    }

    // Assuming dataGridView1 is a DataGridView control on a Form
    dataGridView1.DataSource = dtTable;
}

private void button1_Click(object sender, EventArgs e)
{
    ReadExcelNPOI();
}

Public Sub ReadExcelNPOI()
	Dim dtTable As New DataTable()
	Dim lstRows As New List(Of String)()
	Dim objWorksheet As ISheet
	Dim strPath As String = "c:\temp\NPOI_Test.XLSX"

	' Use FileStream to open the Excel file
	Using fStream = New FileStream(strPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
		fStream.Position = 0
		Dim objWorkbook As New XSSFWorkbook(fStream)
		objWorksheet = objWorkbook.GetSheetAt(0)
		Dim objHeader As IRow = objWorksheet.GetRow(0)
		Dim countCells As Integer = objHeader.LastCellNum

		' Add columns to the DataTable based on the header row of Excel
		For j As Integer = 0 To countCells - 1
			Dim objCell As ICell = objHeader.GetCell(j)
			If objCell Is Nothing OrElse String.IsNullOrWhiteSpace(DirectCast(objCell, Object).ToString()) Then
				Continue For
			End If
			If True Then
				dtTable.Columns.Add(DirectCast(objCell, Object).ToString())
			End If
		Next j

		' Add rows to the DataTable, looping through each row and cell
		For i As Integer = (objWorksheet.FirstRowNum + 1) To objWorksheet.LastRowNum
			Dim objRow As IRow = objWorksheet.GetRow(i)
			If objRow Is Nothing OrElse objRow.Cells.All(Function(d) d.CellType = CellType.Blank) Then
				Continue For
			End If

			For j As Integer = objRow.FirstCellNum To countCells - 1
				Dim cell As ICell = objRow.GetCell(j)
				If cell IsNot Nothing AndAlso Not String.IsNullOrEmpty(DirectCast(cell, Object).ToString()) AndAlso Not String.IsNullOrWhiteSpace(DirectCast(cell, Object).ToString()) Then
					lstRows.Add(DirectCast(cell, Object).ToString())
				End If
			Next j

			If lstRows.Count > 0 Then
				dtTable.Rows.Add(lstRows.ToArray())
			End If

			lstRows.Clear()
		Next i
	End Using

	' Assuming dataGridView1 is a DataGridView control on a Form
	dataGridView1.DataSource = dtTable
End Sub

Private Sub button1_Click(ByVal sender As Object, ByVal e As EventArgs)
	ReadExcelNPOI()
End Sub

Public Sub ReadExcelNPOI()
	Dim dtTable As New DataTable()
	Dim lstRows As New List(Of String)()
	Dim objWorksheet As ISheet
	Dim strPath As String = "c:\temp\NPOI_Test.XLSX"

	' Use FileStream to open the Excel file
	Using fStream = New FileStream(strPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
		fStream.Position = 0
		Dim objWorkbook As New XSSFWorkbook(fStream)
		objWorksheet = objWorkbook.GetSheetAt(0)
		Dim objHeader As IRow = objWorksheet.GetRow(0)
		Dim countCells As Integer = objHeader.LastCellNum

		' Add columns to the DataTable based on the header row of Excel
		For j As Integer = 0 To countCells - 1
			Dim objCell As ICell = objHeader.GetCell(j)
			If objCell Is Nothing OrElse String.IsNullOrWhiteSpace(DirectCast(objCell, Object).ToString()) Then
				Continue For
			End If
			If True Then
				dtTable.Columns.Add(DirectCast(objCell, Object).ToString())
			End If
		Next j

		' Add rows to the DataTable, looping through each row and cell
		For i As Integer = (objWorksheet.FirstRowNum + 1) To objWorksheet.LastRowNum
			Dim objRow As IRow = objWorksheet.GetRow(i)
			If objRow Is Nothing OrElse objRow.Cells.All(Function(d) d.CellType = CellType.Blank) Then
				Continue For
			End If

			For j As Integer = objRow.FirstCellNum To countCells - 1
				Dim cell As ICell = objRow.GetCell(j)
				If cell IsNot Nothing AndAlso Not String.IsNullOrEmpty(DirectCast(cell, Object).ToString()) AndAlso Not String.IsNullOrWhiteSpace(DirectCast(cell, Object).ToString()) Then
					lstRows.Add(DirectCast(cell, Object).ToString())
				End If
			Next j

			If lstRows.Count > 0 Then
				dtTable.Rows.Add(lstRows.ToArray())
			End If

			lstRows.Clear()
		Next i
	End Using

	' Assuming dataGridView1 is a DataGridView control on a Form
	dataGridView1.DataSource = dtTable
End Sub

Private Sub button1_Click(ByVal sender As Object, ByVal e As EventArgs)
	ReadExcelNPOI()
End Sub

Reading an Excel file with IronXL

The following code demonstrates how to read an Excel file and display it inside a data grid view with IronXL. For more IronXL code examples, see the documentation. Add the following code and include the namespace:

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Imports IronXL
Imports System.Data

Notice the inclusion of IronXL. This is necessary for IronXL to work. Add the next few lines:

private void button2_Click(object sender, EventArgs e)
{
    // Load the Excel workbook
    string strPath = @"c:\temp\NPOI_Test.XLSX";
    WorkBook workbook = WorkBook.Load(strPath);

    // Access the default worksheet
    WorkSheet sheet = workbook.DefaultWorkSheet;

    // Convert the worksheet to a DataTable
    var dtTable = sheet.ToDataTable(true);

    // Assuming dataGridView1 is a DataGridView control on a Form
    dataGridView1.DataSource = dtTable;
}

private void button2_Click(object sender, EventArgs e)
{
    // Load the Excel workbook
    string strPath = @"c:\temp\NPOI_Test.XLSX";
    WorkBook workbook = WorkBook.Load(strPath);

    // Access the default worksheet
    WorkSheet sheet = workbook.DefaultWorkSheet;

    // Convert the worksheet to a DataTable
    var dtTable = sheet.ToDataTable(true);

    // Assuming dataGridView1 is a DataGridView control on a Form
    dataGridView1.DataSource = dtTable;
}

Private Sub button2_Click(ByVal sender As Object, ByVal e As EventArgs)
	' Load the Excel workbook
	Dim strPath As String = "c:\temp\NPOI_Test.XLSX"
	Dim workbook As WorkBook = WorkBook.Load(strPath)

	' Access the default worksheet
	Dim sheet As WorkSheet = workbook.DefaultWorkSheet

	' Convert the worksheet to a DataTable
	Dim dtTable = sheet.ToDataTable(True)

	' Assuming dataGridView1 is a DataGridView control on a Form
	dataGridView1.DataSource = dtTable
End Sub

Private Sub button2_Click(ByVal sender As Object, ByVal e As EventArgs)
	' Load the Excel workbook
	Dim strPath As String = "c:\temp\NPOI_Test.XLSX"
	Dim workbook As WorkBook = WorkBook.Load(strPath)

	' Access the default worksheet
	Dim sheet As WorkSheet = workbook.DefaultWorkSheet

	' Convert the worksheet to a DataTable
	Dim dtTable = sheet.ToDataTable(True)

	' Assuming dataGridView1 is a DataGridView control on a Form
	dataGridView1.DataSource = dtTable
End Sub

As you can see, IronXL reduces the read-and-display operation to roughly 5 lines of code compared to NPOI's 40+, eliminating the manual row iteration and cell-by-cell extraction loop entirely. Browse the full set of IronXL feature guides for more streamlined approaches to common Excel tasks.

Which Library Should You Choose?

NPOI provides a solid, well-established open-source foundation for Excel manipulation in .NET - its heritage as a port of Apache POI means it benefits from years of community contributions and broad format coverage. For teams whose primary requirement is reading and writing spreadsheets in a free, community-driven package, NPOI is a dependable choice.

Where teams often hit friction is in the amount of boilerplate code NPOI requires for common operations. As the read-file example above illustrates, IronXL's approach requires roughly 5 lines of code versus NPOI's 40+ lines for the same operation - loading a workbook and displaying it in a data grid - eliminating the manual row-and-cell iteration loop entirely. That reduction in code surface area is an investment that pays off through easier maintenance and fewer places for bugs to hide.

IronXL also includes professional support, consistent update schedules, and the ability to request features directly from Iron Software engineers. Community-driven projects offer different trade-offs in this regard: broader contributor input, but less predictable response times for specific issues.

Beyond license cost, total project cost includes the developer hours spent writing and maintaining the additional boilerplate that NPOI's lower-level API requires, as well as debugging the manual data-mapping logic shown in the examples above. For teams evaluating cost over a multi-year project lifecycle, these development and maintenance costs frequently eclipse the difference between open-source and commercial licensing.

Downloads

This project is available on GitHub:

IronXL vs NPOI Example

Ready to see the difference in your own project? Start a free 30-day IronXL trial to run these examples locally.

Please note: NPOI is a registered trademark of its respective owner. This site is not affiliated with, endorsed by, or sponsored by NPOI. All product names, logos, and brands are property of their respective owners. Comparisons are for informational purposes only and reflect publicly available information at the time of writing.

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.

...