CSV (Comma Separated Values) files are everywhere in business applications, ranging from financial reports to customer data exports. The CSV format is deceptively simple on the surface, but parsing it in production code can become difficult quickly when dealing with quoted fields, multiple delimiter types, embedded newlines, and the need to convert raw text into strongly-typed .NET objects. IronXL is a .NET library that provides enterprise-ready CSV handling, allowing developers to convert CSV data into Excel, XML, or other formats with minimal code.
This guide walks you through how IronXL works as a C# CSV file reader and how you can implement it in your .NET 10 applications. Try out IronXL for yourself with a free trial license and follow along to learn how it handles CSV and Excel tasks.
Getting IronXL into your project takes only a moment. You can install it through the NuGet Package Manager in Visual Studio, or via the command line using either the .NET CLI or the NuGet Package Manager Console in PowerShell. Both approaches install the same package and work with any .NET 10 project type.
For more detail on installation options and configuration, see the IronXL installation documentation.
Once installed, reading your first CSV file requires very little code. The example below uses .NET 10 top-level statements:
using IronXL;
// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read a specific cell
string cellValue = sheet["A1"].StringValue;
// Iterate through all rows and cells
foreach (var row in sheet.Rows)
{
foreach (var cell in row)
{
Console.WriteLine(cell.StringValue);
}
}Imports IronXL
' Load CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read a specific cell
Dim cellValue As String = sheet("A1").StringValue
' Iterate through all rows and cells
For Each row In sheet.Rows
For Each cell In row
Console.WriteLine(cell.StringValue)
Next
NextThe WorkBook.LoadCSV method handles header identification, creates an internal data structure, and performs memory-efficient parsing -- simplifying your data management from the first line of code.
Real-world CSV files do not always use commas. Semicolons, pipes, and tabs are common alternatives, especially in international datasets where commas serve as decimal separators. IronXL handles any delimiter through its flexible loading options.
using IronXL;
// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: ";");
// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: "\t");
// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: "|");
// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();
Console.WriteLine($"Total sales: {totalSales}");Imports IronXL
' Load CSV with semicolon delimiter (common in European data exports)
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=";")
' Load tab-separated values (TSV)
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=vbTab)
' Load pipe-delimited file
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("log_export.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:="|")
' Access data normally after loading
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()
Console.WriteLine($"Total sales: {totalSales}")The listDelimiter parameter accepts any string, giving you complete control over parsing behavior. IronXL preserves column values and data types during parsing -- numeric values remain numbers, dates stay as DateTime objects, and formulas maintain their relationships.
For files with inconsistent formatting, IronXL's error handling manages malformed rows without crashing the application, so valid data continues to be processed even when individual rows are problematic.
IronXL supports loading the following delimiter types when reading CSV files:
| Delimiter | Character | Common Use Case |
|---|---|---|
| Comma | , | Standard CSV, US-locale exports |
| Semicolon | ; | European locale exports (where comma is decimal separator) |
| Tab | \t | Tab-separated values (TSV), database exports |
| Pipe | | | Log files, system exports |
| Custom string | Any | Proprietary data formats, multi-character delimiters |
Transforming CSV rows into strongly-typed objects simplifies data processing and enables LINQ operations. IronXL makes this mapping straightforward through its cell access methods. The following code demonstrates how to map a CSV file into a list of typed objects using .NET 10 top-level statements:
using IronXL;
// Define a typed model matching your CSV structure
public record Product(string Name, decimal Price, int Stock, DateTime? LastUpdated);
// Load and parse CSV file
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
var products = new List<Product>();
// Start from row 2 to skip the header row
for (int row = 2; row <= sheet.RowCount; row++)
{
products.Add(new Product(
Name: sheet[$"A{row}"].StringValue,
Price: sheet[$"B{row}"].DecimalValue,
Stock: sheet[$"C{row}"].IntValue,
LastUpdated: sheet[$"D{row}"].DateTimeValue
));
}
// Use LINQ for analysis after loading
var lowStock = products.Where(p => p.Stock < 10).ToList();
var highValue = products.Where(p => p.Price > 100m).OrderByDescending(p => p.Price).ToList();
Console.WriteLine($"Products with low stock: {lowStock.Count}");
Console.WriteLine($"High-value products: {highValue.Count}");Imports IronXL
' Define a typed model matching your CSV structure
Public Class Product
Public Property Name As String
Public Property Price As Decimal
Public Property Stock As Integer
Public Property LastUpdated As DateTime?
Public Sub New(name As String, price As Decimal, stock As Integer, lastUpdated As DateTime?)
Me.Name = name
Me.Price = price
Me.Stock = stock
Me.LastUpdated = lastUpdated
End Sub
End Class
' Load and parse CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim products As New List(Of Product)()
' Start from row 2 to skip the header row
For row As Integer = 2 To sheet.RowCount
products.Add(New Product(
Name:=sheet($"A{row}").StringValue,
Price:=sheet($"B{row}").DecimalValue,
Stock:=sheet($"C{row}").IntValue,
LastUpdated:=sheet($"D{row}").DateTimeValue
))
Next
' Use LINQ for analysis after loading
Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
Dim highValue = products.Where(Function(p) p.Price > 100D).OrderByDescending(Function(p) p.Price).ToList()
Console.WriteLine($"Products with low stock: {lowStock.Count}")
Console.WriteLine($"High-value products: {highValue.Count}")IronXL's typed value properties -- StringValue, DecimalValue, IntValue, DateTimeValue -- handle conversions safely, returning default values for invalid data rather than throwing exceptions. This defensive approach ensures applications handle imperfect data without disruption. It pairs naturally with C# record types, which were introduced in C# 9 and provide a concise, immutable data model for mapped CSV rows.
The IronXL features page provides a full overview of the value accessor types available for reading cell data.
Once CSV data is loaded into a WorkSheet, you can work with it using range selectors or convert it to objects for LINQ queries. For straightforward column operations, range-based access is the most direct path:
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("sales-data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read entire columns using range notation
var productNames = sheet["A2:A100"]
.Select(cell => cell.StringValue)
.Where(name => !string.IsNullOrEmpty(name))
.ToList();
// Aggregate numeric columns directly
decimal totalRevenue = sheet["C2:C100"].Sum();
decimal averageOrder = sheet["C2:C100"].Avg();
Console.WriteLine($"Products loaded: {productNames.Count}");
Console.WriteLine($"Total revenue: {totalRevenue:C}");
Console.WriteLine($"Average order value: {averageOrder:C}");Imports IronXL
Dim workbook As WorkBook = WorkBook.LoadCSV("sales-data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read entire columns using range notation
Dim productNames = sheet("A2:A100") _
.Select(Function(cell) cell.StringValue) _
.Where(Function(name) Not String.IsNullOrEmpty(name)) _
.ToList()
' Aggregate numeric columns directly
Dim totalRevenue As Decimal = sheet("C2:C100").Sum()
Dim averageOrder As Decimal = sheet("C2:C100").Avg()
Console.WriteLine($"Products loaded: {productNames.Count}")
Console.WriteLine($"Total revenue: {totalRevenue:C}")
Console.WriteLine($"Average order value: {averageOrder:C}")This range-based approach avoids row-by-row iteration for simple aggregations, which improves performance on larger files. See the IronXL docs for the full list of supported range operations.
Many business workflows require CSV data in Excel format for advanced analysis, formatting, or distribution. IronXL makes this conversion straightforward while preserving all data integrity.
using IronXL;
// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;
// Apply formatting before saving
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";
// Apply currency format to price column
sheet["B2:B1000"].FormatString = "$#,##0.00";
// Apply date format to date column
sheet["D2:D1000"].FormatString = "yyyy-MM-dd";
// Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx");
Console.WriteLine("Conversion complete: monthly-report.xlsx");Imports IronXL
' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")
Dim sheet As WorkSheet = csvWorkbook.DefaultWorkSheet
' Apply formatting before saving
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.BackgroundColor = "#4472C4"
sheet("A1:D1").Style.Font.Color = "#FFFFFF"
' Apply currency format to price column
sheet("B2:B1000").FormatString = "$#,##0.00"
' Apply date format to date column
sheet("D2:D1000").FormatString = "yyyy-MM-dd"
' Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx")
Console.WriteLine("Conversion complete: monthly-report.xlsx")The conversion preserves numeric precision, date formats, and special characters that often cause issues with manual conversion methods. IronXL automatically optimizes the resulting Excel file structure, creating efficient files that open quickly even with large datasets.
For additional control over the output format, the export how-to guide covers options including XLSX, XLS, CSV, and PDF export. You can also learn how to write Excel files and create Excel files from scratch.
When you need to load CSV data into a DataSet for further processing or database insertion, IronXL provides direct conversion support. The Excel to DataSet guide explains this in detail:
using IronXL;
using System.Data;
WorkBook workbook = WorkBook.LoadCSV("customer-export.csv");
// Convert entire workbook to DataSet
DataSet dataSet = workbook.ToDataSet();
// The first sheet becomes the first DataTable
DataTable customerTable = dataSet.Tables[0];
Console.WriteLine($"Rows loaded: {customerTable.Rows.Count}");
Console.WriteLine($"Columns: {customerTable.Columns.Count}");
// Process with standard ADO.NET
foreach (DataRow row in customerTable.Rows)
{
string name = row["Name"]?.ToString() ?? string.Empty;
string email = row["Email"]?.ToString() ?? string.Empty;
Console.WriteLine($"Customer: {name} <{email}>");
}Imports IronXL
Imports System.Data
Dim workbook As WorkBook = WorkBook.LoadCSV("customer-export.csv")
' Convert entire workbook to DataSet
Dim dataSet As DataSet = workbook.ToDataSet()
' The first sheet becomes the first DataTable
Dim customerTable As DataTable = dataSet.Tables(0)
Console.WriteLine($"Rows loaded: {customerTable.Rows.Count}")
Console.WriteLine($"Columns: {customerTable.Columns.Count}")
' Process with standard ADO.NET
For Each row As DataRow In customerTable.Rows
Dim name As String = If(row("Name")?.ToString(), String.Empty)
Dim email As String = If(row("Email")?.ToString(), String.Empty)
Console.WriteLine($"Customer: {name} <{email}>")
NextThis approach integrates directly with ADO.NET workflows and is useful when pushing CSV data into SQL Server, SQLite, or other relational databases through standard data adapters. Because DataSet and DataTable are core .NET types, this path requires no additional dependencies beyond IronXL itself.
Processing large CSV files -- tens of thousands of rows or more -- requires attention to how data is accessed and how memory is managed. IronXL includes features that help with large-file scenarios.
For optimal performance with large datasets, use range operations instead of accessing individual cells one at a time. Range operations are processed more efficiently by IronXL's internal engine:
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;
Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns");
// Efficient: read entire range at once
var allData = sheet[$"A1:{GetColumnLetter(colCount)}{rowCount}"]
.Select(cell => cell.StringValue)
.ToList();
// Efficient: aggregate a column without row-by-row iteration
decimal columnSum = sheet[$"B2:B{rowCount}"].Sum();
Console.WriteLine($"Column B total: {columnSum}");
static string GetColumnLetter(int col)
{
string result = string.Empty;
while (col > 0)
{
col--;
result = (char)('A' + col % 26) + result;
col /= 26;
}
return result;
}Imports IronXL
Dim workbook As WorkBook = WorkBook.LoadCSV("large-dataset.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount
Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns")
' Efficient: read entire range at once
Dim allData = sheet($"A1:{GetColumnLetter(colCount)}{rowCount}") _
.Select(Function(cell) cell.StringValue) _
.ToList()
' Efficient: aggregate a column without row-by-row iteration
Dim columnSum As Decimal = sheet($"B2:B{rowCount}").Sum()
Console.WriteLine($"Column B total: {columnSum}")
Private Shared Function GetColumnLetter(col As Integer) As String
Dim result As String = String.Empty
While col > 0
col -= 1
result = ChrW(AscW("A"c) + col Mod 26) & result
col \= 26
End While
Return result
End FunctionIronXL automatically handles text encoding variations (UTF-8, UTF-16, ASCII) when loading CSV files, ensuring international characters in column values display correctly without additional configuration. This is particularly important for files exported from systems in regions where UTF-8 BOM or alternative encodings are common.
When processing CSV files from untrusted or variable sources, wrapping operations in try-catch blocks provides an additional safety layer:
using IronXL;
string filePath = "user-uploaded-data.csv";
try
{
WorkBook workbook = WorkBook.LoadCSV(filePath);
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}");
for (int row = 2; row <= sheet.RowCount; row++)
{
string value = sheet[$"A{row}"].StringValue;
if (!string.IsNullOrWhiteSpace(value))
{
Console.WriteLine(value);
}
}
}
catch (IronXL.Exceptions.IronXLException ex)
{
Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}");
}
catch (IOException ex)
{
Console.WriteLine($"File access error: {ex.Message}");
}Imports IronXL
Module Module1
Sub Main()
Dim filePath As String = "user-uploaded-data.csv"
Try
Dim workbook As WorkBook = WorkBook.LoadCSV(filePath)
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}")
For row As Integer = 2 To sheet.RowCount
Dim value As String = sheet($"A{row}").StringValue
If Not String.IsNullOrWhiteSpace(value) Then
Console.WriteLine(value)
End If
Next
Catch ex As IronXL.Exceptions.IronXLException
Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}")
Catch ex As IOException
Console.WriteLine($"File access error: {ex.Message}")
End Try
End Sub
End ModuleThe IronXL how-to guides cover data import patterns for various sources, including files, streams, and byte arrays.
IronXL operates independently of Microsoft Office, making it suitable for server environments and cloud deployments. Whether deploying to Windows, Linux, macOS, Docker containers, or cloud functions on Azure or AWS, IronXL delivers consistent results across all platforms without configuration changes.
This cross-platform capability is valuable for microservices architectures where lightweight containers handle data processing tasks. The IronXL features overview details the full list of supported environments and runtime targets.
IronXL requires a license key for use in production environments. A free trial license is available for evaluation, and commercial licenses are available for individual developers, teams, and organizations.
Apply the license key in your application before making any IronXL calls:
using IronXL;
// Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
// Verify the license is active
if (IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE"))
{
Console.WriteLine("IronXL license is active.");
}
// Now use IronXL normally
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows.");Imports IronXL
' Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
' Verify the license is active
If IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE") Then
Console.WriteLine("IronXL license is active.")
End If
' Now use IronXL normally
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows.")For trial and licensing options, visit the IronXL licensing page.
IronXL turns C# CSV file reading from a tedious parsing task into a straightforward operation. The library handles the common edge cases that manual parsing gets wrong -- embedded commas, newlines inside quoted fields, inconsistent delimiters, encoding variations, and malformed rows -- without requiring custom code for each scenario. Whether you need a quick one-off data import or a production pipeline processing thousands of files per day, the same API works in both contexts.
Manual CSV parsing with string.Split or StreamReader breaks down quickly when quoted fields contain the delimiter character, or when line breaks appear inside field values. IronXL handles these cases correctly by default, following the CSV specification for quoted field handling and escape sequences.
The key advantages that set IronXL apart for CSV work in .NET 10:
listDelimiter parameterStringValue, DecimalValue, IntValue, and DateTimeValue accessors return safe defaults instead of throwing on bad dataDataSet / DataTable for ADO.NET and database operationsThe IronXL documentation and cell formatting guide provide further details on formatting, formula support, and advanced workbook operations.
Ready to handle CSV files with confidence? Get started with a free trial and explore the full IronXL feature set.
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.
