How to Read a CSV File in C# Using IronXL

<PackageReference Include="IronXL.Excel" Version="2025.*" />

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);
    }
}

// Apply aggregate functions
decimal total = sheet["B:B"].Sum();
decimal average = sheet["B:B"].Avg();

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 rows
For Each row In sheet.Rows
    For Each cell In row
        Console.WriteLine(cell.StringValue)
    Next
Next

' Apply aggregate functions
Dim total As Decimal = sheet("B:B").Sum()
Dim average As Decimal = sheet("B:B").Avg()

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");

// Load pipe-delimited files
WorkBook pipeWorkbook = WorkBook.LoadCSV("legacy_export.txt", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: "|");

// Access data normally
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

// Apply math functions for analysis
decimal maxValue = sheet["C:C"].Max();
decimal minValue = sheet["C:C"].Min();

Imports IronXL

' Load CSV with semicolon delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv", 
    fileFormat:=ExcelFileFormat.XLSX, 
    listDelimiter:=";")

' Load tab-separated values
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv", 
    fileFormat:=ExcelFileFormat.XLSX, 
    listDelimiter:=vbTab)

' Load pipe-delimited files
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("legacy_export.txt", 
    fileFormat:=ExcelFileFormat.XLSX, 
    listDelimiter:="|")

' Access data normally
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()

' Apply math functions for analysis
Dim maxValue As Decimal = sheet("C:C").Max()
Dim minValue As Decimal = sheet("C:C").Min()

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 with validation
        var products = new List<Product>();
        WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
        WorkSheet sheet = workbook.DefaultWorkSheet;

        // Skip header row, parse remaining lines
        for (int row = 2; row <= sheet.RowCount; row++)
        {
            try
            {
                var product = new Product
                {
                    Name = sheet[$"A{row}"].StringValue,
                    Price = sheet[$"B{row}"].DecimalValue,
                    Stock = sheet[$"C{row}"].IntValue,
                    LastUpdated = sheet[$"D{row}"].DateTimeValue
                };

                // Validate data
                if (product.Price > 0 && !string.IsNullOrWhiteSpace(product.Name))
                {
                    products.Add(product);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error parsing row {row}: {ex.Message}");
            }
        }

        // Use LINQ for analysis
        var lowStock = products.Where(p => p.Stock < 10).ToList();
        var totalInventoryValue = products.Sum(p => p.Price * p.Stock);

        // Export results to new Excel file
        var reportWorkbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var reportSheet = reportWorkbook.CreateWorkSheet("Low Stock Report");

        // Add headers with formatting
        reportSheet["A1"].Value = "Product Name";
        reportSheet["B1"].Value = "Current Stock";
        reportSheet["C1"].Value = "Unit Price";
        reportSheet["A1:C1"].Style.Font.Bold = true;

        // Add data
        int reportRow = 2;
        foreach (var item in lowStock)
        {
            reportSheet[$"A{reportRow}"].Value = item.Name;
            reportSheet[$"B{reportRow}"].Value = item.Stock;
            reportSheet[$"C{reportRow}"].Value = item.Price;
            reportRow++;
        }

        reportWorkbook.SaveAs("low_stock_alert.xlsx");
    }
}

Imports IronXL

Public Class Product
    Public Property Name As String
    Public Property Price As Decimal
    Public Property Stock As Integer
    Public Property LastUpdated As DateTime?
End Class

Module Program
    Sub Main(args As String())
        ' Parse CSV into objects with validation
        Dim products As New List(Of Product)()
        Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet

        ' Skip header row, parse remaining lines
        For row As Integer = 2 To sheet.RowCount
            Try
                Dim product As New Product With {
                    .Name = sheet($"A{row}").StringValue,
                    .Price = sheet($"B{row}").DecimalValue,
                    .Stock = sheet($"C{row}").IntValue,
                    .LastUpdated = sheet($"D{row}").DateTimeValue
                }

                ' Validate data
                If product.Price > 0 AndAlso Not String.IsNullOrWhiteSpace(product.Name) Then
                    products.Add(product)
                End If
            Catch ex As Exception
                Console.WriteLine($"Error parsing row {row}: {ex.Message}")
            End Try
        Next

        ' Use LINQ for analysis
        Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
        Dim totalInventoryValue = products.Sum(Function(p) p.Price * p.Stock)

        ' Export results to new Excel file
        Dim reportWorkbook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim reportSheet = reportWorkbook.CreateWorkSheet("Low Stock Report")

        ' Add headers with formatting
        reportSheet("A1").Value = "Product Name"
        reportSheet("B1").Value = "Current Stock"
        reportSheet("C1").Value = "Unit Price"
        reportSheet("A1:C1").Style.Font.Bold = True

        ' Add data
        Dim reportRow As Integer = 2
        For Each item In lowStock
            reportSheet($"A{reportRow}").Value = item.Name
            reportSheet($"B{reportRow}").Value = item.Stock
            reportSheet($"C{reportRow}").Value = item.Price
            reportRow += 1
        Next

        reportWorkbook.SaveAs("low_stock_alert.xlsx")
    End Sub
End Module

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");

// Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx");

// Add advanced formatting before saving
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;

// Apply header styling
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

// Format currency columns
sheet["B:B"].FormatString = "$#,##0.00";

// Add borders to data range
var dataRange = sheet["A1:D100"];
dataRange.Style.Border.SetBorder(BorderType.AllBorders, BorderStyle.Thin, "#000000");

// Autosize columns for better readability
sheet.AutoSizeColumn(0); // Column A
sheet.AutoSizeColumn(1); // Column B
sheet.AutoSizeColumn(2); // Column C
sheet.AutoSizeColumn(3); // Column D

// Add a summary chart
var chart = sheet.CreateChart(ChartType.Column, 10, 5);
chart.AddSeries("B2:B10", "A2:A10");
chart.SetTitle("Monthly Sales Summary");
chart.Plot();

// Add data validation
sheet["E2:E100"].DataValidation.AllowList = new string[] { "Approved", "Pending", "Rejected" };

// Save the enhanced Excel file
csvWorkbook.SaveAs("monthly-report-formatted.xlsx");

' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")

' Save as Excel with single method call
csvWorkbook.SaveAs("monthly-report.xlsx")

' Add advanced formatting before saving
Dim sheet As WorkSheet = csvWorkbook.DefaultWorkSheet

' Apply header styling
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.BackgroundColor = "#4472C4"
sheet("A1:D1").Style.Font.Color = "#FFFFFF"

' Format currency columns
sheet("B:B").FormatString = "$#,##0.00"

' Add borders to data range
Dim dataRange = sheet("A1:D100")
dataRange.Style.Border.SetBorder(BorderType.AllBorders, BorderStyle.Thin, "#000000")

' Autosize columns for better readability
sheet.AutoSizeColumn(0) ' Column A
sheet.AutoSizeColumn(1) ' Column B
sheet.AutoSizeColumn(2) ' Column C
sheet.AutoSizeColumn(3) ' Column D

' Add a summary chart
Dim chart = sheet.CreateChart(ChartType.Column, 10, 5)
chart.AddSeries("B2:B10", "A2:A10")
chart.SetTitle("Monthly Sales Summary")
chart.Plot()

' Add data validation
sheet("E2:E100").DataValidation.AllowList = New String() {"Approved", "Pending", "Rejected"}

' Save the enhanced Excel file
csvWorkbook.SaveAs("monthly-report-formatted.xlsx")

using IronXL;
using System.Diagnostics;

public class CSVProcessor
{
    private readonly ILogger _logger;

    public async Task<ProcessingResult> ProcessCSVBatch(string[] filePaths)
    {
        var results = new List<FileResult>();
        var stopwatch = Stopwatch.StartNew();

        foreach (var filePath in filePaths)
        {
            try
            {
                var fileStopwatch = Stopwatch.StartNew();
                var workbook = WorkBook.LoadCSV(filePath);
                var sheet = workbook.DefaultWorkSheet;

                // Process data
                var recordCount = sheet.RowCount - 1; // Exclude header
                var processedRecords = 0;

                for (int row = 2; row <= sheet.RowCount; row++)
                {
                    try
                    {
                        // Your processing logic here
                        processedRecords++;
                    }
                    catch (Exception rowEx)
                    {
                        _logger.LogWarning($"Failed to process row {row} in {filePath}: {rowEx.Message}");
                    }
                }

                results.Add(new FileResult
                {
                    FileName = filePath,
                    Success = true,
                    RecordsProcessed = processedRecords,
                    ProcessingTime = fileStopwatch.ElapsedMilliseconds
                });

                _logger.LogInformation($"Processed {filePath}: {processedRecords}/{recordCount} records in {fileStopwatch.ElapsedMilliseconds}ms");
            }
            catch (Exception ex)
            {
                _logger.LogError($"Failed to process {filePath}: {ex.Message}");
                results.Add(new FileResult
                {
                    FileName = filePath,
                    Success = false,
                    Error = ex.Message
                });
            }
        }

        return new ProcessingResult
        {
            FileResults = results,
            TotalProcessingTime = stopwatch.ElapsedMilliseconds,
            SuccessRate = (decimal)results.Count(r => r.Success) / results.Count
        };
    }
}

Imports IronXL
Imports System.Diagnostics

Public Class CSVProcessor
    Private ReadOnly _logger As ILogger

    Public Async Function ProcessCSVBatch(filePaths As String()) As Task(Of ProcessingResult)
        Dim results As New List(Of FileResult)()
        Dim stopwatch = Stopwatch.StartNew()

        For Each filePath In filePaths
            Try
                Dim fileStopwatch = Stopwatch.StartNew()
                Dim workbook = WorkBook.LoadCSV(filePath)
                Dim sheet = workbook.DefaultWorkSheet

                ' Process data
                Dim recordCount = sheet.RowCount - 1 ' Exclude header
                Dim processedRecords = 0

                For row As Integer = 2 To sheet.RowCount
                    Try
                        ' Your processing logic here
                        processedRecords += 1
                    Catch rowEx As Exception
                        _logger.LogWarning($"Failed to process row {row} in {filePath}: {rowEx.Message}")
                    End Try
                Next

                results.Add(New FileResult With {
                    .FileName = filePath,
                    .Success = True,
                    .RecordsProcessed = processedRecords,
                    .ProcessingTime = fileStopwatch.ElapsedMilliseconds
                })

                _logger.LogInformation($"Processed {filePath}: {processedRecords}/{recordCount} records in {fileStopwatch.ElapsedMilliseconds}ms")
            Catch ex As Exception
                _logger.LogError($"Failed to process {filePath}: {ex.Message}")
                results.Add(New FileResult With {
                    .FileName = filePath,
                    .Success = False,
                    .Error = ex.Message
                })
            End Try
        Next

        Return New ProcessingResult With {
            .FileResults = results,
            .TotalProcessingTime = stopwatch.ElapsedMilliseconds,
            .SuccessRate = CDec(results.Count(Function(r) r.Success)) / results.Count
        }
    End Function
End Class