Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Importar CSV
USANDO IRONXL

Importar CSV en C# | Tutorial de ASP.NET Core | IronXL

Jordi Bardia
Jordi Bardia
Actualizado:

Importar un archivo CSV en C# con ASP.NET Core significa leer un flujo de archivos, analizar filas delimitadas y asignar cada registro a un objeto tipificado, todo antes de poder hacer algo útil con los datos. IronXL maneja cada paso a través de una única API que funciona igualmente bien para archivos CSV, XLSX y TSV, de modo que usted dedica tiempo a la lógica de su aplicación en lugar de a dividir cadenas en casos extremos.

Comience su prueba gratuita para seguir y probar estos ejemplos de código en su propio entorno.

¿Cómo instalar IronXL en un proyecto .NET ?

Antes de escribir cualquier código de análisis, agregue IronXL a su proyecto. Abra la Consola del Administrador de paquetes en Visual Studio o una terminal en el directorio de su proyecto y ejecute uno de los siguientes comandos:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel
Install-Package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

El paquete está dirigido a .NET 10, .NET 6+, .NET Framework 4.6.2+ y .NET Standard 2.0, por lo que se adapta a cualquier tipo de proyecto moderno. No se requiere instalación de Microsoft Office en el servidor. Después de restaurar el paquete, agregue using IronXL; en la parte superior de cualquier archivo que llame a la biblioteca.

Para conocer las opciones de configuración detalladas, incluida la instalación de herramientas globales y la configuración del flujo de trabajo de CI/CD, visite la guía de instalación de IronXL .

¿Cómo importar un archivo CSV en ASP.NET Core?

Para importar un archivo CSV en ASP.NET Core es necesario leer la secuencia de archivos desde el servidor, analizar cada fila y asignar valores a una clase de modelo. Mientras que algunos desarrolladores recurren a implementaciones manuales StreamReader o paquetes de terceros, IronXL proporciona un método único que maneja archivos CSV junto con formatos Excel sin configuración adicional.

El siguiente código muestra cómo cargar un archivo CSV utilizando el método WorkBook.LoadCSV de IronXL:

using IronXL;

// Load the CSV file directly using the full file path
var csv = WorkBook.LoadCSV("products.csv");
WorkSheet worksheet = csv.DefaultWorkSheet;

// Access CSV data by iterating through rows
foreach (var row in worksheet.Rows)
{
    string productName = row.Columns[1].StringValue;
    decimal price = row.Columns[2].DecimalValue;
    Console.WriteLine($"Product: {productName}, Price: {price}");
}
using IronXL;

// Load the CSV file directly using the full file path
var csv = WorkBook.LoadCSV("products.csv");
WorkSheet worksheet = csv.DefaultWorkSheet;

// Access CSV data by iterating through rows
foreach (var row in worksheet.Rows)
{
    string productName = row.Columns[1].StringValue;
    decimal price = row.Columns[2].DecimalValue;
    Console.WriteLine($"Product: {productName}, Price: {price}");
}
$vbLabelText   $csharpLabel

Comprensión del método WorkBook.LoadCSV

El método WorkBook.LoadCSV lee el archivo CSV y crea una hoja de cálculo donde cada línea se convierte en una fila y cada valor delimitado se convierte en una celda. IronXL detecta automáticamente el delimitador (coma, punto y coma o tabulación) y maneja los campos entre comillas que contienen comas dentro del valor. No es necesario configurar un delimitador manualmente para archivos CSV estándar.

Los accesores de valores de celda como StringValue, DecimalValue, IntValue y DateTimeValue manejan la conversión de tipos, de modo que evita el análisis manual con int.TryParse o decimal.Parse. Cuando una celda está vacía o contiene un valor no reconocido, estos accesores devuelven el tipo predeterminado en lugar de generar una excepción, lo que evita errores no controlados durante operaciones de importación masiva.

Este enfoque elimina el análisis manual de cadenas propenso a errores que requieren las implementaciones personalizadas, en particular para casos extremos como comillas escapadas, finales de línea estilo Windows y valores de celdas de varias líneas. Para obtener más detalles sobre los formatos admitidos y las opciones de delimitadores, consulte la documentación de IronXL CSV .

Importación de CSV de ASP: una guía completa para desarrolladores de C#: Imagen 1: Importación de un archivo CSV simple y lectura de la salida en la consola

¿Cómo se puede crear una clase de modelo para datos CSV?

Para asignar datos CSV a objetos fuertemente tipados se requiere una clase de modelo que refleje la estructura del archivo. Convierte datos de cadenas sin procesar en tipos específicos, como números enteros, decimales y valores de fecha y hora. Para los datos de inventario de productos, cree una clase con propiedades que coincidan con cada columna CSV:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
$vbLabelText   $csharpLabel

Análisis de filas CSV en colecciones tipificadas

Con la clase de modelo definida, puede analizar registros CSV en una colección tipificada. El siguiente ejemplo omite la fila de encabezado utilizando un índice de bucle y asigna cada fila subsiguiente a un objeto Product:

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        Quantity = row.Columns[3].IntValue
    };
    records.Add(product);
}

Console.WriteLine($"Loaded {records.Count} products.");
using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        Quantity = row.Columns[3].IntValue
    };
    records.Add(product);
}

Console.WriteLine($"Loaded {records.Count} products.");
$vbLabelText   $csharpLabel

La colección records ahora contiene objetos Product tipificados listos para operaciones de base de datos, serialización JSON o lógica comercial adicional. Los accesores de valores de celda de IronXL manejan la conversión de tipos automáticamente, incluido el manejo de valores nulos para campos opcionales.

Manejo de campos opcionales y nulos

Los archivos CSV del mundo real a menudo contienen celdas vacías o columnas opcionales. Los accesores de valores de IronXL devuelven valores predeterminados en lugar de excepciones cuando una celda está en blanco. Para los tipos que aceptan valores NULL, puedes utilizar una comprobación condicional:

// Reading an optional DateTime field
DateTime? lastUpdated = string.IsNullOrEmpty(row.Columns[4].StringValue)
    ? null
    : row.Columns[4].DateTimeValue;
// Reading an optional DateTime field
DateTime? lastUpdated = string.IsNullOrEmpty(row.Columns[4].StringValue)
    ? null
    : row.Columns[4].DateTimeValue;
$vbLabelText   $csharpLabel

Este patrón mantiene su código de importación a la defensiva sin envolver cada acceso de celda en un bloque try-catch. Para obtener orientación sobre el manejo de tipos de datos complejos y archivos grandes, visita la documentación de IronXL WorkSheet .

¿Cómo se gestionan las cargas de archivos CSV en una API web?

Para crear un punto final de API que acepte cargas de archivos CSV desde un navegador es necesario combinar IFormFile de ASP.NET Core con las capacidades de análisis de IronXL. El siguiente código demuestra una implementación de controlador completa que analiza el archivo cargado y devuelve una respuesta JSON:

using IronXL;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class CsvController : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> UploadCsv(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("Please upload a valid CSV file.");

        try
        {
            using var stream = new MemoryStream();
            await file.CopyToAsync(stream);
            stream.Position = 0;

            WorkBook workbook = WorkBook.Load(stream, "csv");
            WorkSheet ws = workbook.DefaultWorkSheet;
            var records = new List<Product>();

            // Skip header row, iterate through data rows
            for (int i = 1; i < ws.Rows.Count(); i++)
            {
                var row = ws.Rows[i];
                records.Add(new Product
                {
                    Id = row.Columns[0].IntValue,
                    Name = row.Columns[1].StringValue,
                    Price = row.Columns[2].DecimalValue,
                    Quantity = row.Columns[3].IntValue
                });
            }

            return Ok(new
            {
                message = "Import successful",
                count = records.Count,
                data = records
            });
        }
        catch (Exception ex)
        {
            return BadRequest($"Error processing file: {ex.Message}");
        }
    }
}
using IronXL;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class CsvController : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> UploadCsv(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("Please upload a valid CSV file.");

        try
        {
            using var stream = new MemoryStream();
            await file.CopyToAsync(stream);
            stream.Position = 0;

            WorkBook workbook = WorkBook.Load(stream, "csv");
            WorkSheet ws = workbook.DefaultWorkSheet;
            var records = new List<Product>();

            // Skip header row, iterate through data rows
            for (int i = 1; i < ws.Rows.Count(); i++)
            {
                var row = ws.Rows[i];
                records.Add(new Product
                {
                    Id = row.Columns[0].IntValue,
                    Name = row.Columns[1].StringValue,
                    Price = row.Columns[2].DecimalValue,
                    Quantity = row.Columns[3].IntValue
                });
            }

            return Ok(new
            {
                message = "Import successful",
                count = records.Count,
                data = records
            });
        }
        catch (Exception ex)
        {
            return BadRequest($"Error processing file: {ex.Message}");
        }
    }
}
$vbLabelText   $csharpLabel

Configuración del punto final y del formulario multiparte

Para que la acción [HttpPost("upload")] acepte cargas de archivos, el proyecto debe admitir datos de formularios de varias partes. En Program.cs para una configuración de API mínima, asegúrese de haber llamado a builder.Services.AddControllers() y app.MapControllers(). El punto final se vuelve accesible en /api/csv/upload.

Al realizar pruebas desde un formulario de navegador, configure el atributo enctype del formulario en multipart/form-data y utilice un elemento de entrada de archivo. Para clientes API como Postman , seleccione "form-data" en el cuerpo de la solicitud, agregue una clave llamada file y adjunte el archivo CSV. El controlador devuelve un objeto JSON que contiene el recuento de registros y la matriz de datos analizados, que el JavaScript del lado del cliente puede procesar inmediatamente.

Importación de CSV de ASP: una guía completa para desarrolladores de C#: Imagen 2: salida exitosa con los datos leídos del archivo CSV importado

Validar el tipo de archivo antes del análisis

Antes de pasar la transmisión a IronXL, valide la extensión del archivo para rechazar cargas que no sean CSV:

var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
if (extension != ".csv" && extension != ".txt")
    return BadRequest("Only CSV files are accepted.");
var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
if (extension != ".csv" && extension != ".txt")
    return BadRequest("Only CSV files are accepted.");
$vbLabelText   $csharpLabel

Esta verificación evita que datos binarios malformados lleguen al analizador y proporciona un mensaje de error claro a los consumidores de API. Puede ampliar esta validación para verificar el tipo MIME usando file.ContentType para una aplicación más estricta.

¿Cómo guardar datos CSV en una base de datos?

Después de analizar los archivos CSV en objetos tipificados, normalmente se conservan los registros en una base de datos. El siguiente ejemplo extiende el patrón de capa de servicio mediante el uso de AddRangeAsync de Entity Framework Core para inserciones masivas:

using IronXL;

public class CsvImportService
{
    private readonly AppDbContext _context;

    public CsvImportService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<int> ImportProductsAsync(Stream csvStream)
    {
        WorkBook workbook = WorkBook.LoadCSV(csvStream);
        WorkSheet ws = workbook.DefaultWorkSheet;
        var products = new List<Product>();

        foreach (var row in ws.Rows.Skip(1))
        {
            products.Add(new Product
            {
                Id = row.Columns[0].IntValue,
                Name = row.Columns[1].StringValue,
                Price = row.Columns[2].DecimalValue,
                Quantity = row.Columns[3].IntValue
            });
        }

        await _context.Products.AddRangeAsync(products);
        return await _context.SaveChangesAsync();
    }
}
using IronXL;

public class CsvImportService
{
    private readonly AppDbContext _context;

    public CsvImportService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<int> ImportProductsAsync(Stream csvStream)
    {
        WorkBook workbook = WorkBook.LoadCSV(csvStream);
        WorkSheet ws = workbook.DefaultWorkSheet;
        var products = new List<Product>();

        foreach (var row in ws.Rows.Skip(1))
        {
            products.Add(new Product
            {
                Id = row.Columns[0].IntValue,
                Name = row.Columns[1].StringValue,
                Price = row.Columns[2].DecimalValue,
                Quantity = row.Columns[3].IntValue
            });
        }

        await _context.Products.AddRangeAsync(products);
        return await _context.SaveChangesAsync();
    }
}
$vbLabelText   $csharpLabel

Conexión del servicio a la inyección de dependencia

Registra CsvImportService en Program.cs para que el controlador pueda solicitarlo a través de la inyección del constructor:

builder.Services.AddScoped<CsvImportService>();
builder.Services.AddScoped<CsvImportService>();
$vbLabelText   $csharpLabel

Luego, actualice el constructor del controlador para que acepte el servicio y llame a ImportProductsAsync en lugar de generar la lista en línea. Esta separación simplifica las acciones del controlador y traslada la lógica de acceso a datos a una clase de servicio comprobable. Entity Framework Core agrupa la llamada AddRangeAsync en una única declaración INSERT por lote, lo que funciona bien para archivos CSV que contienen miles de filas.

Para importaciones muy grandes (decenas de miles de filas), considere usar las extensiones masivas de EF Core o una declaración SQL sin formato BULK INSERT para reducir los viajes de ida y vuelta a la base de datos.

¿Cómo exportar datos nuevamente a CSV usando IronXL?

IronXL no se limita a leer archivos CSV: también los escribe. El método SaveAsCsv exporta cualquier hoja de cálculo a un archivo CSV, lo cual resulta útil para generar informes o enviar datos a sistemas posteriores:

using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLS);
WorkSheet ws = workbook.DefaultWorkSheet;

// Write headers
ws["A1"].Value = "Id";
ws["B1"].Value = "Name";
ws["C1"].Value = "Price";

// Write data rows
ws["A2"].Value = 1;
ws["B2"].Value = "Widget A";
ws["C2"].Value = 9.99;

ws["A3"].Value = 2;
ws["B3"].Value = "Widget B";
ws["C3"].Value = 14.49;

// Save as CSV
workbook.SaveAsCsv("export.csv");
Console.WriteLine("CSV export complete.");
using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLS);
WorkSheet ws = workbook.DefaultWorkSheet;

// Write headers
ws["A1"].Value = "Id";
ws["B1"].Value = "Name";
ws["C1"].Value = "Price";

// Write data rows
ws["A2"].Value = 1;
ws["B2"].Value = "Widget A";
ws["C2"].Value = 9.99;

ws["A3"].Value = 2;
ws["B3"].Value = "Widget B";
ws["C3"].Value = 14.49;

// Save as CSV
workbook.SaveAsCsv("export.csv");
Console.WriteLine("CSV export complete.");
$vbLabelText   $csharpLabel

El archivo exportado utiliza delimitadores de coma de forma predeterminada. Para los archivos delimitados por punto y coma comunes en las configuraciones regionales europeas, llame a SaveAsCsv("export.csv", ";") con un argumento delimitador explícito. También puede guardar en un MemoryStream y devolver el resultado como una descarga de archivo desde un punto final de API usando File(stream, "text/csv", "export.csv").

Para obtener una referencia completa sobre las opciones de exportación, visita la documentación de guardado y exportación de IronXL .

¿Por qué IronXL es una mejor opción que el análisis manual de CSV?

El análisis manual de CSV parece sencillo hasta que se encuentran casos extremos: valores que contienen comas entre comillas, nuevas líneas incrustadas en una celda, comillas escapadas y marcas de orden de bytes al comienzo de archivos UTF-8. Manejar todo esto correctamente en un bucle StreamReader personalizado requiere pruebas importantes y mantenimiento continuo.

IronXL aborda todos estos casos internamente. La comparación de ambos enfoques muestra claras ventajas:

IronXL vs. Lector de flujo manual para análisis de CSV en C#
Capacidad IronXL Lector de flujo manual
Detección automática de delimitadores Sí No, debe configurarse manualmente
Manejo de campos cotizados Integrado Requiere lógica personalizada
Conversión de tipo (int, decimal, DateTime) Accesores incorporados Requiere llamadas Parse/TryParse
Valores de celdas de varias líneas Manejado automáticamente Difícil de implementar correctamente
Manejo de listas de materiales Automático Requiere configuración de StreamReader
Compatibilidad con formatos de Excel (XLSX, XLS) Misma API Requiere biblioteca separada
Exportar a CSV Método SaveAsCsv Requiere lógica de escritura separada

Consistencia entre formatos

Una de las ventajas prácticas de IronXL es que el mismo patrón de iteración de WorkBook.Load y de hoja de trabajo funciona para archivos XLSX, XLS, ODS y CSV. Si su aplicación necesita aceptar múltiples formatos de hojas de cálculo de los usuarios, puede cambiar entre formatos sin cambiar la lógica de análisis. Pase el flujo de archivo a WorkBook.Load y IronXL detectará el formato automáticamente según la firma del archivo.

Esta API de formato cruzado significa que usted escribe y prueba una ruta de código en lugar de mantener implementaciones separadas para CSV y Excel. Para obtener una lista completa de los formatos compatibles, consulte la página de formatos de archivo compatibles con IronXL .

Consideraciones de rendimiento para archivos grandes

Para archivos CSV de menos de 100 MB, IronXL funciona bien sin necesidad de realizar ajustes. Para archivos más grandes, considere estas estrategias:

  • Cargue el archivo desde una ruta en lugar de copiarlo a un MemoryStream para reducir la asignación de memoria.
  • Procesar filas en lotes al insertarlas en una base de datos en lugar de recopilar todos los registros antes de la primera inserción.
  • Utilice ws.Rows.Skip(1) con LINQ para evitar materializar la fila de encabezado como un objeto Product.

La guía de rendimiento de IronXL cubre optimizaciones adicionales para escenarios de importación de gran volumen, incluidos los modos de procesamiento paralelo y transmisión.

¿Cuales son tus próximos pasos?

Ahora tiene un patrón de trabajo para cada etapa de la importación de CSV en ASP.NET Core: instalar la biblioteca, cargar archivos desde el disco o secuencias cargadas, mapear filas a objetos de modelo tipificados, persistir registros en una base de datos con Entity Framework Core y exportar datos nuevamente a CSV cuando sea necesario.

Para construir sobre esta base, explore estos recursos:

Con IronXL en su proyecto, agregar soporte para cargas XLSX junto con CSV no requiere cambios de código adicionales: la misma llamada WorkBook.Load maneja ambos. Esa consistencia significa que puede ampliar el conjunto de características de su punto final de importación de forma incremental a medida que crecen los requisitos de su aplicación.

Preguntas Frecuentes

¿Cómo puedo importar archivos CSV en una aplicación ASP.NET Core?

Puede importar archivos CSV en una aplicación ASP.NET Core con IronXL gestionando la carga de archivos, analizando datos CSV y asignándolos a objetos de clase de modelo. IronXL proporciona una API para facilitar estas tareas de forma eficiente.

¿Cuáles son los beneficios de utilizar IronXL para la importación de CSV en C#?

IronXL ofrece una API que simplifica la importación de archivos CSV. Permite analizar datos fácilmente, mapearlos a modelos y convertir registros a JSON, lo que la convierte en la opción ideal para aplicaciones basadas en datos.

¿Puede IronXL analizar datos CSV en objetos de clase modelo?

Sí, IronXL puede analizar datos CSV en objetos de clase de modelo, lo que le permite trabajar con datos estructurados dentro de su aplicación .NET de manera eficiente.

¿Cómo ayuda IronXL con la integración de bases de datos al importar archivos CSV?

IronXL ayuda con la integración de bases de datos al permitirle analizar datos CSV y mapearlos a objetos de modelo que pueden insertarse o actualizarse fácilmente en su base de datos.

¿Es posible devolver registros CSV como JSON usando IronXL?

Sí, con IronXL puedes convertir registros CSV al formato JSON, lo que es útil para crear API web o integrar con aplicaciones front-end.

¿Qué formatos de archivos puede manejar IronXL además de CSV?

Además de CSV, IronXL puede manejar varios formatos de archivos de Excel como XLSX, XLS y otros, lo que proporciona versatilidad para diferentes necesidades de hojas de cálculo.

¿IronXL admite importaciones de archivos CSV grandes?

IronXL está diseñado para manejar importaciones de archivos CSV de gran tamaño de manera eficiente, garantizando el rendimiento y la confiabilidad en aplicaciones basadas en datos.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me