C# CSV File Reader Tutorial: Parse and Convert CSV Data with IronXL

Why Choose IronXL for CSV Reading?

IronXL turns CSV file reading from a parsing headache into straightforward operations. Unlike manual split operations or basic new StreamReader approaches, IronXL automatically handles edge cases like embedded commas, new lines, and columns separated by unusual delimiters.

The library operates independently of Microsoft Office, making it perfect for server environments and cloud deployments. Whether deploying to Windows, Linux, macOS, Azure, or AWS, IronXL delivers consistent results across all platforms. This cross-platform compatibility, combined with its intuitive API, makes it the ideal choice for modern C# applications requiring reliable CSV parsing.

IronXL treats CSV files as first-class citizens alongside Excel formats, enabling seamless transitions between file types without data loss or format issues. Beyond simple CSV reading, IronXL is also capable of using C# for write CSV files from scratch. Be sure to check out our How-to guide to learn more about this. This makes it the perfect library for all your CSV needs, capable of everything from reading and creating CSV files to converting them to any of the supported formats.

Getting Started: Installing IronXL

Installing IronXL takes just moments through Visual Studio's NuGet Package Manager. Open your project, right-click on References in Solution Explorer, and select "Manage NuGet Packages." Search for "IronXL.Excel" and click "Install".

For detailed installation guidance, visit the IronXL installation documentation.

Once installed, reading your first CSV file requires minimal source code, as seen in the following example:

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 rows
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}

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 rows
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}

In this example, the var reader accesses CSV data as string arrays. The WorkBook.LoadCSV method handles header identification, creates a new data table, and performs memory-efficient parsing, simplifying your data structure management.

How to Read Data from CSV Files with Different Delimiters?

Real-world CSV files don't always use commas. Semicolons, pipes, and tabs are common alternatives, especially in international datasets where commas serve as decimal separators. IronXL elegantly handles any delimiter through its flexible loading options.

using IronXL;
// Load CSV with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
// Load tab-separated values
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: "\t");
// Access data normally
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

using IronXL;
// Load CSV with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
// Load tab-separated values
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: "\t");
// Access data normally
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

The listDelimiter parameter accepts any string, providing 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. This automatic type preservation eliminates manual conversion code and reduces errors.

For files with inconsistent formatting, IronXL's error handling gracefully manages malformed rows without crashing, logging issues for review while continuing to process valid data.

How to Parse CSV Data into C# Objects?

Transforming CSV rows into strongly-typed objects streamlines data processing and enables LINQ operations. IronXL makes this mapping straightforward through its cell access methods. The following code shows how to make a simple CSV parser to handle this:

using IronXL;
public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime? LastUpdated { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Parse CSV into objects
        var products = new List<Product>();
        WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Skip first line (header), parse remaining lines
        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
        var lowStock = products.Where(p => p.Stock < 10).ToList();
    }
}

using IronXL;
public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime? LastUpdated { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Parse CSV into objects
        var products = new List<Product>();
        WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Skip first line (header), parse remaining lines
        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
        var lowStock = products.Where(p => p.Stock < 10).ToList();
    }
}

IronXL's typed value properties (StringValue, DecimalValue, IntValue, DateTimeValue) handle conversions safely, returning default values for invalid data rather than throwing exceptions. This avoids tedious manual work, such as creating a new string for each property after parsing. This defensive approach ensures robust applications that handle imperfect data gracefully.

The library also supports nullable types and custom parsing logic when needed, allowing for the accommodation of complex business rules without sacrificing simplicity.

How to Convert CSV to Excel Format?

Many business workflows require CSV data in Excel format for advanced analysis, formatting, or distribution to stakeholders. IronXL makes this conversion trivial while preserving all data integrity.

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
// Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx");
// Add formatting before saving
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;
sheet["A1:D1"].Style.Font.Bold = true;
sheet["B:B"].FormatString = "$#,##0.00";  // Currency format

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
// Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx");
// Add formatting before saving
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;
sheet["A1:D1"].Style.Font.Bold = true;
sheet["B:B"].FormatString = "$#,##0.00";  // Currency format

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.

This seamless conversion capability enables automated reporting pipelines where CSV data from various sources transforms into polished Excel reports ready for executive review.

Best Practices and Advanced Features

IronXL features several advanced enhancements that improve the reliability of CSV processing. The library automatically handles various text encodings (UTF-8, UTF-16, ASCII), ensuring international string values and columns display correctly. Memory-efficient streaming processes large CSV files without loading all data into RAM simultaneously.

When processing CSV files from untrusted sources, wrap operations in try-catch (Exception ex) blocks for additional safety. For comprehensive error handling strategies, review the IronXL troubleshooting guides.

For optimal performance with large datasets, use range operations (sheet["A1:Z1000"]) instead of accessing individual data table rows or an entire string column cell by cell. IronXL's formula engine also works with CSV data, enabling calculations without converting to Excel first. The library's cross-platform support extends beyond basic compatibility. Docker containers, Linux servers, and cloud functions all run IronXL without configuration changes, making it ideal for microservices architectures.

The library's cross-platform support extends beyond basic compatibility. Docker containers, Linux servers, and cloud functions all run IronXL without configuration changes, making it ideal for microservices architectures.

Conclusion

IronXL transforms C# CSV file reading from a tedious task into a reliable, enterprise-ready solution. Its automatic CSV parsing, data structure management, and seamless Excel conversion capabilities make it the top choice for developers handling CSV files, datatable dt, or CSV data in modern .NET applications.

Ready to streamline your CSV processing? Get IronXL today and experience enterprise-grade data handling in your applications.