En España, las empresas sujetas al Suministro Inmediato de Información (SII) deben enviar en tiempo cuasi real registros de facturas en XML a la Agencia Estatal de Administración Tributaria (AEAT). El proceso habitual implica también generar ficheros XLSX para auditoría interna y para las declaraciones periódicas como el modelo 303 (IVA trimestral), el modelo 347 (operaciones con terceros superiores a 3.005,06 €) y el modelo 390 (resumen anual del IVA). En servidores Linux o contenedores Docker —entornos habituales en infraestructuras de compliance fiscal— Excel Interop simplemente no funciona. IronXL resuelve este problema: genera XLSX directamente sin depender de Office, sin interoperabilidad COM y sin licencias adicionales de Microsoft.
Para los desarrolladores de .NET, existen dos enfoques habituales: Interop de Microsoft Office y bibliotecas dedicadas a Excel, como IronXL. Esta guía repasa ambos métodos con ejemplos de código C# en funcionamiento, compara sus ventajas e inconvenientes y explica cuándo tiene sentido cada enfoque, especialmente en proyectos de aplicaciones de compliance fiscal para la AEAT.
Antes de sumergirse en el código, comprender las diferencias fundamentales entre estos dos enfoques ayuda a tomar la decisión correcta para cualquier proyecto. La comparación es especialmente relevante cuando se trabaja con declaraciones de la AEAT en entornos de servidor: el Banco de España y la CNMV también exigen remisiones periódicas de información en XLSX que se procesan en pipelines Linux sin acceso a escritorio Windows.
| Función | Interop de Microsoft Office | IronXL |
|---|---|---|
| Se requiere la instalación de Office | Sí, es necesario tener instalado Microsoft Excel | No -- biblioteca independiente |
| Compatibilidad con el lado del servidor | No recomendado por Microsoft | Totalmente compatible |
| Soporte de Plataforma | Sólo Windows | Windows, Linux, macOS, Azure |
| Compatibilidad con .NET Core / .NET 5+ | Limitado | Compatibilidad total (.NET 6, 7, 8, 9, 10) |
| Gestión de Recursos | Requiere limpieza de objetos COM | Eliminación estándar de .NET Standard |
| Método de instalación | Referencia COM + Instalación de Office | Paquete NuGet |
| Modelo de Hilos | Apartamento de un solo subproceso (STA) | Operaciones seguras |
| Conjuntos de datos de gran tamaño (ej. libro registro SII) | Proceso que consume mucha memoria | Enfoque eficiente basado en archivos |
| Formatos de archivo compatibles | XLSX, XLS, CSV | XLSX, XLS, CSV, JSON, XML |
| Licencias | Requiere licencia de Office | Licencia comercial disponible |
La diferencia arquitectónica es fundamental: Excel Interop automatiza la propia aplicación Microsoft Excel a través de COM, mientras que IronXL lee y escribe formatos de archivos Excel directamente sin iniciar ningún proceso externo. Esta distinción afecta todo, desde el uso de la memoria hasta la complejidad de la implementación. Para los sistemas de compliance fiscal (VeriFactu, TicketBAI en Bizkaia, Gipuzkoa y Araba), donde los servidores corren en Linux/Docker, IronXL es la única opción viable.
La instalación de IronXL solo lleva unos segundos a través de NuGet. No se requiere software adicional, instalación de Office ni configuración del sistema. La biblioteca se ejecuta inmediatamente después de su instalación en Windows, Linux y macOS, incluyendo Azure App Services, Azure Functions e instancias de contenedor —exactamente el entorno habitual de los servicios de generación de ficheros para el SII y las declaraciones de la AEAT.
Abra la consola del Administrador de paquetes NuGet y ejecute:
IronXL es compatible con .NET Framework 4.6.2+ y todas las versiones modernas de .NET hasta .NET 10. Una vez instalado, añada using IronXL; en la parte superior de su archivo y estará listo para exportar ficheros XLSX para la AEAT.
El enfoque tradicional utiliza el espacio de nombres Microsoft.Office.Interop.Excel para automatizar Excel directamente. Este método requiere que Microsoft Excel esté instalado en la máquina donde se ejecuta el código.
Antes de utilizar Interop, confirme que:
Microsoft.Office.Interop.Excel se incluye en el proyecto.El siguiente código muestra cómo exportar un DataTable a un archivo Excel utilizando Interop de Microsoft Office en C# con sentencias de nivel superior:
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;
// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);
// Initialize Excel Application object
Application excelApp = new Application
{
Visible = false,
DisplayAlerts = false
};
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;
try
{
// Write column headers to the first row
for (int i = 0; i < dt.Columns.Count; i++)
{
worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
}
// Write data rows starting from row 2
for (int i = 0; i < dt.Rows.Count; i++)
{
for (int j = 0; j < dt.Columns.Count; j++)
{
worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
}
}
string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created using Interop.");
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
finally
{
// Always release COM objects to prevent orphaned Excel processes
workbook.Close();
excelApp.Quit();
Marshal.ReleaseComObject(worksheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);
}Imports Microsoft.Office.Interop.Excel
Imports System.Data
Imports System.Runtime.InteropServices
' Create a sample DataTable with employee data
Dim dt As New DataTable("Employees")
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))
dt.Rows.Add(1, "John Smith", "Engineering", 75000)
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
dt.Rows.Add(3, "Michael Chen", "Finance", 70000)
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)
' Initialize Excel Application object
Dim excelApp As New Application With {
.Visible = False,
.DisplayAlerts = False
}
Dim workbook As Workbook = excelApp.Workbooks.Add()
Dim worksheet As Worksheet = CType(workbook.ActiveSheet, Worksheet)
Try
' Write column headers to the first row
For i As Integer = 0 To dt.Columns.Count - 1
worksheet.Cells(1, i + 1) = dt.Columns(i).ColumnName
Next
' Write data rows starting from row 2
For i As Integer = 0 To dt.Rows.Count - 1
For j As Integer = 0 To dt.Columns.Count - 1
worksheet.Cells(i + 2, j + 1) = dt.Rows(i)(j).ToString()
Next
Next
Dim filePath As String = "C:\Reports\EmployeeReport_Interop.xlsx"
workbook.SaveAs(filePath)
Console.WriteLine("Excel file created using Interop.")
Catch ex As Exception
Console.WriteLine("Error: " & ex.Message)
Finally
' Always release COM objects to prevent orphaned Excel processes
workbook.Close()
excelApp.Quit()
Marshal.ReleaseComObject(worksheet)
Marshal.ReleaseComObject(workbook)
Marshal.ReleaseComObject(excelApp)
End TryEl objeto Application representa el proceso Excel en sí. La configuración de Visible = false impide que Excel se abra en pantalla durante el procesamiento, lo cual es esencial para las operaciones en segundo plano. El ajuste DisplayAlerts = false suprime los cuadros de diálogo que, de otro modo, interrumpirían los flujos de trabajo automatizados.
El bloque finally no es opcional -- debe liberar cada objeto COM explícitamente usando Marshal.ReleaseComObject. Si se omite este paso, quedan procesos de Excel huérfanos en el Administrador de tareas, lo que consume memoria y, con el tiempo, desestabiliza el servidor. Este patrón de limpieza es un conocido punto débil que hace que Interop no sea adecuado para aplicaciones y servicios web —y completamente inviable para entornos Linux donde se ejecutan los servicios de envío al SII.
IronXL ofrece una alternativa moderna que funciona sin necesidad de instalar Office. La biblioteca lee y escribe archivos Excel directamente, lo que la hace ideal para entornos de servidor, implementaciones en la nube y aplicaciones multiplataforma. Para los departamentos fiscales que generan el modelo 303 (declaración trimestral de IVA), modelo 347 y modelo 390, IronXL genera ficheros XLSX directamente desde los datos del sistema contable sin requerir ninguna instalación de Office en el servidor. Consulte la documentación completa de IronXL para obtener más detalles sobre la API.
El siguiente código muestra cómo convertir un DataTable con operaciones del libro registro de IVA a un archivo XLSX utilizando IronXL —por ejemplo, para preparar el fichero de declaración del modelo 347 con operaciones con terceros superiores a 3.005,06 €:
using IronXL;
using System.Data;
// DataTable con registros de operaciones SII para modelo 347
DataTable dt = new DataTable("Operaciones347");
dt.Columns.Add("NIF_Tercero", typeof(string));
dt.Columns.Add("RazonSocial", typeof(string));
dt.Columns.Add("ImporteTotal", typeof(decimal));
dt.Columns.Add("EjercicioFiscal", typeof(int));
// Operaciones con terceros > 3.005,06 € (umbral modelo 347)
dt.Rows.Add("B12345678", "Distribuciones García S.L.", 15230.50m, 2025);
dt.Rows.Add("A87654321", "Suministros Martínez S.A.", 8750.00m, 2025);
dt.Rows.Add("B99887766", "Consultoría Fernández S.L.", 22100.75m, 2025);
dt.Rows.Add("A11223344", "Talleres López S.A.", 4320.00m, 2025);
// Create a new Excel workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Operaciones347");
// Write column headers to row 0
for (int i = 0; i < dt.Columns.Count; i++)
{
sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}
// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
for (int j = 0; j < dt.Columns.Count; j++)
{
sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
}
}
string filePath = @"/var/reports/aeat/modelo347_2025T4.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Fichero XLSX modelo 347 generado con IronXL.");Imports IronXL
Imports System.Data
' DataTable con registros de operaciones SII para modelo 347
Dim dt As New DataTable("Operaciones347")
dt.Columns.Add("NIF_Tercero", GetType(String))
dt.Columns.Add("RazonSocial", GetType(String))
dt.Columns.Add("ImporteTotal", GetType(Decimal))
dt.Columns.Add("EjercicioFiscal", GetType(Integer))
' Operaciones con terceros > 3.005,06 € (umbral modelo 347)
dt.Rows.Add("B12345678", "Distribuciones García S.L.", 15230.50D, 2025)
dt.Rows.Add("A87654321", "Suministros Martínez S.A.", 8750.00D, 2025)
dt.Rows.Add("B99887766", "Consultoría Fernández S.L.", 22100.75D, 2025)
dt.Rows.Add("A11223344", "Talleres López S.A.", 4320.00D, 2025)
' Create a new Excel workbook
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Operaciones347")
' Write column headers to row 0
For i As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(0, i, dt.Columns(i).ColumnName)
Next
' Export DataTable rows to Excel cells
For i As Integer = 0 To dt.Rows.Count - 1
For j As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
Next
Next
Dim filePath As String = "/var/reports/aeat/modelo347_2025T4.xlsx"
workbook.SaveAs(filePath)
Console.WriteLine("Fichero XLSX modelo 347 generado con IronXL.")El enfoque IronXL sigue una estructura lógica similar pero con una sintaxis más limpia y sin complejidad COM. El método WorkBook.Create inicializa un nuevo libro en el formato especificado — ExcelFileFormat.XLSX produce archivos Office Open XML modernos compatibles con Excel 2007 y versiones posteriores. La ruta /var/reports/aeat/ refleja un servidor Linux típico en un entorno de compliance fiscal.
SetCellValue utiliza índices basados en 0 que coinciden con las convenciones estándar de .NET, lo que reduce los errores de uno por uno que suelen producirse al convertir entre sistemas de índices. El método gestiona la conversión de tipos automáticamente: los valores enteros, de cadena, decimales y DateTime se escriben con los tipos de celda de Excel adecuados.
Observe la ausencia total de código de limpieza. Los objetos IronXL son objetos administrados .NET estándar que el recolector de elementos no utilizados maneja automáticamente. No hay riesgo de procesos huérfanos ni de gestión del recuento de referencias COM.
Para obtener más detalles sobre la creación de libros de trabajo, consulte la guía de creación de hojas de cálculo de IronXL.
Las aplicaciones de compliance fiscal a menudo necesitan un método reutilizable que pueda exportar cualquier DataTable —ya sea del libro registro de facturas emitidas del SII, del modelo 303 o del resumen LOPDGDD-compatible para minimizar datos personales exportados a la AEAT— a un archivo Excel. El siguiente ejemplo muestra un helper que encapsula la lógica de exportación, maneja valores nulos y crea automáticamente el directorio de salida si no existe. Consulte la página Ejemplos de IronXL para obtener más ejemplos.
using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;
// --- ExcelExporter helper ---
bool ExportToExcel(DataTable dt, string filePath)
{
if (dt == null || dt.Rows.Count == 0)
return false;
try
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");
// Bold headers in the first row
for (int i = 0; i < dt.Columns.Count; i++)
{
var cell = sheet.GetCellAt(0, i);
cell.Value = dt.Columns[i].ColumnName;
cell.Style.Font.Bold = true;
}
// Data rows
for (int i = 0; i < dt.Rows.Count; i++)
{
for (int j = 0; j < dt.Columns.Count; j++)
{
var value = dt.Rows[i][j];
sheet.SetCellValue(
i + 1, j,
(value == DBNull.Value || value == null) ? "" : value
);
}
}
FileInfo fileInfo = new FileInfo(filePath);
if (!fileInfo.Directory!.Exists)
fileInfo.Directory.Create();
workbook.SaveAs(filePath);
return true;
}
catch (Exception ex)
{
Console.WriteLine("Export failed: " + ex.Message);
return false;
}
}
// --- Usage ---
DataTable employees = new DataTable("Employees");
employees.Columns.Add("EmployeeID", typeof(int));
employees.Columns.Add("Name", typeof(string));
employees.Columns.Add("Department", typeof(string));
employees.Rows.Add(1, "John Smith", "Engineering");
employees.Rows.Add(2, "Sarah Johnson", "Marketing");
bool success = ExportToExcel(employees, @"C:\Reports\Export.xlsx");
Console.WriteLine(success ? "Export completed." : "Export failed.");Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
' --- ExcelExporter helper ---
Function ExportToExcel(dt As DataTable, filePath As String) As Boolean
If dt Is Nothing OrElse dt.Rows.Count = 0 Then
Return False
End If
Try
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet(If(dt.TableName, "Sheet1"))
' Bold headers in the first row
For i As Integer = 0 To dt.Columns.Count - 1
Dim cell = sheet.GetCellAt(0, i)
cell.Value = dt.Columns(i).ColumnName
cell.Style.Font.Bold = True
Next
' Data rows
For i As Integer = 0 To dt.Rows.Count - 1
For j As Integer = 0 To dt.Columns.Count - 1
Dim value = dt.Rows(i)(j)
sheet.SetCellValue(i + 1, j, If(value Is DBNull.Value OrElse value Is Nothing, "", value))
Next
Next
Dim fileInfo As New FileInfo(filePath)
If Not fileInfo.Directory.Exists Then
fileInfo.Directory.Create()
End If
workbook.SaveAs(filePath)
Return True
Catch ex As Exception
Console.WriteLine("Export failed: " & ex.Message)
Return False
End Try
End Function
' --- Usage ---
Dim employees As New DataTable("Employees")
employees.Columns.Add("EmployeeID", GetType(Integer))
employees.Columns.Add("Name", GetType(String))
employees.Columns.Add("Department", GetType(String))
employees.Rows.Add(1, "John Smith", "Engineering")
employees.Rows.Add(2, "Sarah Johnson", "Marketing")
Dim success As Boolean = ExportToExcel(employees, "C:\Reports\Export.xlsx")
Console.WriteLine(If(success, "Export completed.", "Export failed."))El ayudante ExportToExcel acepta cualquier DataTable y una cadena de ruta de archivo, devolviendo false si la exportación falla o la tabla está vacía. Maneja los valores que faltan con elegancia mediante la comprobación de DBNull.Value antes de escribir las celdas. El paso de creación de directorios evita que DirectoryNotFoundException interrumpa las exportaciones programadas, un problema de producción común cuando se despliega en nuevos entornos.
En el contexto de la LOPDGDD, este patrón también permite filtrar columnas con datos personales innecesarios antes de generar el XLSX destinado a la AEAT, reduciendo la superficie de datos exportados y cumpliendo con el principio de minimización de datos.
Los encabezados en negrita se aplican utilizando cell.Style.Font.Bold = true, lo que produce un resultado de aspecto profesional sin configuración adicional. El patrón es fácil de ampliar: añada colores de fondo, bordes o ajuste automático del ancho de columna para que se adapte a los estándares de presentación de informes de su organización.
Para trabajar con grandes conjuntos de datos, la guía de rendimiento de IronXL describe estrategias de escritura masiva que minimizan la asignación de memoria. La biblioteca también permite exportar un DataSet (una colección de objetos DataTable relacionados) a varias hojas de cálculo de un mismo libro, lo que resulta útil para informes de varias hojas como los que combinan datos del SII con resúmenes de los modelos 303 y 390.
Las exportaciones profesionales para compliance AEAT a menudo requieren formato: encabezados en negrita, celdas coloreadas, bordes y formatos numéricos para importes en euros. Ambas bibliotecas admiten el uso de estilos, pero su implementación difiere significativamente en cuanto a detalle y fiabilidad.
using IronXL;
using IronXL.Styles;
using System.Data;
// Datos de ejemplo para el libro registro de facturas emitidas (SII)
DataTable dt = new DataTable("FacturasEmitidas_SII");
dt.Columns.Add("NumFactura", typeof(string));
dt.Columns.Add("ImporteBase", typeof(decimal));
dt.Rows.Add("F2025-0001", 15000.50m);
dt.Rows.Add("F2025-0002", 22500.75m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Facturas_SII");
// Write headers with light blue background and bold font
for (int i = 0; i < dt.Columns.Count; i++)
{
var cell = sheet.GetCellAt(0, i);
cell.Value = dt.Columns[i].ColumnName;
cell.Style.Font.Bold = true;
cell.Style.SetBackgroundColor("#ADD8E6");
cell.Style.BottomBorder.SetColor("#000000");
cell.Style.BottomBorder.Type = BorderType.Thin;
}
// Write data rows
for (int i = 0; i < dt.Rows.Count; i++)
{
for (int j = 0; j < dt.Columns.Count; j++)
{
sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
}
}
workbook.SaveAs(@"/var/reports/sii/facturas_emitidas_2025.xlsx");
Console.WriteLine("Fichero SII generado con formato.");Imports IronXL
Imports IronXL.Styles
Imports System.Data
' Datos de ejemplo para el libro registro de facturas emitidas (SII)
Dim dt As New DataTable("FacturasEmitidas_SII")
dt.Columns.Add("NumFactura", GetType(String))
dt.Columns.Add("ImporteBase", GetType(Decimal))
dt.Rows.Add("F2025-0001", 15000.5D)
dt.Rows.Add("F2025-0002", 22500.75D)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Facturas_SII")
' Write headers with light blue background and bold font
For i As Integer = 0 To dt.Columns.Count - 1
Dim cell = sheet.GetCellAt(0, i)
cell.Value = dt.Columns(i).ColumnName
cell.Style.Font.Bold = True
cell.Style.SetBackgroundColor("#ADD8E6")
cell.Style.BottomBorder.SetColor("#000000")
cell.Style.BottomBorder.Type = BorderType.Thin
Next
' Write data rows
For i As Integer = 0 To dt.Rows.Count - 1
For j As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
Next
Next
workbook.SaveAs("/var/reports/sii/facturas_emitidas_2025.xlsx")
Console.WriteLine("Fichero SII generado con formato.")La API de estilo de IronXL utiliza un modelo de objetos limpio. Los valores de color aceptan códigos hexadecimales estándar, como #ADD8E6 (azul claro), lo que facilita la adaptación a la marca corporativa sin necesidad de convertir entre sistemas de color. BorderType.Thin y BorderType.Thick cubren escenarios de borde estándar sin requerir búsquedas de enumeración.
Para todas las opciones de estilo, incluidos los formatos numéricos, el formato condicional y la fusión de celdas, consulte la guía de estilo de celdas de IronXL y la documentación sobre bordes y alineación.
El equivalente Interop accede a objetos Range individuales y establece propiedades como Font.Bold, Interior.Color y Borders.LineStyle. Cada acceso a una propiedad es una llamada COM entre procesos, lo que añade sobrecarga y aumenta la posibilidad de excepciones si Excel deja de responder. Los valores de color requieren una conversión System.Drawing.ColorTranslator.ToOle, y cada bloque de estilo debe ir seguido de la cadena de limpieza COM estándar: tres llamadas Marshal.ReleaseComObject como mínimo.
Esta verbosidad se convierte en un problema al aplicar formato condicional, anchos de columna o formatos numéricos en hojas de cálculo de gran tamaño. IronXL gestiona los mismos escenarios con menos líneas de código y sin el riesgo de dejar procesos de Excel en ejecución tras un fallo del sistema.
Seguir prácticas coherentes en todas las rutinas de exportación para proyectos SII/AEAT reduce los errores, mejora la mantenibilidad y facilita la prueba y la implementación del código.
Utilice una convención de nomenclatura coherente para los archivos exportados: {Modelo}_{Ejercicio}_{Periodo}_{Timestamp}.xlsx (por ejemplo, Modelo303_2025_T4_20251231.xlsx). Los nombres de archivo predecibles facilitan la limpieza y el archivo automatizados. Almacenar el directorio de salida en la configuración de la aplicación evita DirectoryNotFoundException al desplegar a nuevos entornos.
Envuelva toda la lógica de exportación en bloques try-catch y registre las excepciones con suficiente contexto para diagnosticar el fallo. Para las exportaciones programadas de declaraciones AEAT, considere devolver un objeto de resultado en lugar de lanzar excepciones, de modo que el servicio de llamada pueda reintentar la operación o alertar a los operadores sin que se produzca un fallo. El ExportToExcel helper anterior demuestra este patrón con un bool valor de retorno.
Para conjuntos de datos con más de 50 000 filas —habitual en el libro registro de facturas recibidas del SII en empresas con alto volumen de operaciones— transmita los datos por lotes para evitar la sobrecarga de memoria. IronXL admite escrituras progresivas, y el SDK de OpenXML ofrece streaming de bajo nivel para archivos de gran tamaño. Evite por completo el uso de Interop para conjuntos de datos de gran tamaño: su modelo en memoria provoca ralentizaciones significativas a gran escala.
Si la aplicación se ejecuta en Linux o macOS —por ejemplo, en contenedores Docker o Azure Linux App Services, que son el estándar de facto para los servicios de integración con el SII y VeriFactu—, IronXL es la única opción viable. Interop no funciona fuera de Windows porque depende del servidor COM de Excel. Utilice la guía de implementación multiplataforma de .NET para verificar que todas las dependencias estén disponibles en el entorno de ejecución de destino.
Antes de generar cualquier fichero XLSX para remisión a la AEAT o al Banco de España / CNMV, revise qué columnas contienen datos personales. Bajo la LOPDGDD (Ley Orgánica de Protección de Datos y Garantía de Derechos Digitales), el principio de minimización de datos obliga a no exportar más información personal de la estrictamente necesaria para el cumplimiento fiscal. Filtre las columnas antes de llamar a ExportToExcel.
Las pruebas unitarias de la lógica de exportación deben verificar que el archivo de salida existe, contiene el número de filas esperado y utiliza los nombres de columna correctos. El método WorkBook.Load de IronXL facilita la lectura de los archivos exportados en las pruebas sin necesidad de iniciar Excel. Consulte la guía de lectura de IronXL para ver ejemplos.
La elección adecuada depende de los requisitos específicos del proyecto, el entorno de implementación y las consideraciones de mantenimiento a largo plazo.
Elija Microsoft Office Excel Interop cuando:
Elija IronXL cuando:
Explora los tutoriales de IronXL para ver otros escenarios, como la lectura de archivos Excel existentes, el trabajo con fórmulas y la gestión de varias hojas de cálculo.
Exportar un DataTable a un archivo Excel es un requisito fundamental para las aplicaciones .NET que manejan datos empresariales y de compliance fiscal. Tanto si la fuente es una consulta al sistema contable para el SII, un DataSet con múltiples tablas de declaraciones AEAT o una colección en memoria creada dinámicamente para VeriFactu o TicketBAI, la elección de la biblioteca correcta determina la flexibilidad de implementación y la capacidad de mantenimiento a largo plazo.
Microsoft Office Excel Interop ha prestado servicio a los desarrolladores durante años, pero su dependencia de la instalación de Office, la complejidad de COM, los escenarios de servidor no compatibles y los retos de gestión de recursos lo hacen cada vez menos práctico para el desarrollo de aplicaciones modernas —y directamente inviable para los pipelines de compliance fiscal que corren en Linux.
IronXL ofrece una alternativa más limpia que resuelve estas limitaciones. Con una sencilla instalación de NuGet, compatibilidad multiplataforma que abarca Windows, Linux y macOS, y API sencillas que siguen las convenciones de .NET, elimina los quebraderos de cabeza de la implementación y los escollos de la gestión de recursos que afectan a las soluciones de interoperabilidad de Excel. La librería Excel C# SII AEAT de referencia para los desarrolladores que trabajan con la AEAT es, precisamente, IronXL: IronXL genera ficheros SII y todas las demás declaraciones fiscales directamente en XLSX desde servidores Linux sin ninguna dependencia de Office.
Para empezar, instale IronXL desde NuGet, copie uno de los ejemplos de código anteriores y ejecute una exportación rápida desde una prueba DataTable. La guía de inicio rápido de IronXL cubre los escenarios más comunes en pocos minutos. Cuando esté listo para la producción, consulte la página de licencias de IronXL para encontrar la opción que se adapte al tamaño de su equipo y a su modelo de implementación. Para obtener más información, consulta la referencia completa de la API de IronXL y el repositorio de IronXL en GitHub, donde encontrarás ejemplos de la comunidad.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronXL es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
La API de Excel que necesita, sin la molestia de Office Interop.
