How to Read a CSV File into a DataTable in C#

Why Does CSV to DataTable Conversion Matter?

CSV to DataTable conversion lets developers transform comma-separated values into structured objects for further processing. Whether you're handling inventory data, customer records, or transaction logs, converting CSV to a DataTable efficiently is crucial. Using the first row as column headers, you can ensure that DataTable columns align with your database table schema, making it perfect for Excel to SQL operations.

Traditional approaches often struggle with large files, different delimiters, or memory management. IronXL eliminates these challenges and handles different delimiters, quoted fields, and embedded commas without extra code. IronXL's CSV reading capabilities eliminate common pain points while providing additional features like data validation and file size control.

How Do You Install IronXL?

Getting started with IronXL requires a simple NuGet package installation. Open the NuGet Package Manager Console in Visual Studio and execute one of the following commands:

Install-Package IronXL

Install-Package IronXL

Or if you prefer the .NET CLI:

dotnet add package IronXL

dotnet add package IronXL

Once installed, add the IronXL namespace to your project:

using IronXL;
using System.Data;

using IronXL;
using System.Data;

This provides access to all CSV processing capabilities without any Excel dependencies. For more details, refer to the IronXL documentation and NuGet installation guide.

How Do You Verify the Installation Was Successful?

Create a test program that loads a CSV file to verify installation. If you encounter licensing messages, you will need to obtain a license key. Check the package references in your project file to ensure IronXL appears with the correct version. Run a basic CSV read operation -- if it completes without errors, your installation is working correctly.

Install with NuGet

PM >  Install-Package IronXL.Excel

Check out IronXL on NuGet for quick installation. With over 10 million downloads, it’s transforming PDF development with C#. You can also download the DLL.

How Do You Convert a CSV File to DataTable?

The core workflow in IronXL involves just a few lines of code. Here is how to read a CSV file and convert it to a DataTable using top-level statements in C# 10+:

using IronXL;
using System.Data;

// Load CSV file into a WorkBook object
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv",
    fileFormat: ExcelFileFormat.XLSX);

// Access the default worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Convert to DataTable with headers
DataTable dataTable = worksheet.ToDataTable(true);

// Display the data
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

using IronXL;
using System.Data;

// Load CSV file into a WorkBook object
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv",
    fileFormat: ExcelFileFormat.XLSX);

// Access the default worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Convert to DataTable with headers
DataTable dataTable = worksheet.ToDataTable(true);

// Display the data
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

The LoadCSV method parses your CSV file automatically, handling quoted fields and embedded commas. The fileFormat parameter tells IronXL how to interpret the CSV data internally, ensuring it's treated as an Excel-compatible structure. Once loaded, the ToDataTable(true) method converts the worksheet into a DataTable, with the parameter true indicating that the first row should be used as column headers. This results in a clean, structured DataTable with named columns that match your CSV headers. For more advanced manipulation options, explore the complete IronXL how-to guide.

The conversion process also preserves data types -- numbers remain numeric, dates are parsed correctly, and text fields maintain their formatting. This automatic type inference saves considerable development time compared to manual parsing approaches. For scenarios requiring custom data formatting, you can apply cell formatting before conversion.

How Do You Import a DataTable into SQL Server?

Once you have your DataTable, importing it into SQL Server becomes efficient using SqlBulkCopy. The following example uses C# top-level statements:

using System.Data;
using Microsoft.Data.SqlClient;
using IronXL;

// Create connection string
string connectionString = "Data Source=localhost;Initial Catalog=SalesDB;" +
    "Integrated Security=True;TrustServerCertificate=True;";

// Read CSV into DataTable
WorkBook workbook = WorkBook.LoadCSV("inventory_report.csv");
DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);

// Bulk insert into SQL Server
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

using SqlBulkCopy bulkCopy = new SqlBulkCopy(connection);

// Set destination table name
bulkCopy.DestinationTableName = "dbo.Inventory";

// Map DataTable columns to SQL table columns
bulkCopy.ColumnMappings.Add("ProductCode", "product_code");
bulkCopy.ColumnMappings.Add("Quantity", "quantity");
bulkCopy.ColumnMappings.Add("LastUpdated", "last_updated");

// Set batch size for better performance
bulkCopy.BatchSize = 1000;

// Write data to SQL Server
bulkCopy.WriteToServer(dataTable);

Console.WriteLine($"Successfully imported {dataTable.Rows.Count} records");

using System.Data;
using Microsoft.Data.SqlClient;
using IronXL;

// Create connection string
string connectionString = "Data Source=localhost;Initial Catalog=SalesDB;" +
    "Integrated Security=True;TrustServerCertificate=True;";

// Read CSV into DataTable
WorkBook workbook = WorkBook.LoadCSV("inventory_report.csv");
DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);

// Bulk insert into SQL Server
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();

using SqlBulkCopy bulkCopy = new SqlBulkCopy(connection);

// Set destination table name
bulkCopy.DestinationTableName = "dbo.Inventory";

// Map DataTable columns to SQL table columns
bulkCopy.ColumnMappings.Add("ProductCode", "product_code");
bulkCopy.ColumnMappings.Add("Quantity", "quantity");
bulkCopy.ColumnMappings.Add("LastUpdated", "last_updated");

// Set batch size for better performance
bulkCopy.BatchSize = 1000;

// Write data to SQL Server
bulkCopy.WriteToServer(dataTable);

Console.WriteLine($"Successfully imported {dataTable.Rows.Count} records");

The SqlBulkCopy class provides strong performance for large-scale data imports. The ColumnMappings collection maps DataTable columns to database columns with different names, ensuring flexibility in your data schema. The BatchSize property optimizes memory usage by processing records in chunks rather than loading everything at once. Learn more about IronXL's import and export capabilities.

For additional data integrity, consider implementing transaction support around your bulk copy operations. This ensures that partial imports can be rolled back if errors occur. You can also use IronXL's write Excel file features to pre-validate data before import.

Here, you can use the query SELECT * FROM dbo.Inventory; in SSMS to check that your CSV data was imported into the SQL Server. First, take a look at the data used in the example CSV file:

Now, if you look at the output for the query, you can see it successfully copied every column, header, and row into the database table.

How Do You Handle Different CSV Delimiters?

Not all CSV files use commas. IronXL handles various delimiters, making it practical for international data formats or legacy systems. The following example demonstrates loading tab-delimited and semicolon-delimited files:

using IronXL;
using System;
using System.Data;
using System.IO;

// --- Tab-delimited file ---
string tsvPath = "export_data.tsv";
WorkBook tsvWorkbook = WorkBook.LoadCSV(tsvPath, ExcelFileFormat.XLSX, "\t");

// --- Semicolon-delimited file ---
string semiPath = "european_data.csv";
string tempCsv = Path.Combine(Path.GetTempPath(), "european_data_comma.csv");

// Replace semicolons with commas for proper parsing
string[] lines = File.ReadAllLines(semiPath);
for (int i = 0; i < lines.Length; i++)
{
    lines[i] = lines[i].Replace(';', ',');
}
File.WriteAllLines(tempCsv, lines);

WorkBook semiWorkbook = WorkBook.LoadCSV(tempCsv, ExcelFileFormat.XLSX);

// Print tab-delimited results
DataTable tsvTable = tsvWorkbook.DefaultWorkSheet.ToDataTable(true);
Console.WriteLine("--- Tab-delimited File ---");
foreach (DataColumn col in tsvTable.Columns)
    Console.Write($"{col.ColumnName}\t");
Console.WriteLine();
foreach (DataRow row in tsvTable.Rows)
{
    foreach (var item in row.ItemArray)
        Console.Write($"{item}\t");
    Console.WriteLine();
}

// Print semicolon-delimited results
DataTable semiTable = semiWorkbook.DefaultWorkSheet.ToDataTable(true);
Console.WriteLine("\n--- Semicolon-delimited File ---");
foreach (DataColumn col in semiTable.Columns)
    Console.Write($"{col.ColumnName}\t");
Console.WriteLine();
foreach (DataRow row in semiTable.Rows)
{
    foreach (var item in row.ItemArray)
        Console.Write($"{item}\t");
    Console.WriteLine();
}

using IronXL;
using System;
using System.Data;
using System.IO;

// --- Tab-delimited file ---
string tsvPath = "export_data.tsv";
WorkBook tsvWorkbook = WorkBook.LoadCSV(tsvPath, ExcelFileFormat.XLSX, "\t");

// --- Semicolon-delimited file ---
string semiPath = "european_data.csv";
string tempCsv = Path.Combine(Path.GetTempPath(), "european_data_comma.csv");

// Replace semicolons with commas for proper parsing
string[] lines = File.ReadAllLines(semiPath);
for (int i = 0; i < lines.Length; i++)
{
    lines[i] = lines[i].Replace(';', ',');
}
File.WriteAllLines(tempCsv, lines);

WorkBook semiWorkbook = WorkBook.LoadCSV(tempCsv, ExcelFileFormat.XLSX);

// Print tab-delimited results
DataTable tsvTable = tsvWorkbook.DefaultWorkSheet.ToDataTable(true);
Console.WriteLine("--- Tab-delimited File ---");
foreach (DataColumn col in tsvTable.Columns)
    Console.Write($"{col.ColumnName}\t");
Console.WriteLine();
foreach (DataRow row in tsvTable.Rows)
{
    foreach (var item in row.ItemArray)
        Console.Write($"{item}\t");
    Console.WriteLine();
}

// Print semicolon-delimited results
DataTable semiTable = semiWorkbook.DefaultWorkSheet.ToDataTable(true);
Console.WriteLine("\n--- Semicolon-delimited File ---");
foreach (DataColumn col in semiTable.Columns)
    Console.Write($"{col.ColumnName}\t");
Console.WriteLine();
foreach (DataRow row in semiTable.Rows)
{
    foreach (var item in row.ItemArray)
        Console.Write($"{item}\t");
    Console.WriteLine();
}

This code demonstrates loading CSV files with different delimiters into IronXL WorkBook objects. Tab-delimited files are read using "\t" as the separator, while semicolon-delimited files are converted to standard CSV format before loading. Each workbook's default worksheet is converted into a DataTable with ToDataTable(true), which uses the first row as column headers. For more complex file format scenarios, you can also explore exporting Excel data to various formats.

The flexibility to handle different delimiters addresses many real-world CSV parsing challenges. When working with European data formats, IronXL's delimiter handling accommodates regional differences in data formatting standards. For files with inconsistent structures, pre-process the raw text before passing it to LoadCSV.

The RFC 4180 standard defines the CSV format specification that IronXL follows for quoted fields and embedded commas. This flexibility is also discussed in detail in the Stack Overflow community thread on reading CSV into DataTable in .NET.

What Are the Supported IronXL Features Beyond CSV?

IronXL covers much more than CSV reading. The library handles the full spectrum of Excel and spreadsheet operations in C#, making it a single dependency for data-centric applications.

What Are the Next Steps?

IronXL transforms CSV database imports into a straightforward, reliable process. With just a few lines of code, you can:

• Read CSV files from any file path using LoadCSV functionality
• Convert CSV data into a DataTable with proper data formatting
• Preserve column headers and DataTable columns through automatic parsing
• Import millions of rows into a database table efficiently using bulk operations

The library handles the intricacies of CSV parsing, memory management, and data type conversions, letting you focus on your business logic rather than file processing details. Whether you're building ASP.NET applications, working with Blazor, or developing .NET 10 desktop apps, IronXL provides consistent, reliable CSV processing across all platforms.

Ready to get started? The IronXL documentation covers every feature in depth, and a trial license lets you evaluate the full library. With extensive code examples and clear API references, you will be processing CSV files efficiently in your .NET 10 applications in no time.