Cómo leer un archivo CSV en un DataTable en C#

¿Por qué es esencial la conversión de CSV a DataTable?

La conversión de CSV a DataTable permite a los desarrolladores transformar valores separados por comas (datos CSV) en objetos estructurados como un DataTable para posterior procesamiento. Ya sea que estés manejando datos de inventario, registros de clientes o registros de transacciones, poder convertir CSV a un DataTable nuevo de manera eficiente es crucial. Usando la primera fila como encabezados de columna, puedes asegurarte de que las columnas del DataTable coincidan con el esquema de la tabla de tu base de datos.

Los enfoques tradicionales a menudo enfrentan dificultades con archivos grandes, diferentes delimitadores o gestión de memoria. IronXL elimina estos desafíos y maneja diferentes delimitadores, campos entre comillas y comas incrustadas sin problemas. Las capacidades de lectura de CSV de IronXL eliminan estos problemas comunes.

¿Cómo instalar IronXL?

Comenzar con IronXL solo requiere una simple instalación del paquete NuGet. Abre la Consola del Administrador de Paquetes NuGet en Visual Studio y ejecuta:

Install-Package IronXL.Excel

Una vez instalado, agrega el espacio de nombres IronXL a tu proyecto:

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Esto proporciona acceso a todas las potentes capacidades de procesamiento de CSV sin ninguna dependencia de Excel. Para más detalles sobre la extensa API de IronXL, consulta la Documentación de Referencia API.

Instalar con NuGet

PM >  Install-Package IronXL.Excel

Echa un vistazo a IronXL en NuGet para una instalación rápida. Con más de 10 millones de descargas, está transformando el desarrollo de PDF con C#. También puede descargar el DLL.

¿Cómo convertir CSV a DataTable?

La belleza de IronXL reside en su simplicidad. Aquí te mostramos cómo leer un archivo CSV y convertirlo en un DataTable:

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

El método LoadCSV analiza inteligentemente tu archivo CSV, manejando automáticamente casos comunes como campos entre comillas y comas incrustadas. El parámetro fileFormat indica a IronXL cómo interpretar los datos CSV internamente, asegurando que se traten como una estructura compatible con Excel. Una vez cargado, el método ToDataTable(true) convierte la hoja de trabajo en un DataTable, con el parámetro true indicando que la primera fila debe usarse como encabezados de columna. Esto da como resultado un DataTable limpio y estructurado con columnas nombradas que coinciden con los encabezados de tu CSV. Para más opciones de manipulación avanzada, explora el tutorial completo de Excel a DataTable.

¿Cómo importar DataTable en SQL Server?

Una vez que tienes tu DataTable, importarlo en SQL Server se vuelve notablemente eficiente usando SqlBulkCopy:

using System.Data;
using Microsoft.Data.SqlClient;
using IronXL;
class Program
{
    static void Main(string[] args)
    {
        // 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;
class Program
{
    static void Main(string[] args)
    {
        // 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");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La clase SqlBulkCopy proporciona un rendimiento excepcional para importaciones de datos a gran escala. La colección ColumnMappings te permite mapear columnas de DataTable a columnas de base de datos con nombres diferentes, asegurando flexibilidad en tu esquema de datos. La propiedad BatchSize optimiza el uso de memoria procesando registros en bloques en lugar de cargar todo de una vez. Este enfoque puede manejar milones de registros de manera eficiente, lo que lo hace ideal para operaciones de datos de escala empresarial. Aprende más sobre las capacidades de DataSet y DataTable de IronXL.

¿Cómo manejar diferentes delimitadores?

No todos los archivos CSV usan comas. IronXL maneja sin problemas varios delimitadores:

using IronXL;
using System;
using System.Data;
using System.IO;
class Program
{
    static void Main()
    {
        // --- 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
        var 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 both workbooks
        PrintWorkbook(tsvWorkbook, "Tab-delimited File");
        PrintWorkbook(semiWorkbook, "Semicolon-delimited File");
    }
    static void PrintWorkbook(WorkBook workbook, string name)
    {
        Console.WriteLine($"\n--- {name} ---\n");
        DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);
        // Print column headers
        foreach (DataColumn col in dt.Columns)
        {
            Console.Write($"{col.ColumnName}\t");
        }
        Console.WriteLine();
        // Print rows
        foreach (DataRow row in dt.Rows)
        {
            foreach (var item in row.ItemArray)
            {
                Console.Write($"{item}\t");
            }
            Console.WriteLine();
        }
    }
}

using IronXL;
using System;
using System.Data;
using System.IO;
class Program
{
    static void Main()
    {
        // --- 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
        var 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 both workbooks
        PrintWorkbook(tsvWorkbook, "Tab-delimited File");
        PrintWorkbook(semiWorkbook, "Semicolon-delimited File");
    }
    static void PrintWorkbook(WorkBook workbook, string name)
    {
        Console.WriteLine($"\n--- {name} ---\n");
        DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);
        // Print column headers
        foreach (DataColumn col in dt.Columns)
        {
            Console.Write($"{col.ColumnName}\t");
        }
        Console.WriteLine();
        // Print rows
        foreach (DataRow row in dt.Rows)
        {
            foreach (var item in row.ItemArray)
            {
                Console.Write($"{item}\t");
            }
            Console.WriteLine();
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Este código carga archivos CSV con diferentes delimitadores en objetos WorkBook de IronXL. Los archivos delimitados por tabulaciones se leen usando "\t" como separador, mientras que los archivos delimitados por punto y coma se convierten a formato CSV estándar antes de cargarlos. La hoja de trabajo predeterminada de cada libro se convierte en un DataTable con ToDataTable(true), que usa la primera fila como encabezados de columna.

El método PrintWorkbook luego itera a través del DataTable y muestra los datos en la consola, incluidos los encabezados y todas las filas. Esta flexibilidad aborda muchos de los desafíos comunes de análisis de CSV discutidos por los desarrolladores.

Conclusión

IronXL transforma la compleja tarea de importación de bases de datos CSV en un proceso sencillo y confiable. Con solo unas pocas líneas de código, puedes:

• Leer archivos CSV desde cualquier ruta de archivo
• Convertir datos CSV en un nuevo DataTable
• Preservar encabezados de columna y columnas de DataTable
• Importar millones de filas en una tabla de base de datos de manera eficiente

La biblioteca maneja automáticamente las complejidades del análisis de CSV, la gestión de memoria y las conversiones de tipos de datos, permitiéndote concentrarte en tu lógica de negocio en lugar de en los detalles del procesamiento de archivos.

¿Listo para optimizar tu flujo de trabajo de importación de datos? Comienza tu prueba gratuita para encontrar el ajuste perfecto para las necesidades de tu equipo.