CSV Parser in C#

Why Does Basic String Splitting Fail?

Consider the most common beginner's approach to parse a CSV file:

string line = "John,Doe,30,Engineer";
string[] values = line.Split(','); // string array

string line = "John,Doe,30,Engineer";
string[] values = line.Split(','); // string array

This works perfectly for simple cases but immediately fails when encountering:

Quoted Fields with Embedded Commas: Real CSV files often contain fields like addresses or descriptions that include commas within the data itself. A CSV line such as "Smith, John",Developer,"New York, NY",50000 would be incorrectly split into five fields instead of four, corrupting the data structure and causing misalignment in subsequent processing.

Line Breaks Within Fields: According to RFC 4180, the CSV standard, fields can contain line breaks when properly quoted. A multi-line address field breaks any line-by-line reading approach, requiring sophisticated state management to track whether a line break occurs within a quoted field or represents a new record.

Escape Characters and Quote Handling: CSV files use various conventions for escaping quotes within quoted fields. Some use doubled quotes (""), while others use backslashes or other escape characters. Without proper handling, data like "She said, ""Hello!""",greeting becomes corrupted or causes parsing errors.

Different Delimiters and Encodings: Not all "CSV" files use commas. Tab-separated values (TSV), pipe-delimited files, and semicolon-separated values are common variations. Additionally, files may use different character encodings (UTF-8, UTF-16, ANSI), requiring proper detection and conversion to avoid data corruption, especially with international characters. The RFC 4180 standard defines CSV format specifications, but many implementations deviate from it.

Memory Management for Large Files: Loading a 500MB CSV file entirely into memory using File.ReadAllLines() can cause significant performance degradation or out-of-memory exceptions. Processing millions of rows requires streaming approaches and efficient memory management to maintain application responsiveness when using a C# CSV parser.

What Performance Issues Arise with Large Files?

Memory Management for Large Files: Loading a 500MB CSV file entirely into memory using File.ReadAllLines() can cause significant performance degradation or out-of-memory exceptions. Processing millions of rows requires streaming approaches and efficient memory management to maintain responsiveness. The latest performance improvements in IronXL achieved a 40x speed increase while reducing memory usage from 19.5 GB to under 1 GB.

These complexities compound when dealing with CSV files from different sources, each potentially using different conventions. Building a parser that handles all scenarios reliably requires substantial development effort and ongoing maintenance as new edge cases emerge. This is why many developers prefer using proven libraries like IronXL that handle complex Excel operations including CSV parsing.

What Core Features Make IronXL Different?

Recent Updates and Stability Improvements:IronXL continuously evolves through regular updates and community feedback. In recent releases, several key improvements and bug fixed updates have enhanced CSV parsing accuracy, file encoding detection, and memory efficiency. These updates ensure developers experience consistent results even when working with large or irregular datasets, eliminating many of the pitfalls found in earlier custom CSV implementations.

Intelligent Parsing Engine: IronXL's parser automatically detects and handles quoted fields, embedded delimiters, and line breaks within data. The engine adapts to different CSV dialects without requiring manual configuration, correctly interpreting files whether they follow strict RFC 4180 standards or use common variations.

Flexible Delimiter Support: While commas remain the default, IronXL easily handles any delimiter character through simple configuration options. Whether working with tab-separated files, pipe-delimited exports, or semicolon-separated European formats, the same clean API handles all variations consistently. See our CSV reading tutorial for detailed examples.

Excel Integration Excellence: Unlike standalone CSV parsers, IronXL provides seamless bidirectional conversion between CSV and Excel formats. This capability enables workflows where CSV data imports into Excel workbooks for advanced formatting, formula application, and chart generation—all programmatically through C# code.

Cross-Platform Reliability: IronXL runs consistently across Windows, Linux, and macOS environments, making it ideal for modern cloud-native applications. The library supports containerized deployments in Docker and Kubernetes, ensuring CSV processing logic works identically whether running on a developer's machine or in production containers on Azure or AWS.

Memory-Efficient Architecture: The library employs optimized memory management techniques that enable processing of large CSV files without excessive memory consumption. IronXL handles multi-gigabyte files through efficient streaming and buffering strategies, maintaining responsiveness even with millions of rows.

Why Choose IronXL for Cross-Platform Development?

Cross-Platform Reliability: IronXL runs consistently across Windows, Linux, and macOS, making it ideal for cloud-native applications. The library supports containerized deployments in Docker and Kubernetes, ensuring CSV processing works identically whether running locally or in production containers on Azure or AWS. For AWS Lambda deployments, IronXL provides specific optimization guidance.

Memory-Efficient Architecture: The library employs optimized memory management for processing large CSV files without excessive consumption. IronXL handles multi-gigabyte files through efficient streaming and buffering, maintaining responsiveness with millions of rows. These optimizations are crucial when working with large datasets and performing aggregation functions.

What Are the Installation Steps?

First, install IronXL through the NuGet Package Manager Console:

Install-Package IronXL.Excel

Alternatively, use the .NET CLI for modern .NET projects:

dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

For licensing setup and applying license keys, consult our licensing documentation. For web applications, you can configure the license key in Web.config.

How Do I Load My First CSV File?

Once installed, add the IronXL namespace to your C# files:

using IronXL;

using IronXL;

Let's start with a simple example demonstrating loading and reading a CSV file:

// Load a CSV file
var reader = WorkBook.LoadCSV("customers.csv");
// Access the default worksheet (CSV files have one sheet)
WorkSheet sheet = reader.DefaultWorkSheet;
// Read a specific cell value
string customerName = sheet["B2"].StringValue;
// Display the value
Console.WriteLine($"Customer: {customerName}");

// Load a CSV file
var reader = WorkBook.LoadCSV("customers.csv");
// Access the default worksheet (CSV files have one sheet)
WorkSheet sheet = reader.DefaultWorkSheet;
// Read a specific cell value
string customerName = sheet["B2"].StringValue;
// Display the value
Console.WriteLine($"Customer: {customerName}");

This code demonstrates key concepts. First, WorkBook.LoadCSV() intelligently parses the CSV file, automatically detecting delimiters and handling quoted fields. The method returns a WorkBook object, IronXL's primary container for spreadsheet data. Since CSV files contain single sheets, we access it through DefaultWorkSheet. Finally, we use Excel-style cell references to access values with type-safe accessors like StringValue. For advanced cell operations, explore our guides on cell formatting and cell data formats.

Input

Output

What's the Basic Approach to Reading CSV Data?

The most straightforward approach uses LoadCSV with default settings:

// Load CSV with automatic delimiter detection
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Iterate through rows
for (var row = 1; row <= sheet.RowCount; row++)
{
    // Read cells in the current row
    string productName = sheet[$"A{row}"].StringValue;
    decimal price = sheet[$"B{row}"].DecimalValue;
    int quantity = sheet[$"C{row}"].IntValue;
    Console.WriteLine($"Product: {productName}, Price: ${price}, Qty: {quantity}");
}

// Load CSV with automatic delimiter detection
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Iterate through rows
for (var row = 1; row <= sheet.RowCount; row++)
{
    // Read cells in the current row
    string productName = sheet[$"A{row}"].StringValue;
    decimal price = sheet[$"B{row}"].DecimalValue;
    int quantity = sheet[$"C{row}"].IntValue;
    Console.WriteLine($"Product: {productName}, Price: ${price}, Qty: {quantity}");
}

This example showcases row-by-row iteration through CSV data. Starting from row 1 (assuming headers in row 0), it processes each row sequentially. IronXL's typed accessors automatically convert text to appropriate .NET types, eliminating manual parsing. The loop continues through all rows using RowCount, which accurately reflects total data rows. For complex operations, you can add rows and columns or insert new rows dynamically.

How Do I Handle Non-Standard Delimiters?

For CSV files with non-standard delimiters, IronXL provides configuration options:

// Load a tab-separated file
WorkBook workbook = WorkBook.LoadCSV("inventory.tsv", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: "\t");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Process header row
var headers = new List<string>();
for (int col = 0; col < sheet.ColumnCount; col++)
{
    headers.Add(sheet.GetCellAt(0, col).StringValue);
}
// Display headers
Console.WriteLine("Columns: " + string.Join(" | ", headers));

// Load a tab-separated file
WorkBook workbook = WorkBook.LoadCSV("inventory.tsv", 
    fileFormat: ExcelFileFormat.XLSX, 
    listDelimiter: "\t");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Process header row
var headers = new List<string>();
for (int col = 0; col < sheet.ColumnCount; col++)
{
    headers.Add(sheet.GetCellAt(0, col).StringValue);
}
// Display headers
Console.WriteLine("Columns: " + string.Join(" | ", headers));

LoadCSV accepts optional parameters to customize parsing. The listDelimiter parameter specifies field separators—here, tabs for TSV files. The fileFormat parameter determines internal representation after parsing. This example demonstrates column iteration using numeric indices to build header lists. You can also autosize columns and set column widths programmatically.

Input

Output

What Range Operations Can I Perform?

Working with CSV data often requires range-based operations. For advanced operations, explore our Excel ranges tutorial:

var csv = WorkBook.LoadCSV("employees.csv");
WorkSheet sheet = csv.DefaultWorkSheet;
// Read a range of cells
var range = sheet["A2:D10"];
// Process all cells in the range
foreach (var cell in range)
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine($"Cell {cell.AddressString}: {cell.Text}");
    }
}
// Calculate sum of a numeric column
decimal totalSalary = sheet["E2:E100"].Sum();
Console.WriteLine($"Total Salary: ${totalSalary:N2}");

var csv = WorkBook.LoadCSV("employees.csv");
WorkSheet sheet = csv.DefaultWorkSheet;
// Read a range of cells
var range = sheet["A2:D10"];
// Process all cells in the range
foreach (var cell in range)
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine($"Cell {cell.AddressString}: {cell.Text}");
    }
}
// Calculate sum of a numeric column
decimal totalSalary = sheet["E2:E100"].Sum();
Console.WriteLine($"Total Salary: ${totalSalary:N2}");

Range operations provide powerful data processing capabilities. The range selector syntax mirrors Excel conventions, making it intuitive. The foreach loop iterates through range cells, with IsEmpty helping skip blanks efficiently. IronXL extends ranges with aggregate functions like Sum(), Average(), and Max(), enabling calculations without manual iteration. Check our API reference for available methods. You can also combine multiple ranges and sort data within ranges.

How Do I Process Files with Headers?

Handling CSV files with headers requires special consideration. The library provides methods to work with named ranges and create named tables for better organization:

WorkBook workbook = WorkBook.LoadCSV("products_with_headers.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Skip header row and process var data
for (int row = 1; row <= sheet.RowCount; row++)
{
    var rowData = sheet.GetRow(row);
    // Access cells by index based on known column positions
    string sku = rowData.Columns[0].StringValue;      // Column A
    string description = rowData.Columns[1].StringValue; // Column B
    decimal cost = rowData.Columns[2].DecimalValue;    // Column C
    // Process the data
    ProcessProduct(sku, description, cost);
}
void ProcessProduct(string sku, string description, decimal cost)
{
    // Business logic here
    Console.WriteLine($"Processing: {sku} - {description} (${cost})");
}

WorkBook workbook = WorkBook.LoadCSV("products_with_headers.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Skip header row and process var data
for (int row = 1; row <= sheet.RowCount; row++)
{
    var rowData = sheet.GetRow(row);
    // Access cells by index based on known column positions
    string sku = rowData.Columns[0].StringValue;      // Column A
    string description = rowData.Columns[1].StringValue; // Column B
    decimal cost = rowData.Columns[2].DecimalValue;    // Column C
    // Process the data
    ProcessProduct(sku, description, cost);
}
void ProcessProduct(string sku, string description, decimal cost)
{
    // Business logic here
    Console.WriteLine($"Processing: {sku} - {description} (${cost})");
}

For advanced header handling, you can freeze panes to keep headers visible or set up print configurations with repeating headers.

Input

Output

How Does IronXL Handle Quoted Fields and Special Characters?

Let's examine handling CSV files with quoted fields containing delimiters:

// CSV with complex quoted fields
string csvContent = @"Name,Description,Price,Category
""Johnson, Mike"",""Premium keyboard with ""mechanical"" switches"",149.99,Electronics
""O'Brien, Sarah"",""Children's toy - ages 3+"",29.99,Toys";
// Save content to file for demonstration
File.WriteAllText("complex_data.csv", csvContent);
// Load and process the CSV
WorkBook workbook = WorkBook.LoadCSV("complex_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read the complex fields
for (int row = 1; row <= sheet.RowCount; row++)
{
    string name = sheet[$"A{row}"].StringValue;
    string description = sheet[$"B{row}"].StringValue;
    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Description: {description}");
    Console.WriteLine("---");
}

// CSV with complex quoted fields
string csvContent = @"Name,Description,Price,Category
""Johnson, Mike"",""Premium keyboard with ""mechanical"" switches"",149.99,Electronics
""O'Brien, Sarah"",""Children's toy - ages 3+"",29.99,Toys";
// Save content to file for demonstration
File.WriteAllText("complex_data.csv", csvContent);
// Load and process the CSV
WorkBook workbook = WorkBook.LoadCSV("complex_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read the complex fields
for (int row = 1; row <= sheet.RowCount; row++)
{
    string name = sheet[$"A{row}"].StringValue;
    string description = sheet[$"B{row}"].StringValue;
    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Description: {description}");
    Console.WriteLine("---");
}

IronXL automatically handles quoted field complexity. The parser correctly interprets "Johnson, Mike" as a single field despite containing commas, and properly processes nested quotes in descriptions. The library follows CSV standards, treating doubled quotes as escape sequences. This automatic handling eliminates complex regular expressions or state machines. For additional text manipulation, you can add comments to cells or apply text styling.

What About Character Encoding Issues?

Working with different character encodings requires careful consideration. IronXL handles various file formats and encodings automatically:

// Load CSV with specific encoding
WorkBook workbook = WorkBook.Load("international_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Process international characters
for (int row = 1; row <= sheet.RowCount; row++)
{
    string city = sheet[$"A{row}"].StringValue;
    string country = sheet[$"B{row}"].StringValue;
    // Characters like ñ, ü, é display correctly
    Console.WriteLine($"Location: {city}, {country}");
}
// Save with UTF-8 encoding to preserve characters
workbook.SaveAsCsv("output_utf8.csv");

// Load CSV with specific encoding
WorkBook workbook = WorkBook.Load("international_data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Process international characters
for (int row = 1; row <= sheet.RowCount; row++)
{
    string city = sheet[$"A{row}"].StringValue;
    string country = sheet[$"B{row}"].StringValue;
    // Characters like ñ, ü, é display correctly
    Console.WriteLine($"Location: {city}, {country}");
}
// Save with UTF-8 encoding to preserve characters
workbook.SaveAsCsv("output_utf8.csv");

IronXL intelligently detects and handles various encodings, ensuring international characters display correctly. Whether working with UTF-8, UTF-16, or legacy ANSI encodings, the library preserves character integrity throughout read-write cycles. When saving CSV files, IronXL uses UTF-8 by default for maximum compatibility. You can also export to various formats including HTML and JSON.

Input

Output

How Can I Work with Custom Delimiters and Regional Formats?

Custom delimiters and formats require flexible configuration. IronXL supports various number formats and regional settings:

// European CSV format (semicolon delimiter, comma decimal)
string europeanCsv = @"Product;Price;Quantity
Widget A;12,50;100
Gadget B;24,99;50";
File.WriteAllText("european.csv", europeanCsv);
// Load with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("european.csv", 
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Parse European number format
for (int row = 1; row <= sheet.RowCount; row++)
{
    string product = sheet[$"A{row}"].StringValue;
    string priceText = sheet[$"B{row}"].StringValue;
    // Convert European format to decimal
    decimal price = decimal.Parse(priceText.Replace(',', '.'));
    Console.WriteLine($"{product}: €{price}");
}

// European CSV format (semicolon delimiter, comma decimal)
string europeanCsv = @"Product;Price;Quantity
Widget A;12,50;100
Gadget B;24,99;50";
File.WriteAllText("european.csv", europeanCsv);
// Load with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("european.csv", 
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Parse European number format
for (int row = 1; row <= sheet.RowCount; row++)
{
    string product = sheet[$"A{row}"].StringValue;
    string priceText = sheet[$"B{row}"].StringValue;
    // Convert European format to decimal
    decimal price = decimal.Parse(priceText.Replace(',', '.'));
    Console.WriteLine($"{product}: €{price}");
}

This example handles European CSV conventions where semicolons separate fields and commas denote decimal points. The listDelimiter parameter configures field splitting. For number parsing, the code converts European decimal notation to .NET's expected format. This flexibility allows processing CSV files from any region without modifying source data. You can also apply cell borders and alignment for better presentation.

What's the Best Approach for Batch Processing?

For files that fit in memory but contain many rows, batch processing improves efficiency:

WorkBook workbook = WorkBook.LoadCSV("large_dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Process in batches of 1000 rows
int batchSize = 1000;
int totalRows = sheet.RowCount;
for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    // Process current batch
    var batchResults = new List<ProcessedRecord>();
    for (int row = startRow; row <= endRow; row++)
    {
        string id = sheet[$"A{row}"].StringValue;
        decimal amount = sheet[$"B{row}"].DecimalValue;
        // Process and store results
        batchResults.Add(new ProcessedRecord 
        { 
            Id = id, 
            Amount = amount,
            Processed = DateTime.Now 
        });
    }
    // Save batch results (to database, file, etc.)
    SaveBatch(batchResults);
    Console.WriteLine($"Processed rows {startRow} to {endRow}");
}
void SaveBatch(List<ProcessedRecord> records)
{
    // Implement batch saving logic
    Console.WriteLine($"Saved {records.Count} records");
}
class ProcessedRecord
{
    public string Id { get; set; }
    public decimal Amount { get; set; }
    public DateTime Processed { get; set; }
}

WorkBook workbook = WorkBook.LoadCSV("large_dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Process in batches of 1000 rows
int batchSize = 1000;
int totalRows = sheet.RowCount;
for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    // Process current batch
    var batchResults = new List<ProcessedRecord>();
    for (int row = startRow; row <= endRow; row++)
    {
        string id = sheet[$"A{row}"].StringValue;
        decimal amount = sheet[$"B{row}"].DecimalValue;
        // Process and store results
        batchResults.Add(new ProcessedRecord 
        { 
            Id = id, 
            Amount = amount,
            Processed = DateTime.Now 
        });
    }
    // Save batch results (to database, file, etc.)
    SaveBatch(batchResults);
    Console.WriteLine($"Processed rows {startRow} to {endRow}");
}
void SaveBatch(List<ProcessedRecord> records)
{
    // Implement batch saving logic
    Console.WriteLine($"Saved {records.Count} records");
}
class ProcessedRecord
{
    public string Id { get; set; }
    public decimal Amount { get; set; }
    public DateTime Processed { get; set; }
}

Batch processing divides large datasets into manageable chunks, preventing memory overload and enabling progress tracking. Processing 1000 rows at a time accumulates results temporarily before saving. This approach allows garbage collection between batches, maintaining steady memory usage. The pattern also facilitates error recovery—resume from the last successful batch rather than restarting. For more efficient processing, consider grouping rows and columns or using trimming operations to remove unnecessary data.

Input

Output

How Can I Use LINQ for Memory-Efficient Processing?

For streaming scenarios where the entire file shouldn't load into memory:

// Alternative approach using row-by-row processing
public static void ProcessLargeCsvEfficiently(string filePath)
{
    WorkBook workbook = WorkBook.LoadCSV(filePath);
    WorkSheet sheet = workbook.DefaultWorkSheet;
    // Use LINQ for memory-efficient processing
    var results = Enumerable.Range(1, sheet.RowCount)
        .Select(row => new
        {
            Row = row,
            Value = sheet[$"A{row}"].DecimalValue
        })
        .Where(item => item.Value > 100) // Filter criteria
        .Take(10000); // Limit results
    // Process results as they're enumerated
    foreach (var item in results)
    {
        Console.WriteLine($"Row {item.Row}: {item.Value}");
    }
}

// Alternative approach using row-by-row processing
public static void ProcessLargeCsvEfficiently(string filePath)
{
    WorkBook workbook = WorkBook.LoadCSV(filePath);
    WorkSheet sheet = workbook.DefaultWorkSheet;
    // Use LINQ for memory-efficient processing
    var results = Enumerable.Range(1, sheet.RowCount)
        .Select(row => new
        {
            Row = row,
            Value = sheet[$"A{row}"].DecimalValue
        })
        .Where(item => item.Value > 100) // Filter criteria
        .Take(10000); // Limit results
    // Process results as they're enumerated
    foreach (var item in results)
    {
        Console.WriteLine($"Row {item.Row}: {item.Value}");
    }
}

This LINQ-based approach leverages deferred execution to process rows on-demand. The query builds a processing pipeline executing lazily, reading and filtering rows only as requested. The Take method provides an upper limit, preventing runaway queries. This pattern works well for finding specific records in large files without processing everything. You can also load data from SQL databases or export to SQL formats for better system integration.

Why Convert CSV Files to Excel?

Converting CSV to Excel with formatting enhances data presentation and enables advanced features:

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("sales_report.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Apply formatting to enhance readability
// Format header row
for (int col = 0; col < sheet.ColumnCount; col++)
{
    var headerCell = sheet.GetCellAt(0, col);
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
}
// Format currency columns
for (int row = 1; row <= sheet.RowCount; row++)
{
    var priceCell = sheet[$"C{row}"];
    priceCell.FormatString = "$#,##0.00";
    var quantityCell = sheet[$"D{row}"];
    quantityCell.Style.HorizontalAlignment = HorizontalAlignment.Right;
}
// Auto-fit columns for better display
for (int col = 0; col < sheet.ColumnCount; col++)
{
    sheet.AutoSizeColumn(col);
}
// Save as Excel file with formatting preserved
workbook.SaveAs("formatted_report.xlsx");
Console.WriteLine("CSV converted to formatted Excel file");

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("sales_report.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Apply formatting to enhance readability
// Format header row
for (int col = 0; col < sheet.ColumnCount; col++)
{
    var headerCell = sheet.GetCellAt(0, col);
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
}
// Format currency columns
for (int row = 1; row <= sheet.RowCount; row++)
{
    var priceCell = sheet[$"C{row}"];
    priceCell.FormatString = "$#,##0.00";
    var quantityCell = sheet[$"D{row}"];
    quantityCell.Style.HorizontalAlignment = HorizontalAlignment.Right;
}
// Auto-fit columns for better display
for (int col = 0; col < sheet.ColumnCount; col++)
{
    sheet.AutoSizeColumn(col);
}
// Save as Excel file with formatting preserved
workbook.SaveAs("formatted_report.xlsx");
Console.WriteLine("CSV converted to formatted Excel file");

This conversion process transforms plain CSV data into professionally formatted Excel workbooks using our efficient C# CSV parser. The code applies bold formatting and colors to headers, creating visual hierarchy. Currency formatting with thousand separators improves numeric readability. AutoSizeColumn adjusts widths to fit content. The resulting Excel file maintains all formatting when opened in spreadsheet applications. For more options, see our cell formatting guide. You can also add background patterns and colors, merge cells, or add hyperlinks for enhanced interactivity.

For containerized deployments, IronXL's Excel conversion capabilities work seamlessly in Docker environments. The library requires no external dependencies or Office installations, making it ideal for cloud-native architectures. When deploying to Kubernetes, create lightweight containers that process CSV files and generate formatted Excel reports without traditional Office automation overhead. For high-availability scenarios, IronXL's thread-safe operations enable horizontal scaling across multiple container instances, each processing CSV files independently while sharing common data stores.

Input

Output