Reading Excel Data in C#? Spire.XLS Makes It Easy!

Posted on by — No Comments ↓

In modern enterprise applications, Excel files play a critical role. Whether it’s data import, report generation, or data analysis, working with Excel data is unavoidable. For C# developers, efficiently and reliably reading Excel data in C# is often a challenge. Traditional approaches may rely on Microsoft Office COM components, which not only complicate deployment but can also introduce compatibility and performance issues.

This article introduces a powerful and professional .NET component— Spire.XLS for .NET . It helps you overcome these difficulties and makes reading Excel data in C# simple and efficient. We’ll walk through how to use the Spire.XLS for .NET library with clear, actionable steps and code examples to read the full contents of an Excel worksheet.

1. Getting Started with Spire.XLS for .NET

Spire.XLS for .NET, developed by E-iceblue, is a professional Excel processing library that allows developers to create, read, write, convert, and print Excel files in .NET applications—without requiring Microsoft Office.

Key benefits include:

  • No Office dependency: Runs independently without Office installed, simplifying deployment.
  • High performance: Optimized for handling large datasets with fast read/write speed.
  • Rich features: Supports Excel functionalities such as cell styles, formulas, charts, and comments.
  • Strong compatibility: Works with .NET Core, .NET Standard, .NET 5+, and traditional .NET Framework.

Installation

Installing Spire.XLS for .NET is straightforward. You can add it to your C# project via NuGet Package Manager.

  1. Open Visual Studio , right-click on “References” or “Dependencies” in your project, and select “Manage NuGet Packages.”
  2. In the Browse tab, search for Spire.XLS .
  3. Select the package and click Install .

Or, install it via the NuGet Package Manager Console: 

Install-Package Spire.XLS

Once installed, you can import the namespace in your code and begin your C# Excel operations .

2. Core Steps and Code for Reading an Entire Worksheet

Let’s look at an example of reading all data from the first worksheet of an Excel file using Spire.XLS for .NET.

Step Breakdown

  1. Load Excel file: Use a Workbook object to load the target file.
  2. Access worksheet: Retrieve the desired sheet from the Workbook.Worksheets collection.
  3. Iterate through rows and columns: Loop through each cell in the sheet.
  4. Extract cell data: Read the value from each cell.

Example Code

Suppose we have an Excel file named Sample.xlsx. The following code reads its first worksheet and prints all contents to the console: 

using System;
using Spire.Xls;

namespace ReadExcelDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Create a Workbook instance and load the Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("Sample.xlsx");

            // 2. Get the first worksheet (index starts from 0)
            Worksheet sheet = workbook.Worksheets[0];

            Console.WriteLine($"Reading worksheet: {sheet.Name}");
            Console.WriteLine("-----------------------------------");

            // 3. Iterate through all rows and columns
            for (int row = 1; row <= sheet.LastRow; row++)
            {
                for (int col = 1; col <= sheet.LastColumn; col++)
                {
                    // 4. Get the cell and extract its value
                    CellRange cell = sheet.Range[row, col];
                    Console.Write($"{cell.Text}t");
                }
                Console.WriteLine();
            }

            Console.WriteLine("-----------------------------------");
            Console.WriteLine("Excel reading complete!");

            // Release resources
            workbook.Dispose();
            Console.ReadKey();
        }
    }
}

Key classes and properties explained:

  • Workbook – represents an Excel workbook file.
  • Workbook.LoadFromFile(string filePath) – loads an Excel file from a specified path.
  • Workbook.Worksheets – a collection of all worksheets in the workbook.
  • Worksheet – represents an Excel sheet.
  • Worksheet.LastRow / LastColumn – returns the index of the last row/column containing data.
  • Worksheet.Range[row, column] – retrieves a CellRange object for the given cell.
  • CellRange.Text – formatted display text of a cell.
  • CellRange.Value – raw value of a cell (string, number, date, etc.).

With this, you’ve learned the basic approach for parsing Excel in C# using Spire.XLS.

3. Common Reading Scenarios and Advanced Tips

Beyond reading an entire worksheet, Spire.XLS offers flexible data access options:

  • Access specific cells/ranges:
    • Get value of cell A1: string value = sheet.Range["A1"].Text;
    • Get numeric value of cell B2: double number = sheet.Range["B2"].NumberValue;
    • Get a range: CellRange range = sheet.Range["A1:C5"]; and iterate over its cells.

  • Work with data types: Spire.XLS automatically detects data types. Use CellRange.Value for raw values or properties like NumberValue, DateTimeValue, etc., for typed values.

  • Error handling: Wrap your code in try-catch blocks to handle missing files, corrupted data, or permission issues.

  • Performance optimization: For large datasets (hundreds of thousands of rows), consider batch reading or leveraging Spire.XLS’s advanced import/export functions, such as loading directly into a DataTable.

Conclusion

In this guide, we showed how to easily read Excel data in C# using the powerful Spire.XLS library. From installation to core examples, we demonstrated its intuitive API and robust features. Whether your use case involves data import, reporting, or analytics, Spire.XLS for .NET provides an efficient, reliable solution—freeing you from the limitations of traditional methods.

Leave a Reply