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

ASP Import CSV: Guía completa para desarrolladores en C#

Jordi Bardia
Jordi Bardia
Publicado:

Trabajar con archivos CSV es una realidad diaria para los desarrolladores que crean aplicaciones basadas en datos. Ya sea que los usuarios carguen inventario de productos, registros de clientes o datos financieros, la capacidad de importar CSV de ASP de forma eficiente puede ser clave para el éxito o el fracaso de su aplicación .NET Core. Este artículo muestra cómo gestionar la carga de archivos CSV, analizar datos CSV en objetos de clase de modelo y devolver registros como JSON, todo ello mediante la API optimizada de IronXL.

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

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

Para importar un archivo CSV en ASP.NET Core es necesario leer el flujo de archivos desde el servidor, analizar cada nueva línea y asignar valores a una clase de modelo. Mientras que algunos desarrolladores recurren al paquete NuGet CsvHelper o definen manualmente un lector de variables usando el espacio de nombres del sistema, IronXL ofrece una alternativa que maneja archivos CSV junto con formatos Excel sin dependencias adicionales.

El siguiente código muestra cómo cargar un archivo CSV usando 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 customerName = row.Columns[1].StringValue;
     decimal price = row.Columns[2].DecimalValue;
     Console.WriteLine($"Product: {customerName}, 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 customerName = row.Columns[1].StringValue;
     decimal price = row.Columns[2].DecimalValue;
     Console.WriteLine($"Product: {customerName}, Price: {price}");
 }
Imports IronXL

' Load the CSV file directly using the full file path
Dim csv = WorkBook.LoadCSV("products.csv")
Dim worksheet As WorkSheet = csv.DefaultWorkSheet

' Access CSV data by iterating through rows
For Each row In worksheet.Rows
    Dim customerName As String = row.Columns(1).StringValue
    Dim price As Decimal = row.Columns(2).DecimalValue
    Console.WriteLine($"Product: {customerName}, Price: {price}")
Next
$vbLabelText   $csharpLabel

Resultado

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

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. IronXL detecta automáticamente el delimitador y maneja caracteres especiales, encabezados de archivos CSV y campos entre comillas. Este enfoque elimina la necesidad de un nuevo streamwriter o de una instancia manual de streamwriter, lo que evita el análisis manual de cadenas propenso a errores que requieren las implementaciones personalizadas.

¿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. A menudo es necesario convertir datos de cadenas sin procesar en tipos específicos, como números enteros o decimales. Para los datos de inventario de productos, cree una clase con propiedades que coincidan con cada columna:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
Public Class Product
    Public Property Id As Integer
    Public Property Name As String
    Public Property Price As Decimal
    Public Property Quantity As Integer
End Class
$vbLabelText   $csharpLabel

Con esta clase de modelo definida, puede analizar registros CSV en una colección tipificada:

using IronXL;
WorkBook workbook = WorkBook.LoadCSV("inventory.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];
    var product = new Product
    {
        ProductCode = row.Columns[0].StringValue,
        Quantity = row.Columns[1].IntValue,
        LastUpdated = row.Columns[2].DateTimeValue ?? default(DateTime)
};
    records.Add(product);
}
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("inventory.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];
    var product = new Product
    {
        ProductCode = row.Columns[0].StringValue,
        Quantity = row.Columns[1].IntValue,
        LastUpdated = row.Columns[2].DateTimeValue ?? default(DateTime)
};
    records.Add(product);
}
Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim records As New List(Of Product)()
' Skip header row, iterate through data rows
For i As Integer = 1 To ws.Rows.Count() - 1
    Dim row = ws.Rows(i)
    Dim product As New Product With {
        .ProductCode = row.Columns(0).StringValue,
        .Quantity = row.Columns(1).IntValue,
        .LastUpdated = If(row.Columns(2).DateTimeValue, Nothing)
    }
    records.Add(product)
Next i
$vbLabelText   $csharpLabel

La colección de registros var ahora contiene objetos de producto tipificados listos para operaciones de base de datos, serialización JSON o procesamiento posterior. Los accesores de valores de celda de IronXL, como IntValue y DateTimeValue, manejan la conversión de tipos automáticamente.

¿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 envía una respuesta JSON:

using IronXL;
using Microsoft.AspNetCore.Mvc;
namespace CsvTestProject.Controllers
{
    [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];
                    var product = new Product
                    {
                        ProductCode = row.Columns[0].StringValue,
                        Quantity = row.Columns[1].IntValue,
                        LastUpdated = row.Columns[2].DateTimeValue ?? default(DateTime)
                    };
                    records.Add(product);
                }
                return Ok(new
                {
                    message = "Success!",
                    count = records.Count,
                    data = records
                });
            }
            catch (Exception ex)
            {
                return BadRequest($"Error: {ex.Message}");
            }
        }
    }
}
using IronXL;
using Microsoft.AspNetCore.Mvc;
namespace CsvTestProject.Controllers
{
    [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];
                    var product = new Product
                    {
                        ProductCode = row.Columns[0].StringValue,
                        Quantity = row.Columns[1].IntValue,
                        LastUpdated = row.Columns[2].DateTimeValue ?? default(DateTime)
                    };
                    records.Add(product);
                }
                return Ok(new
                {
                    message = "Success!",
                    count = records.Count,
                    data = records
                });
            }
            catch (Exception ex)
            {
                return BadRequest($"Error: {ex.Message}");
            }
        }
    }
}
Imports IronXL
Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Threading.Tasks

Namespace CsvTestProject.Controllers
    <Route("api/[controller]")>
    <ApiController>
    Public Class CsvController
        Inherits ControllerBase

        <HttpPost("upload")>
        Public Async Function UploadCsv(file As IFormFile) As Task(Of IActionResult)
            If file Is Nothing OrElse file.Length = 0 Then
                Return BadRequest("Please upload a valid CSV file.")
            End If

            Try
                Using stream As New MemoryStream()
                    Await file.CopyToAsync(stream)
                    stream.Position = 0
                    Dim workbook As WorkBook = WorkBook.Load(stream, "csv")
                    Dim ws As WorkSheet = workbook.DefaultWorkSheet
                    Dim records As New List(Of Product)()

                    ' Skip header row, iterate through data rows
                    For i As Integer = 1 To ws.Rows.Count() - 1
                        Dim row = ws.Rows(i)
                        Dim product As New Product With {
                            .ProductCode = row.Columns(0).StringValue,
                            .Quantity = row.Columns(1).IntValue,
                            .LastUpdated = If(row.Columns(2).DateTimeValue, default(DateTime))
                        }
                        records.Add(product)
                    Next

                    Return Ok(New With {
                        .message = "Success!",
                        .count = records.Count,
                        .data = records
                    })
                End Using
            Catch ex As Exception
                Return BadRequest($"Error: {ex.Message}")
            End Try
        End Function
    End Class
End Namespace
$vbLabelText   $csharpLabel

Resultado

Importación de CSV de ASP: Guía completa para desarrolladores de C#: Imagen 2: Salida correcta con los datos leídos desde nuestro archivo CSV importado

Este método de tarea asíncrona pública acepta una solicitud POST con el archivo CSV en el cuerpo de la solicitud. El código crea un MemoryStream, copia el contenido del archivo cargado y luego pasa la transmisión directamente a IronXL. La operación de retorno de registros serializa la colección como JSON, que las aplicaciones cliente pueden consumir inmediatamente.

Para un proyecto de API web .NET Core, cree el punto final utilizando dotnet new webapp o su plantilla de proyecto preferida. La configuración de ruta hace que el punto final de la API sea accesible en /api/csv/upload. Si está trabajando con Razor Pages, puede activar esta carga desde su página de índice. Simplemente agregue un formulario HTML con una entrada de archivo y un botón de envío usando la clase Bootstrap btn btn primary para darle estilo a la interfaz de usuario.

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

Después de analizar los archivos CSV, normalmente conservará los registros en una base de datos. A continuación se explica cómo ampliar la clase CsvService para escribir datos utilizando Entity Framework:

public class CsvService
{
    private readonly AppDbContext _context;
    public CsvService(AppDbContext context)
    {
        _context = context;
    }
    public async Task<int> ImportProducts(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();
    }
}
public class CsvService
{
    private readonly AppDbContext _context;
    public CsvService(AppDbContext context)
    {
        _context = context;
    }
    public async Task<int> ImportProducts(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();
    }
}
Imports System.IO
Imports System.Threading.Tasks

Public Class CsvService
    Private ReadOnly _context As AppDbContext

    Public Sub New(context As AppDbContext)
        _context = context
    End Sub

    Public Async Function ImportProducts(csvStream As Stream) As Task(Of Integer)
        Dim workbook As WorkBook = WorkBook.LoadCSV(csvStream)
        Dim ws As WorkSheet = workbook.DefaultWorkSheet
        Dim products As New List(Of Product)()

        For Each row In ws.Rows.Skip(1)
            products.Add(New Product With {
                .Id = row.Columns(0).IntValue,
                .Name = row.Columns(1).StringValue,
                .Price = row.Columns(2).DecimalValue,
                .Quantity = row.Columns(3).IntValue
            })
        Next

        Await _context.Products.AddRangeAsync(products)
        Return Await _context.SaveChangesAsync()
    End Function
End Class
$vbLabelText   $csharpLabel

El bucle foreach procesa cada fila mientras Skip(1) maneja la fila del encabezado del archivo CSV. Este patrón escala de manera eficiente para leer archivos CSV con miles de registros.

¿Por qué elegir IronXL para operaciones CSV?

IronXL simplifica los flujos de trabajo de importación de CSV al proporcionar una API consistente que funciona en formatos CSV, Excel y TSV. A diferencia de las implementaciones manuales de StreamReader o el paquete CsvHelper, IronXL ofrece:

  • Detección y manejo automático de delimitadores
  • Conversión de tipos incorporada para valores numéricos y de fecha
  • Compatibilidad multiplataforma con .NET Core, .NET Framework y .NET Standard
  • Dependencia cero de la instalación de Microsoft Office o Excel

La biblioteca también admite la creación y escritura de archivos CSV utilizando el método SaveAsCsv, lo que la convierte en una solución completa para operaciones CSV bidireccionales.

¿Está listo para optimizar el manejo de sus archivos CSV? Descargue IronXL y comience a crear funciones sólidas de importación de datos hoy mismo. Para aplicaciones de producción, explore las opciones de licencia de IronXL para desbloquear todo el poder de la biblioteca.

Conclusión

Al final del día, importar datos no debería ser la parte más frustrante de la semana. Al utilizar una herramienta especializada, puede evitarse el dolor de cabeza de inicializar manualmente un nuevo lector de flujo para cada archivo o luchar con delimitadores rotos.

Ya sea que esté creando una aplicación .NET Core empresarial masiva o simplemente un proyecto pequeño, este enfoque mantiene su código limpio y su enfoque en los datos en sí. Continúe, tome su clave real, pruebe estos ejemplos exhaustivamente y vea cuánto más agradable puede ser realmente una tarea de importación de CSV.

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 optimizada 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 intuitiva 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, agilizando el proceso de importación 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