IronXL para SII AEAT: Alternativas a CsvWriter en C# para declaraciones fiscales
En entornos de cumplimiento fiscal español, el tratamiento de ficheros CSV y Excel es una operación cotidiana. Los departamentos de contabilidad necesitan leer datos del SII (Suministro Inmediato de Información) para preparar declaraciones ante la AEAT, convertir registros de facturas al formato XLSX requerido por los modelos tributarios y ejecutar todo esto en servidores Linux o Docker sin tener instalado Microsoft Office. En este artículo comparamos IronXL y CSVWriter para cubrir estas necesidades de manera eficiente en C# .NET.
En este artículo vamos a discutir y comparar cómo trabajar con documentos de Microsoft Excel programáticamente en tecnologías C# .NET, ya sea en formato CSV o el formato estándar de Excel, utilizando dos de las bibliotecas más populares, IronXL y CSVWriter. Para desarrolladores que trabajan con declaraciones AEAT —como el modelo 303, 347, 390 o 130— la capacidad de generar XLSX desde código sin dependencias de Office es esencial.
Veamos primero lo que ambas bibliotecas tienen para ofrecer.
La biblioteca IronXL
IronXL es una biblioteca .NET que facilita la lectura y edición de documentos de Microsoft Excel con C#. IronXL.Excel es una biblioteca de software .NET independiente para leer una amplia gama de formatos de hojas de cálculo. No requiere tener Microsoft Excel instalado, ni depende de Interop.
IronXL es una API intuitiva de C# que te permite leer, editar y crear archivos de hojas de cálculo de Excel en .NET con un rendimiento ultra rápido. IronXL es compatible con .NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS y Azure.
IronXL es una librería Excel C# SII AEAT de referencia: al ejecutarse sobre Linux/Docker sin Office, es ideal para flujos de trabajo de preparación del SII en servidores cloud y para generar los ficheros XLSX de los modelos 303, 347, 390 y 130 de la AEAT.
IronXL es una biblioteca Excel destacada para C# en .NET Core y .NET Framework.
Conjunto de características de IronXL
- Cargar, leer y editar datos — de XLS/XLSX/CSV/TSV
- Guardar y exportar — a XLS/XLSX/CSV/TSV/JSON
- Rangos: sintaxis de hoja de trabajo fácil de usar ["A1:B10"]. Combina y crea rangos de manera intuitiva.
- Ordenar — ordenar rangos, columnas y filas.
- Estilos: estilos visuales de celda, fuente, tamaño, patrón de fondo, borde, alineación y formatos de número.
CSVWriter
Una biblioteca .NET para escribir archivos CSV. Extremadamente rápida, flexible y fácil de usar. Compatible con escritura de objetos de clase personalizados.
Características de CsvWriter
- Rápido: compila clases en el vuelo para un rendimiento extremadamente rápido
- Flexible: conservador al escribir, liberal al leer
- Fácil de usar: leer y escribir son tan simples como
GetRecords<t>()yWriteRecords(records) - Altamente configurable
- Modo Linux
- Uso de memoria baja
1. Crear una aplicación de consola
Utiliza los siguientes pasos para crear una Aplicación de Consola:
- Inicia el IDE de Visual Studio 2022.
- Haz clic en "Crear nuevo proyecto".
- En la página "Crear nuevo proyecto", seleccionaC#en la lista desplegable del idioma,Windowsde la lista dePlataformasyConsolade la lista de "Tipos de proyecto".
- SeleccionaAplicación de consola (.NET Framework)de las plantillas de proyecto mostradas.
*Crear proyecto - Aplicación de consola*
- Haz clic enSiguiente.
- En la pantalla deInformación adicional, especifica laVersión de Frameworkque deseas utilizar. Usaremos.NET Framework 4.8en este ejemplo.
*Crear proyecto - .NET Framework*
- Haz clic enCrearpara completar el proceso.
El proyecto ahora está creado y estamos casi listos para probar las bibliotecas. Sin embargo, aún necesitamos instalarlas e integrarlas en nuestro proyecto. Instalemos IronXL primero.
2. Instalación de la biblioteca IronXL C
Puedes descargar e instalar la biblioteca IronXL utilizando los siguientes métodos:
- Usar Visual Studio con paquetes de NuGet
- Descargando el Paquete NuGet directamente
- Instalar manualmente con el DLL
Echemos un vistazo más de cerca a cada uno.
2.1. Uso de Visual Studio con paquetes NuGet
Visual Studio proporciona el Administrador de Paquetes NuGet para instalar paquetes NuGet en tus proyectos. Puedes acceder a él a través del menú Proyecto, o haciendo clic derecho en tu proyecto en el Explorador de Soluciones.
*Seleccionar-Administrar-Paquete-NuGet*
- Ahora, desde la pestaña de navegación -> busca IronXL.Excel -> Instalar
*Buscar IronXL*
- Y hemos terminado.
2.2. Descargar el paquete NuGet directamente
Esto se puede hacer visitando el sitio de NuGet directamente y descargando el paquete. Los pasos son:
- Navigate tohttps://www.nuget.org/packages/IronXL.Excel
- Selecciona "Descargar Paquete"
- Haz doble clic en el paquete descargado
- El paquete será instalado
- Recarga tu proyecto de Visual Studio y comienza a usarlo
2.3. Instalación manual con la DLL
Otra manera de descargar e instalar la biblioteca C# de IronXL es utilizar los siguientes pasos para instalar elpaquete NuGet IronXLa través del Símbolo del sistema del desarrollador.
- Abre el Símbolo del sistema del desarrollador, normalmente se encuentra en la carpeta de Visual Studio.
- Escribe el siguiente comando:
Install-Package IronXL.Excel
- Presiona Enter
- Esto descargará e instalará el paquete
- Recarga tu proyecto de Visual Studio y comienza a usarlo
2.4. Agregar directivas de uso necesarias
- En el Explorador de soluciones, haz clic derecho en el archivo Program.cs y luego haz clic en Ver código.
- Agrega las siguientes directivas using en la parte superior del archivo de código:
using IronXL;
using IronXL;
Imports IronXL
¡Todo listo! IronXL está descargado, instalado y listo para usar. Sin embargo, antes de eso, debemos instalar CsvHelper.
3. Instalación de CSVWriter
3.1. Uso de la consola del administrador de paquetes NuGet
Para trabajar con CSVWriter necesitas descargar e instalar la biblioteca C# CsvHelper. Para hacerlo, utiliza los siguientes pasos para instalar elpaquete NuGeta través del Símbolo del sistema del desarrollador.
- Abre el Símbolo del sistema del desarrollador, normalmente se encuentra en la carpeta de Visual Studio.
- Escribe el siguiente comando:
Install-Package CsvHelper -Version 27.2.1
- Presiona Enter
- Esto descargará e instalará el paquete
- Recarga tu proyecto de Visual Studio y comienza a usarlo
- Revisa el detalle del método CsvHelper.CsvWriter para la implementación
3.2. Descarga directa
Download from the NuGet website: https://www.nuget.org/packages/CsvHelper/
4. Trabajar con archivos CSV con IronXL
Un archivo de valores separados por comas (CSV) es un archivo de texto delimitado que utiliza una coma para separar los valores. Cada línea del archivo es un registro de datos. Manipular estos archivos para cálculos puede ser una tarea desafiante, pero IronXL proporciona una opción bastante buena y fácil para lograrlo, y sin utilizar Microsoft Excel. Primero vamos a convertir un archivo CSV a un archivo de Excel normal.
4.1. Convertir un archivo CSV a formato Excel
El proceso es bastante simple y fácil. Generalmente se hace con una línea de código.
CSV a formatos de Excel:
// Load the CSV file and specify the format and delimiter
WorkBook workbook = WorkBook.LoadCSV("test.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
// Get the default worksheet
WorkSheet ws = workbook.DefaultWorkSheet;
// Save the workbook as an Excel file
workbook.SaveAs("CsvToExcelConversion.xlsx");
// Load the CSV file and specify the format and delimiter
WorkBook workbook = WorkBook.LoadCSV("test.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
// Get the default worksheet
WorkSheet ws = workbook.DefaultWorkSheet;
// Save the workbook as an Excel file
workbook.SaveAs("CsvToExcelConversion.xlsx");
' Load the CSV file and specify the format and delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("test.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
' Get the default worksheet
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Save the workbook as an Excel file
workbook.SaveAs("CsvToExcelConversion.xlsx")
4.2. Leer y manipular archivos CSV convertidos con IronXL
La clase WorkBook de IronXL representa una hoja de Excel. Para abrir un archivo de Excel usando C#, utilizamos WorkBook.Load y especificamos la ruta del archivo de Excel (.xlsx). La siguiente línea de código se utiliza para abrir el archivo para lectura:
// Load WorkBook
var workbook = WorkBook.Load(@"Spreadsheets\\sample.xlsx");
// Load WorkBook
var workbook = WorkBook.Load(@"Spreadsheets\\sample.xlsx");
' Load WorkBook
Dim workbook = WorkBook.Load("Spreadsheets\\sample.xlsx")
Cada WorkBook puede contener múltiples objetos WorkSheet. Estos representan las hojas de trabajo en el documento de Excel. Si el libro contiene hojas de trabajo, recupéralas por nombre de la siguiente manera:
// Open Sheet for reading
var worksheet = workbook.GetWorkSheet("sheetnamegoeshere");
// Open Sheet for reading
var worksheet = workbook.GetWorkSheet("sheetnamegoeshere");
' Open Sheet for reading
Dim worksheet = workbook.GetWorkSheet("sheetnamegoeshere")
Código para leer los valores de las celdas:
// Read from Ranges of cells elegantly.
foreach (var cell in worksheet["A2:A10"])
{
Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}
// Read from Ranges of cells elegantly.
foreach (var cell in worksheet["A2:A10"])
{
Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}
' Read from Ranges of cells elegantly.
For Each cell In worksheet("A2:A10")
Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next cell
Después de cargar y leer el libro de trabajo y la hoja de trabajo, se puede utilizar el siguiente ejemplo de código para realizar cambios en las fórmulas o aplicar fórmulas a celdas específicas. El código es el siguiente:
// Set Formulas
worksheet["A1"].Formula = "Sum(B8:C12)";
worksheet["B8"].Formula = "=C9/C11";
worksheet["G30"].Formula = "Max(C3:C7)";
// Force recalculate all formula values in all sheets.
workbook.EvaluateAll();
// Set Formulas
worksheet["A1"].Formula = "Sum(B8:C12)";
worksheet["B8"].Formula = "=C9/C11";
worksheet["G30"].Formula = "Max(C3:C7)";
// Force recalculate all formula values in all sheets.
workbook.EvaluateAll();
' Set Formulas
worksheet("A1").Formula = "Sum(B8:C12)"
worksheet("B8").Formula = "=C9/C11"
worksheet("G30").Formula = "Max(C3:C7)"
' Force recalculate all formula values in all sheets.
workbook.EvaluateAll()
4.3. Guardar el documento de Excel como archivo CSV
Escribir archivos CSV es un proceso fácil con IronXL. El siguiente código simplemente guarda el archivo de Excel en el formato CSV usando el método SaveAsCsv.
// Load the workbook
WorkBook wb = WorkBook.Load("Normal_Excel_File.xlsx");
// Save as .csv file
wb.SaveAsCsv("SaveAsCSV.csv", ",");
// Saved as : SaveAsCSV.Sheet1.csv
// Load the workbook
WorkBook wb = WorkBook.Load("Normal_Excel_File.xlsx");
// Save as .csv file
wb.SaveAsCsv("SaveAsCSV.csv", ",");
// Saved as : SaveAsCSV.Sheet1.csv
' Load the workbook
Dim wb As WorkBook = WorkBook.Load("Normal_Excel_File.xlsx")
' Save as .csv file
wb.SaveAsCsv("SaveAsCSV.csv", ",")
' Saved as : SaveAsCSV.Sheet1.csv
4.4. IronXL genera ficheros SII para AEAT: ejemplo con modelo 303
Un caso de uso real en España es la preparación del SII (Suministro Inmediato de Información) a la AEAT. Las empresas deben remitir facturas en XML al SII de manera casi inmediata; IronXL permite leer el CSV de SII exportado por tu ERP y convertirlo a XLSX para conciliar con el modelo 303 (declaración trimestral del IVA), el modelo 347 (operaciones con terceros superiores a 3.005,06 €) o el modelo 390 (resumen anual del IVA).
El siguiente ejemplo muestra cómo leer un CSV con datos de facturas emitidas, filtrar sólo las columnas necesarias para cumplir con la LOPDGDD (minimización de datos) y generar el XLSX del modelo 303:
using IronXL;
using System.Data;
// Leer CSV de SII exportado por el ERP
WorkBook csvSII = WorkBook.LoadCSV("facturas_sii_q1.csv",
fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ";");
WorkSheet hoja = csvSII.DefaultWorkSheet;
// Crear libro de trabajo para el modelo 303 (IVA trimestral AEAT)
WorkBook modelo303 = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet ws303 = modelo303.CreateWorkSheet("Modelo303_T1");
// Cabeceras AEAT modelo 303 - sólo columnas requeridas (LOPDGDD: minimización de datos)
ws303["A1"].Value = "NIF Emisor";
ws303["B1"].Value = "Fecha Factura";
ws303["C1"].Value = "Base Imponible";
ws303["D1"].Value = "Cuota IVA (21%)";
ws303["E1"].Value = "Tipo Operación SII";
// Transferir registros desde el CSV del SII al XLSX del modelo 303
int fila = 2;
foreach (var row in hoja.Rows.Skip(1)) // omitir cabecera
{
ws303["A" + fila].Value = row[0].StringValue; // NIF
ws303["B" + fila].Value = row[2].StringValue; // Fecha
ws303["C" + fila].Value = row[5].DoubleValue; // Base
ws303["D" + fila].Value = row[5].DoubleValue * 0.21; // IVA 21%
ws303["E" + fila].Value = row[8].StringValue; // Tipo SII
fila++;
}
// Exportar XLSX para presentación AEAT
modelo303.SaveAs("AEAT_Modelo303_T1_2026.xlsx");
using IronXL;
using System.Data;
// Leer CSV de SII exportado por el ERP
WorkBook csvSII = WorkBook.LoadCSV("facturas_sii_q1.csv",
fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ";");
WorkSheet hoja = csvSII.DefaultWorkSheet;
// Crear libro de trabajo para el modelo 303 (IVA trimestral AEAT)
WorkBook modelo303 = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet ws303 = modelo303.CreateWorkSheet("Modelo303_T1");
// Cabeceras AEAT modelo 303 - sólo columnas requeridas (LOPDGDD: minimización de datos)
ws303["A1"].Value = "NIF Emisor";
ws303["B1"].Value = "Fecha Factura";
ws303["C1"].Value = "Base Imponible";
ws303["D1"].Value = "Cuota IVA (21%)";
ws303["E1"].Value = "Tipo Operación SII";
// Transferir registros desde el CSV del SII al XLSX del modelo 303
int fila = 2;
foreach (var row in hoja.Rows.Skip(1)) // omitir cabecera
{
ws303["A" + fila].Value = row[0].StringValue; // NIF
ws303["B" + fila].Value = row[2].StringValue; // Fecha
ws303["C" + fila].Value = row[5].DoubleValue; // Base
ws303["D" + fila].Value = row[5].DoubleValue * 0.21; // IVA 21%
ws303["E" + fila].Value = row[8].StringValue; // Tipo SII
fila++;
}
// Exportar XLSX para presentación AEAT
modelo303.SaveAs("AEAT_Modelo303_T1_2026.xlsx");
Imports IronXL
Imports System.Data
' Leer CSV de SII exportado por el ERP
Dim csvSII As WorkBook = WorkBook.LoadCSV("facturas_sii_q1.csv", fileFormat:=ExcelFileFormat.XLSX, ListDelimiter:=";")
Dim hoja As WorkSheet = csvSII.DefaultWorkSheet
' Crear libro de trabajo para el modelo 303 (IVA trimestral AEAT)
Dim modelo303 As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim ws303 As WorkSheet = modelo303.CreateWorkSheet("Modelo303_T1")
' Cabeceras AEAT modelo 303 - sólo columnas requeridas (LOPDGDD: minimización de datos)
ws303("A1").Value = "NIF Emisor"
ws303("B1").Value = "Fecha Factura"
ws303("C1").Value = "Base Imponible"
ws303("D1").Value = "Cuota IVA (21%)"
ws303("E1").Value = "Tipo Operación SII"
' Transferir registros desde el CSV del SII al XLSX del modelo 303
Dim fila As Integer = 2
For Each row In hoja.Rows.Skip(1) ' omitir cabecera
ws303("A" & fila).Value = row(0).StringValue ' NIF
ws303("B" & fila).Value = row(2).StringValue ' Fecha
ws303("C" & fila).Value = row(5).DoubleValue ' Base
ws303("D" & fila).Value = row(5).DoubleValue * 0.21 ' IVA 21%
ws303("E" & fila).Value = row(8).StringValue ' Tipo SII
fila += 1
Next
' Exportar XLSX para presentación AEAT
modelo303.SaveAs("AEAT_Modelo303_T1_2026.xlsx")
Este flujo se ejecuta íntegramente en Linux/Docker sin instalar Office, lo que lo hace apto para infraestructuras cloud de empresas reguladas por el Banco de España o la CNMV que deben generar informes prudenciales en XLSX.
5. Trabajar con datos CSV mediante CSVWriter
Escribir datos en un archivo CSV es una operación común. El método CSVWriter de CSVHelper con un separador suministrado maneja todos los caracteres y caracteres de nueva línea en un escritor CSV muy simple publicado para C#. Aquí vamos a ver cómo escribir datos usando CSVWriter.
5.1. Crear una aplicación de consola sencilla
Crea una aplicación de consola simple de CSVWriter con separador suministrado usando Visual Studio. Una vez creado el proyecto, el siguiente paso es crear una clase Person:
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
public bool IsLiving { get; set; }
}
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
public bool IsLiving { get; set; }
}
Public Class Person
Public Property Id() As Integer
Public Property Name() As String
Public Property IsLiving() As Boolean
End Class
Dentro del método Main, ahora hagamos una lista de objetos Person que escribiremos en el archivo CSV:
var myPersonObjects = new List<Person>()
{
new Person { Id = 1, IsLiving = true, Name = "John" },
new Person { Id = 2, IsLiving = true, Name = "Steve" },
new Person { Id = 3, IsLiving = true, Name = "James" }
};
var myPersonObjects = new List<Person>()
{
new Person { Id = 1, IsLiving = true, Name = "John" },
new Person { Id = 2, IsLiving = true, Name = "Steve" },
new Person { Id = 3, IsLiving = true, Name = "James" }
};
Dim myPersonObjects = New List(Of Person)() From {
New Person With {
.Id = 1,
.IsLiving = True,
.Name = "John"
},
New Person With {
.Id = 2,
.IsLiving = True,
.Name = "Steve"
},
New Person With {
.Id = 3,
.IsLiving = True,
.Name = "James"
}
}
5.2. Escribir en un archivo CSV en C# con la configuración predeterminada
CsvHelper ha surgido como la forma estándar de escribir CSV en C# usando el método CSVWriter, y es muy fácil de usar:
using (var writer = new StreamWriter("filePersons.csv"))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
csv.WriteRecords(myPersonObjects);
}
using (var writer = new StreamWriter("filePersons.csv"))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
csv.WriteRecords(myPersonObjects);
}
Using writer = New StreamWriter("filePersons.csv")
Using csv = New CsvWriter(writer, CultureInfo.InvariantCulture)
csv.WriteRecords(myPersonObjects)
End Using
End Using
5.3. Añadir datos
Debemos tener en cuenta el hecho de que cada vez que ejecutamos nuestro programa, los archivos CSV antiguos se sobrescribirán. A veces queremos que los datos se anexen al final de un archivo, en lugar de sobrescribir los datos existentes. CSVWriter no proporciona un método para hacer esto, ya que abrir/escribir un archivo no es responsabilidad de CSVWriter con separador suministrado. Podemos lograr esto utilizando un FileStream, y luego construyendo nuestro StreamWriter utilizando ese FileStream. Aunque esto no entra dentro del alcance de este artículo, te mostraré cómo hacerlo, ya que es una parte integral de cualquier aplicación.
var configPersons = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false
};
using (var stream = File.Open("filePersons.csv", FileMode.Append))
using (var writer = new StreamWriter(stream))
using (var csv = new CsvWriter(writer, configPersons))
{
csv.WriteRecords(myPersonObjects);
}
var configPersons = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false
};
using (var stream = File.Open("filePersons.csv", FileMode.Append))
using (var writer = new StreamWriter(stream))
using (var csv = new CsvWriter(writer, configPersons))
{
csv.WriteRecords(myPersonObjects);
}
Dim configPersons = New CsvConfiguration(CultureInfo.InvariantCulture) With {.HasHeaderRecord = False}
Using stream = File.Open("filePersons.csv", FileMode.Append)
Using writer = New StreamWriter(stream)
Using csv = New CsvWriter(writer, configPersons)
csv.WriteRecords(myPersonObjects)
End Using
End Using
End Using
Anexar a un archivo existente es complicado, sin embargo, porque el orden puede cambiar cuando anexamos, o podemos haber agregado nuevas propiedades. Debemos asegurarnos de tener esto en cuenta al anexar.
5.4. IronXL para TicketBAI y VeriFactu: exportación XLSX conforme a normativa vasca y estatal
Las empresas del País Vasco sujetas a TicketBAI (Bizkaia, Gipuzkoa y Araba) deben generar registros de facturación con firma electrónica. IronXL puede generar los XLSX complementarios que acompañan los ficheros XML de TicketBAI, facilitando la conciliación contable. Del mismo modo, el VeriFactu (Real Decreto-Ley 15/2025) exige que los sistemas informatizados de facturación generen registros de facturas verificables; IronXL genera los XLSX de respaldo que documentan cada registro VERI*FACTU.
Para entidades reguladas por el Banco de España o la CNMV, que deben presentar informes prudenciales en XLSX, IronXL es la solución ideal al ejecutarse sin Office en entornos Linux. El hecho de que CSVWriter solo trate ficheros CSV lo descarta para estos flujos de trabajo de cumplimiento normativo.
6. Licencias
IronXL is an openly commercial C# Excel library. It is free for development and can always be licensed for commercial deployment.Licenses are availablefor single-project use, single developers, agencies, and global corporations, as well as SaaS and OEM redistribution. Todas las licencias incluyen una garantía de devolución de dinero de 30 días, un año de soporte al producto y actualizaciones, validez para dev/staging/producción, y también una licencia permanente (compra única). El paquete Lite comienza desde $999.
CSVWriter con separador suministrado es un elemento separado por comas completamente gratuito para uso comercial amistoso.
7. Resumen y conclusión
Resumen
IronXL es una biblioteca completa que ofrece todo lo que necesitas para poder manipular un archivo de Excel. Te proporciona la facilidad de convertir varios formatos a XLSX, y también de XLSX a otros formatos, como CSV. Esta interconversión proporciona a los usuarios la flexibilidad para manipular otros formatos de archivo con facilidad.
Para desarrolladores en España, IronXL es la opción natural para flujos de trabajo de cumplimiento fiscal: IronXL genera ficheros SII para la AEAT, crea los XLSX de los modelos 303, 347, 390 y 130, soporta exportaciones TicketBAI y VeriFactu, y funciona en Linux/Docker sin Office para entidades reguladas por el Banco de España y la CNMV. La LOPDGDD también se respeta al poder exportar sólo las columnas estrictamente necesarias para cada declaración AEAT.
Por otro lado, CSVWriter solo funciona con formatos de archivo CSV y con opciones muy limitadas. Los usuarios no pueden cambiar entre diferentes formatos de archivo, mientras que con IronXL sí pueden. Todos los ejemplos de código se pueden encontrar en los archivos de documentación de CsvHelper. Este documento proporciona pautas sobre cómo usar CSVWriter en tu proyecto.
Conclusión
IronXL tiene una clara ventaja sobre CsvHelper.CSVWriter, ya que soporta trabajar con múltiples formatos. Además, puedes aplicar fórmulas y estilos según tu elección, mientras que CsvHelper solo permite la lectura y escritura de archivos CSV, y con opciones limitadas. Además, no puedes anexar nuevos registros a un archivo CSV existente, ya que simplemente sobrescribe las entradas anteriores. Para los equipos de desarrollo que operan en el contexto regulatorio español —SII, AEAT, TicketBAI, VeriFactu— IronXL es claramente la elección adecuada.
Preguntas Frecuentes
¿Cómo genero el fichero XLSX para el modelo 303 de la AEAT con IronXL?
Con IronXL puedes leer el CSV exportado por tu ERP con los datos del SII, filtrar sólo las columnas necesarias conforme a la LOPDGDD y generar un XLSX estructurado para el modelo 303 (declaración trimestral de IVA). Todo funciona en Linux/Docker sin instalar Microsoft Office, lo que lo hace apto para servidores cloud.
¿Es IronXL válido para flujos de trabajo SII (Suministro Inmediato de Información) en España?
Sí. IronXL puede leer ficheros CSV del SII, transformar los datos y exportarlos a XLSX para su conciliación con los modelos 303, 347, 390 y 130 de la AEAT. Al funcionar sin Office en servidores Linux/Docker, encaja perfectamente en arquitecturas cloud de empresas españolas sujetas al SII.
¿Cuáles son las alternativas a CSVWriter para manejar documentos de Excel en C#?
IronXL es una excelente alternativa a CSVWriter para manejar documentos de Excel en C#. Te permite leer, editar y exportar varios formatos de Excel como XLS, XLSX, CSV y TSV sin requerir Microsoft Excel. Además, al generar XLSX directamente, es apto para declaraciones AEAT y otras obligaciones fiscales españolas.
¿Cómo puedo convertir un archivo CSV a un formato de Excel usando una biblioteca .NET?
Usando IronXL, puedes convertir fácilmente un archivo CSV a un formato de Excel cargando el CSV en un libro de trabajo y luego guardándolo como un archivo XLSX. Este proceso implica comandos de código simples para manipular y guardar los archivos, y es el punto de partida para construir el XLSX del modelo 303 o 347.
¿Qué ventajas ofrece IronXL sobre CSVWriter para cumplimiento fiscal en España?
IronXL genera XLSX para modelos AEAT (303, 347, 390, 130), soporta exportaciones TicketBAI y VeriFactu, y funciona en Linux/Docker sin Office. CSVWriter solo genera CSV, lo que lo hace insuficiente para las declaraciones que la AEAT exige en formato XLSX. Además, IronXL permite exportar solo las columnas necesarias para cumplir con la LOPDGDD.
¿Cómo instalo IronXL en mi proyecto C#?
Puedes instalar IronXL en tu proyecto C# a través del Administrador de paquetes NuGet en Visual Studio. Alternativamente, puedes descargar el paquete NuGet o instalar manualmente el DLL mediante el Símbolo del sistema del desarrollador.
¿Puede usarse IronXL en entornos .NET Core y Azure?
Sí, IronXL soporta múltiples plataformas, incluyendo .NET Core y Azure, lo que lo convierte en una opción versátil para desarrollar aplicaciones que requieren manipulación de archivos de Excel en diferentes entornos, incluyendo infraestructuras cloud de entidades reguladas por el Banco de España o la CNMV.
¿Es posible escribir objetos de clase personalizados en un archivo CSV usando CSVWriter?
Sí, CSVWriter soporta escribir objetos de clase personalizados en un archivo CSV. Proporciona un enfoque flexible y fácil de usar para escribir datos eficientemente al trabajar con archivos CSV.
¿Cuáles son los requisitos de licencia para usar IronXL en aplicaciones comerciales?
IronXL requiere una licencia para uso comercial. Es gratuito para propósitos de desarrollo, pero hay diferentes licencias disponibles según las necesidades de implementación, ya sea para proyectos singulares o aplicaciones a nivel empresarial.
¿Cómo maneja IronXL las fórmulas de Excel?
IronXL te permite aplicar y manipular fórmulas de Excel dentro de tus hojas de cálculo, proporcionando una funcionalidad robusta para el cálculo y análisis dinámico de datos directamente dentro de tus aplicaciones C#.




