Importar CSV de operaciones SII/AEAT a Excel con IronXL en C#: guía ASP.NET Core

¿Cómo instalar IronXL en un proyecto .NET para parsear CSV de operaciones SII?

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

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 —esencial para los servicios de compliance que corren en Linux/Docker. Una vez restaurado el paquete, añada using IronXL; al principio de cualquier archivo que llame a la biblioteca.

Para obtener información detallada sobre las opciones de configuración, incluida la instalación global de herramientas y la configuración del pipeline de CI/CD, consulte la guía de instalación de IronXL .

¿Cómo importar un fichero CSV del SII/AEAT en ASP.NET Core?

Importar un archivo CSV del SII en .NET Core requiere leer el flujo de datos del servidor, analizar cada fila y asignar los valores a una clase de modelo. Los ficheros CSV del Suministro Inmediato de Información pueden contener campos con punto y coma como delimitador (formato habitual en España), valores de importes decimales con coma y fechas en formato español (dd/MM/yyyy). IronXL proporciona un método único que maneja archivos CSV junto con formatos de 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}");
}

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

¿Cómo se puede crear una clase de modelo para datos CSV del SII/modelo 347?

Para asignar datos CSV del SII a objetos fuertemente tipados se requiere una clase de modelo que refleje la estructura del fichero. En el contexto del modelo 347 (operaciones con terceros superiores a 3.005,06 €), los campos típicos incluyen NIF del tercero, razón social, importe total y ejercicio fiscal. Convierte datos de cadenas sin procesar en tipos específicos, como enteros, decimales y valores DateTime:

// Modelo para operaciones SII/modelo 347
public class OperacionAEAT
{
    public string NIF_Tercero { get; set; } = string.Empty;
    public string RazonSocial { get; set; } = string.Empty;
    public decimal ImporteTotal { get; set; }
    public int EjercicioFiscal { get; set; }
}

// Modelo para operaciones SII/modelo 347
public class OperacionAEAT
{
    public string NIF_Tercero { get; set; } = string.Empty;
    public string RazonSocial { get; set; } = string.Empty;
    public decimal ImporteTotal { get; set; }
    public int EjercicioFiscal { get; set; }
}

' Modelo para operaciones SII/modelo 347
Public Class OperacionAEAT
    Public Property NIF_Tercero As String = String.Empty
    Public Property RazonSocial As String = String.Empty
    Public Property ImporteTotal As Decimal
    Public Property EjercicioFiscal As Integer
End Class

using IronXL;

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

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var operacion = new OperacionAEAT
    {
        NIF_Tercero = row.Columns[0].StringValue,
        RazonSocial = row.Columns[1].StringValue,
        ImporteTotal = row.Columns[2].DecimalValue,
        EjercicioFiscal = row.Columns[3].IntValue
    };
    records.Add(operacion);
}

// Filtrar solo las operaciones con importe > 3.005,06 € (umbral modelo 347)
var operacionesModelo347 = records.Where(o => o.ImporteTotal > 3005.06m).ToList();
Console.WriteLine($"Operaciones modelo 347: {operacionesModelo347.Count}");

using IronXL;

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

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var operacion = new OperacionAEAT
    {
        NIF_Tercero = row.Columns[0].StringValue,
        RazonSocial = row.Columns[1].StringValue,
        ImporteTotal = row.Columns[2].DecimalValue,
        EjercicioFiscal = row.Columns[3].IntValue
    };
    records.Add(operacion);
}

// Filtrar solo las operaciones con importe > 3.005,06 € (umbral modelo 347)
var operacionesModelo347 = records.Where(o => o.ImporteTotal > 3005.06m).ToList();
Console.WriteLine($"Operaciones modelo 347: {operacionesModelo347.Count}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("operaciones_sii_347.csv")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim records As New List(Of OperacionAEAT)()

' 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 operacion As New OperacionAEAT With {
        .NIF_Tercero = row.Columns(0).StringValue,
        .RazonSocial = row.Columns(1).StringValue,
        .ImporteTotal = row.Columns(2).DecimalValue,
        .EjercicioFiscal = row.Columns(3).IntValue
    }
    records.Add(operacion)
Next

' Filtrar solo las operaciones con importe > 3.005,06 € (umbral modelo 347)
Dim operacionesModelo347 = records.Where(Function(o) o.ImporteTotal > 3005.06D).ToList()
Console.WriteLine($"Operaciones modelo 347: {operacionesModelo347.Count}")

// 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)

¿Cómo se gestionan las cargas de ficheros CSV del SII en una API web?

La creación de un punto final de API que acepte cargas de archivos CSV del SII desde un navegador requiere la combinación de IFormFile de ASP.NET Core con las capacidades de análisis de IronXL. El siguiente código muestra una implementación completa del controlador que analiza el fichero CSV del SII cargado y devuelve una respuesta JSON con los registros de operaciones:

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

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

¿Cómo guardar datos CSV del SII en una base de datos respetando la LOPDGDD?

Tras analizar los ficheros CSV del SII en objetos tipados, lo habitual es guardar los registros en una base de datos. Antes de la inserción, aplique los principios de minimización de datos de la LOPDGDD: solo guarde los campos estrictamente necesarios para el cumplimiento fiscal, eliminando datos personales superfluos. El siguiente ejemplo amplía 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();
    }
}

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

builder.Services.AddScoped<CsvImportService>();

builder.Services.AddScoped<CsvImportService>();

¿Cómo se exportan datos de vuelta a CSV o XLSX con IronXL para remisión AEAT?

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, útil para generar informes o enviar datos a sistemas posteriores —como el sistema de carga de operaciones en el portal de la AEAT para el modelo 347. Para remisiones en XLSX al Banco de España o a la CNMV, use SaveAs con formato XLSX:

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

El archivo exportado utiliza delimitadores de coma de forma predeterminada. Para los archivos delimitados por punto y coma, comunes en las localizaciones europeas y en los ficheros CSV de la AEAT, 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 la 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 mejor que el análisis manual de CSV para ficheros SII/AEAT?

El análisis manual de archivos CSV parece sencillo hasta que te encuentras con casos extremos habituales en los ficheros del SII: valores que contienen comas entre comillas (nombres de razones sociales), delimitadores de punto y coma (formato europeo AEAT), saltos de línea incrustados en una celda, comillas de escape y marcas de orden de bytes al principio de los archivos UTF-8. Manejar todo esto correctamente en un bucle StreamReader personalizado requiere pruebas significativas y un mantenimiento continuo.

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

¿Cuales son tus próximos pasos?

Ahora dispones de un patrón de trabajo para cada etapa de la importación de ficheros CSV del SII/AEAT en ASP.NET Core: instalación de la biblioteca en entornos Linux/Docker, carga de archivos desde el disco o flujos cargados, asignación de filas a objetos de modelo tipados (operaciones SII, datos modelo 347), aplicación de filtros LOPDGDD antes de la inserción en base de datos, almacenamiento de registros con Entity Framework Core y exportación de datos de vuelta a CSV o XLSX para remisión a la AEAT, al Banco de España o a la CNMV.

Para ampliar esta base, explore estos recursos:

• Paquete NuGet de IronXL: detalles del paquete e historial de versiones en NuGet.org
• Descripción general de los tutoriales de IronXL: tutoriales guiados que abarcan el filtrado, la evaluación de fórmulas y la generación de gráficos
• Referencia de la API de IronXL: documentación completa de clases y métodos
• Ejemplos de IronXL en GitHub: proyectos de muestra descargables en GitHub
• Opciones de licencia de IronXL: niveles de licencia para desarrollo, entorno de pruebas y producción
• Documentación de análisis de CSV de Microsoft: información sobre el modelo .NET IO en el que se basa IronXL
• Documentación sobre la carga de archivos en ASP.NET Core: guía oficial sobre IFormFile y la configuración de la carga multiparte
• Tutorial de IronXL para leer e importar Excel: trata la lectura de archivos XLSX y CSV
• Tutorial de creación y escritura de IronXL: trata sobre la escritura de datos y el guardado en múltiples formatos
• Ordenación y filtrado de datos en IronXL: manipulación de datos importados tras su carga

Con IronXL en su proyecto, la adición de soporte para cargas XLSX junto con CSV del SII no requiere cambios de código adicionales — la misma llamada WorkBook.Load maneja ambos. 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 compliance fiscal de su aplicación.