Í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 implica leer un flujo de datos, analizar filas delimitadas y asignar cada registro a un objeto tipado, todo ello antes de poder hacer nada útil con los datos. IronXL gestiona cada paso a través de una única API que funciona igual de bien con archivos CSV, XLSX y TSV, por lo que puedes dedicar tu tiempo a la lógica de tu aplicación en lugar de a casos extremos de división de cadenas.

Comienza tu prueba gratuita para seguir el proceso y probar estos ejemplos de código en tu propio Entorno.

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

Antes de escribir cualquier código de análisis, añade IronXL a tu proyecto. Abre la Consola del Administrador de paquetes en Visual Studio o un terminal en el directorio de tu proyecto y ejecuta 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á destinado 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 es necesario instalar Microsoft Office en el servidor. Una vez restaurado el paquete, añada using IronXL; al principio de cualquier archivo que llame a la biblioteca.

Para conocer las opciones de configuración detalladas, incluida la instalación global de la herramienta y la configuración del canal de CI/CD, consulte la guía de instalación de IronXL.

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

Importar un archivo CSV en .NET Core requiere leer el flujo de datos del servidor, analizar cada fila y asignar los valores a una clase de modelo. Mientras que algunos desarrolladores recurren a implementaciones manuales StreamReader o a paquetes de terceros, IronXL ofrece un único método que gestiona archivos CSV junto con formatos de Excel sin necesidad de 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}");
}
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 productName As String = row.Columns(1).StringValue
    Dim price As Decimal = row.Columns(2).DecimalValue
    Console.WriteLine($"Product: {productName}, Price: {price}")
Next
$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 en la que 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 gestiona los campos entre comillas que contienen comas dentro del valor. No es necesario configurar un delimitador manualmente para los archivos CSV estándar.

Los accesores de valores de celda como StringValue, DecimalValue, IntValue y DateTimeValue gestionan la conversión de tipos, por lo que se 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 valor predeterminado del tipo en lugar de lanzar una excepción, lo que evita errores no controlados durante las operaciones de importación masiva.

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

ASP Import CSV: Una guía completa para desarrolladores de C#: Imagen 1 - Importación de un archivo CSV sencillo 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 enteros, decimales y valores DateTime. Para los datos de inventario de productos, crea una clase con propiedades que coincidan con cada columna del 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; }
}
Public Class Product
    Public Property Id As Integer
    Public Property Name As String = String.Empty
    Public Property Price As Decimal
    Public Property Quantity As Integer
End Class
$vbLabelText   $csharpLabel

Análisis de filas CSV en colecciones tipadas

Una vez definida la clase de modelo, puede analizar registros CSV en una colección tipada. El siguiente ejemplo omite la fila del encabezado utilizando un índice de bucle y asigna cada fila posterior 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.");
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 (index 0), 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 {
        .Id = row.Columns(0).IntValue,
        .Name = row.Columns(1).StringValue,
        .Price = row.Columns(2).DecimalValue,
        .Quantity = row.Columns(3).IntValue
    }
    records.Add(product)
Next

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

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

Tratamiento de campos opcionales y nulos

Los archivos CSV reales suelen contener celdas vacías o columnas opcionales. Los accesores de valor de IronXL devuelven valores predeterminados en lugar de excepciones cuando una celda está en blanco. Para los tipos nulos, puede 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;
' Reading an optional DateTime field
Dim lastUpdated As DateTime? = If(String.IsNullOrEmpty(row.Columns(4).StringValue), Nothing, row.Columns(4).DateTimeValue)
$vbLabelText   $csharpLabel

Este patrón mantiene tu código de importación defensivo sin envolver cada acceso a una celda en un bloque try-catch. Para obtener orientación sobre cómo manejar tipos de datos complejos y archivos de gran tamaño, consulte 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 la carga de archivos CSV desde un navegador, es necesario combinar IFormFile de ASP.NET Core con las capacidades de análisis sintáctico de IronXL. El siguiente código muestra una implementación completa del controlador 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}");
        }
    }
}
Imports IronXL
Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Threading.Tasks

<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)
                    records.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

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

Configuración del punto final y del formulario multiparte

Para que la acción [HttpPost("upload")] acepte la carga de archivos, el proyecto debe admitir datos de formulario multiparte. En Program.cs, para una configuración mínima de la API, asegúrate de haber llamado a builder.Services.AddControllers() y app.MapControllers(). Se puede acceder al punto final en /api/csv/upload.

Al realizar pruebas desde un formulario de navegador, establezca el atributo enctype del formulario en multipart/form-data y utilice un elemento de entrada de archivo. Para clientes de API como Postman, seleccione "form-data" en el cuerpo de la solicitud, añada una clave denominada 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 utilizar inmediatamente.

ASP Import CSV: Una guía completa para desarrolladores de C#: Imagen 2 - Resultado satisfactorio con los datos leídos del archivo CSV importado

Validación del tipo de archivo antes del análisis

Antes de pasar el flujo a IronXL, valida la extensión del archivo para rechazar las 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.");
Dim extension As String = Path.GetExtension(file.FileName).ToLowerInvariant()
If extension <> ".csv" AndAlso extension <> ".txt" Then
    Return BadRequest("Only CSV files are accepted.")
End If
$vbLabelText   $csharpLabel

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

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

Tras analizar los archivos CSV en objetos tipados, lo habitual es guardar los registros en una base de datos. El siguiente ejemplo amplía el patrón de capa de servicio utilizando 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();
    }
}
Imports IronXL

Public Class CsvImportService
    Private ReadOnly _context As AppDbContext

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

    Public Async Function ImportProductsAsync(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

Integración del servicio en la inyección de dependencias

Registra CsvImportService en Program.cs para que el controlador pueda solicitarlo mediante la inyección de constructores:

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

A continuación, actualice el constructor del controlador para que acepte el servicio y llame a ImportProductsAsync en lugar de crear la lista en línea. Esta separación mantiene las acciones del controlador ligeras y traslada la lógica de acceso a los datos a una clase de servicio que se puede probar. Entity Framework Core agrupa la llamada AddRangeAsync en una única instrucción INSERT por lote, lo que funciona bien con archivos CSV que contienen miles de filas.

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

¿Cómo se exportan los datos de vuelta a CSV utilizando IronXL?

IronXL no se limita a leer archivos CSV, sino que 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.");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)
Dim ws As WorkSheet = 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 archivos delimitados por punto y coma, comunes en las configuraciones regionales europeas, llame a SaveAsCsv("export.csv", ";") con un argumento de 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 utilizando File(stream, "text/csv", "export.csv").

Para obtener información completa sobre las opciones de exportación, consulte la documentación de IronXL sobre guardar y exportar.

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

El análisis manual de archivos CSV parece sencillo hasta que te encuentras con casos extremos: valores que contienen comas entre comillas, saltos de línea incrustados en una celda, comillas de escape y marcas de orden de bytes al principio de los archivos UTF-8. Gestionar todo esto correctamente en un bucle StreamReader personalizado requiere pruebas exhaustivas y un mantenimiento continuo.

IronXL aborda todos estos casos de forma interna. La comparación de los dos enfoques muestra claras ventajas:

IronXL frente a StreamReader manual para el análisis de CSV en C#
Capacidad IronXL Manual de StreamReader
Detección automática de delimitadores Sí No -- debe configurarse manualmente
Manejo de campos entrecomillados Integrado Requiere lógica personalizada
Conversión de tipos (int, decimal, DateTime) Accesores integrados Requiere llamadas a Parse/TryParse
Valores de celda de varias líneas Gestionado automáticamente Difícil de implementar correctamente
Gestión de la lista de materiales (BOM) Automático Requiere configuración de StreamReader
Compatibilidad con el formato Excel (XLSX, XLS) Misma API Requiere una biblioteca independiente
Exportar a CSV Método SaveAsCsv Requiere lógica de escritura independiente

Coherencia entre formatos

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

Esta API multiformato te permite escribir y probar una sola 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 de gran tamaño

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

  • Carga el archivo desde una ruta en lugar de copiarlo a un MemoryStream para reducir la asignación de memoria.
  • Procese las filas por 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 abarca optimizaciones adicionales para escenarios de importación de gran volumen, incluyendo el procesamiento paralelo y los modos de streaming.

¿Cuales son tus próximos pasos?

Ahora dispones de un patrón de trabajo para cada etapa de la importación de CSV en ASP.NET Core: instalación de la biblioteca, carga de archivos desde el disco o flujos cargados, asignación de filas a objetos de modelo tipados, almacenamiento de registros en una base de datos con Entity Framework Core y exportación de datos de vuelta a CSV cuando sea necesario.

Para ampliar esta base, explore estos recursos:

Con IronXL en su proyecto, añadir compatibilidad con la carga de archivos XLSX junto con CSV no requiere cambios adicionales en el código: la misma llamada WorkBook.Load gestiona ambos formatos. Esa coherencia significa que puede ampliar el conjunto de funciones 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

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame