SII AEAT: Importar plantillas XLSX y leer modelos en C# sin Office | IronXL

¿Por qué StreamReader no puede leer archivos de Excel?

StreamReader está diseñado para archivos de texto sin formato, leyendo datos de caracteres línea por línea utilizando una codificación especificada. Los archivos Excel, a pesar de su apariencia de hoja de cálculo, son en realidad estructuras XML binarias o comprimidas en ZIP complejas que StreamReader no puede interpretar. Los archivos XLSX modernos siguen el estándar Office Open XML, mientras que los archivos XLS más antiguos utilizan un formato binario propietario.

static void Main(string[] args)
{
 // Este código NO funcionará - demuestra el problema
 using (StreamReader reader = new StreamReader("PlantillaSII_AEAT.xlsx"))
 {
    string content = reader.ReadLine(); // Intenta leer Excel como texto
    Console.WriteLine(content); // Muestra datos binarios ilegibles
 }
}

static void Main(string[] args)
{
 // Este código NO funcionará - demuestra el problema
 using (StreamReader reader = new StreamReader("PlantillaSII_AEAT.xlsx"))
 {
    string content = reader.ReadLine(); // Intenta leer Excel como texto
    Console.WriteLine(content); // Muestra datos binarios ilegibles
 }
}

Option Strict On
Option Infer On

Imports System.IO

Module Program
    Sub Main(args As String())
        ' Este código NO funcionará - demuestra el problema
        Using reader As New StreamReader("PlantillaSII_AEAT.xlsx")
            Dim content As String = reader.ReadLine() ' Intenta leer Excel como texto
            Console.WriteLine(content) ' Muestra datos binarios ilegibles
        End Using
    End Sub
End Module

Al ejecutar este fragmento de código, en lugar de ver los datos de la hoja de cálculo (por ejemplo, una plantilla XLSX del SII enviada por la asesoría), aparecerán datos binarios, como "PK♥♦" o caracteres similares. Esto sucede porque los archivos XLSX son archivos ZIP que contienen múltiples archivos XML, mientras que los archivos XLS utilizan un formato binario propietario. StreamReader espera texto sin formato e intenta interpretar estas estructuras complejas como caracteres, lo que da lugar a un resultado sin sentido. En el caso de las aplicaciones en contenedores (habituales en los sistemas SII de las empresas españolas), intentar utilizar bibliotecas nativas de Excel o COM Interop requeriría instalar Microsoft Office en el contenedor, lo que aumentaría drásticamente el tamaño y la complejidad de la imagen.

¿Cómo importar plantillas XLSX del SII y leer modelos AEAT enviados por asesoría?

IronXL ofrece una solución sencilla para importar y leer plantillas XLSX del SII o modelos AEAT en C#. A diferencia de StreamReader, IronXL comprende la estructura interna de Excel y ofrece métodos intuitivos para acceder a sus datos. La biblioteca es compatible con Windows, Linux, macOS y contenedores Docker, lo que la hace perfecta para aplicaciones modernas y multiplataforma. Para los equipos de DevOps, la arquitectura sin dependencias de IronXL significa que no hay que gestionar bibliotecas nativas ni componentes COM durante la implementación.

Primero, instala IronXL a través del Administrador de Paquetes NuGet:

Install-Package IronXL.Excel

A continuación se explica cómo leer correctamente una plantilla XLSX del SII o cualquier fichero XLSX de la AEAT:

using IronXL;
// Cargar la plantilla XLSX del SII (facturas emitidas) enviada por la asesoría
WorkBook workbook = WorkBook.Load("PlantillaFacturasEmitidas_SII.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Leer los datos de una celda específica (por ejemplo, el NIF del emisor)
string nifEmisor = worksheet["A2"].StringValue;
Console.WriteLine($"NIF Emisor: {nifEmisor}");
// Leer un rango de registros de facturas SII
foreach (var cell in worksheet["A2:F100"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

using IronXL;
// Cargar la plantilla XLSX del SII (facturas emitidas) enviada por la asesoría
WorkBook workbook = WorkBook.Load("PlantillaFacturasEmitidas_SII.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Leer los datos de una celda específica (por ejemplo, el NIF del emisor)
string nifEmisor = worksheet["A2"].StringValue;
Console.WriteLine($"NIF Emisor: {nifEmisor}");
// Leer un rango de registros de facturas SII
foreach (var cell in worksheet["A2:F100"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

Imports IronXL

' Cargar la plantilla XLSX del SII (facturas emitidas) enviada por la asesoría
Dim workbook As WorkBook = WorkBook.Load("PlantillaFacturasEmitidas_SII.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Leer los datos de una celda específica (por ejemplo, el NIF del emisor)
Dim nifEmisor As String = worksheet("A2").StringValue
Console.WriteLine($"NIF Emisor: {nifEmisor}")
' Leer un rango de registros de facturas SII
For Each cell In worksheet("A2:F100")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

Este código carga correctamente la plantilla XLSX del SII y proporciona un acceso limpio a los valores de las celdas. El método WorkBook.Load detecta automáticamente el formato de archivo (XLSX, XLS, XLSM, CSV) y gestiona internamente todo el análisis sintáctico complejo. Se puede acceder a las celdas utilizando la notación habitual de Excel, como "A1", o rangos como "A2:F100", lo que hace que el código resulte intuitivo para cualquiera que esté familiarizado con las plantillas de la AEAT.

Para implementaciones en contenedores (habituales en arquitecturas SII), puede incluir fácilmente puntos finales de comprobación de estado que verifiquen las capacidades de procesamiento de Excel:

// Endpoint de health-check para aplicaciones en contenedores (sistemas SII en Kubernetes)
public async Task<IActionResult> HealthCheck()
{
    try
    {
        // Verificar funcionalidad Excel con fichero XLSX de prueba
        using var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var sheet = workbook.CreateWorkSheet("HealthCheck");
        sheet["A1"].Value = DateTime.UtcNow;

        // Convertir a array de bytes para validación
        var bytes = workbook.ToByteArray();
        return Ok(new { 
            status = "healthy", 
            excelSupport = true,
            timestamp = DateTime.UtcNow 
        });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { 
            status = "unhealthy", 
            error = ex.Message 
        });
    }
}

// Endpoint de health-check para aplicaciones en contenedores (sistemas SII en Kubernetes)
public async Task<IActionResult> HealthCheck()
{
    try
    {
        // Verificar funcionalidad Excel con fichero XLSX de prueba
        using var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        var sheet = workbook.CreateWorkSheet("HealthCheck");
        sheet["A1"].Value = DateTime.UtcNow;

        // Convertir a array de bytes para validación
        var bytes = workbook.ToByteArray();
        return Ok(new { 
            status = "healthy", 
            excelSupport = true,
            timestamp = DateTime.UtcNow 
        });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { 
            status = "unhealthy", 
            error = ex.Message 
        });
    }
}

Imports System
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

' Endpoint de health-check para aplicaciones en contenedores (sistemas SII en Kubernetes)
Public Async Function HealthCheck() As Task(Of IActionResult)
    Try
        ' Verificar funcionalidad Excel con fichero XLSX de prueba
        Using workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            Dim sheet = workbook.CreateWorkSheet("HealthCheck")
            sheet("A1").Value = DateTime.UtcNow

            ' Convertir a array de bytes para validación
            Dim bytes = workbook.ToByteArray()
            Return Ok(New With {
                .status = "healthy",
                .excelSupport = True,
                .timestamp = DateTime.UtcNow
            })
        End Using
    Catch ex As Exception
        Return StatusCode(503, New With {
            .status = "unhealthy",
            .error = ex.Message
        })
    End Try
End Function

¿Cómo leer ficheros XLSX de notificaciones AEAT desde flujos de memoria?

Las aplicaciones del mundo real a menudo necesitan procesar ficheros XLSX de la AEAT (respuestas SII, notificaciones de liquidación) desde flujos en lugar de archivos de disco. Entre los escenarios habituales se incluyen la gestión de cargas web, la recuperación de ficheros de bases de datos o el procesamiento de datos de almacenamiento en la nube, como AWS S3 o Azure Blob Storage. IronXL gestiona estas situaciones a la perfección:

using IronXL;
using System.IO;
// Leer fichero XLSX de respuesta SII (AEAT) desde memoria
byte[] fileBytes = File.ReadAllBytes("RespuestaSII_AEAT.xlsx");
using (MemoryStream stream = new MemoryStream(fileBytes))
{
    WorkBook workbook = WorkBook.FromStream(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    // Procesar los datos del registro de facturas SII
    int rowCount = worksheet.RowCount;
    Console.WriteLine($"Registros SII en el fichero: {rowCount}");
    // Leer todos los datos en un DataTable para su procesamiento
    var dataTable = worksheet.ToDataTable(false);
    Console.WriteLine($"Registros cargados: {dataTable.Rows.Count}");
}

using IronXL;
using System.IO;
// Leer fichero XLSX de respuesta SII (AEAT) desde memoria
byte[] fileBytes = File.ReadAllBytes("RespuestaSII_AEAT.xlsx");
using (MemoryStream stream = new MemoryStream(fileBytes))
{
    WorkBook workbook = WorkBook.FromStream(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;
    // Procesar los datos del registro de facturas SII
    int rowCount = worksheet.RowCount;
    Console.WriteLine($"Registros SII en el fichero: {rowCount}");
    // Leer todos los datos en un DataTable para su procesamiento
    var dataTable = worksheet.ToDataTable(false);
    Console.WriteLine($"Registros cargados: {dataTable.Rows.Count}");
}

Imports IronXL
Imports System.IO

' Leer fichero XLSX de respuesta SII (AEAT) desde memoria
Dim fileBytes As Byte() = File.ReadAllBytes("RespuestaSII_AEAT.xlsx")
Using stream As New MemoryStream(fileBytes)
    Dim workbook As WorkBook = WorkBook.FromStream(stream)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
    ' Procesar los datos del registro de facturas SII
    Dim rowCount As Integer = worksheet.RowCount
    Console.WriteLine($"Registros SII en el fichero: {rowCount}")
    ' Leer todos los datos en un DataTable para su procesamiento
    Dim dataTable = worksheet.ToDataTable(False)
    Console.WriteLine($"Registros cargados: {dataTable.Rows.Count}")
End Using

El método FromStream acepta cualquier tipo de flujo, ya sea un MemoryStream, un FileStream o un flujo de red. Esta flexibilidad le permite procesar ficheros XLSX de la AEAT de diversas fuentes sin necesidad de guardarlos primero en el disco. El ejemplo también muestra cómo convertir datos de hojas de cálculo a una DataTable, que se integra a la perfección con bases de datos y escenarios de enlace de datos. En el caso de las arquitecturas de microservicios de los sistemas SII, este enfoque basado en flujos minimiza la E/S de disco y mejora el rendimiento.

[HttpPost("upload")]
public async Task<IActionResult> ProcesarFicheroAEAT(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No se ha subido ningún fichero");

    using var stream = new MemoryStream();
    await file.CopyToAsync(stream);
    stream.Position = 0;

    var workbook = WorkBook.FromStream(stream);
    var worksheet = workbook.DefaultWorkSheet;

    // Procesar el fichero XLSX de la AEAT y devolver resultados
    var data = worksheet.ToDataSet();
    return Ok(new { 
        hojas = workbook.WorkSheets.Count,
        registros = worksheet.RowCount,
        procesado = DateTime.UtcNow
    });
}

[HttpPost("upload")]
public async Task<IActionResult> ProcesarFicheroAEAT(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No se ha subido ningún fichero");

    using var stream = new MemoryStream();
    await file.CopyToAsync(stream);
    stream.Position = 0;

    var workbook = WorkBook.FromStream(stream);
    var worksheet = workbook.DefaultWorkSheet;

    // Procesar el fichero XLSX de la AEAT y devolver resultados
    var data = worksheet.ToDataSet();
    return Ok(new { 
        hojas = workbook.WorkSheets.Count,
        registros = worksheet.RowCount,
        procesado = DateTime.UtcNow
    });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Threading.Tasks

<HttpPost("upload")>
Public Async Function ProcesarFicheroAEAT(file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No se ha subido ningún fichero")
    End If

    Using stream As New MemoryStream()
        Await file.CopyToAsync(stream)
        stream.Position = 0

        Dim workbook = WorkBook.FromStream(stream)
        Dim worksheet = workbook.DefaultWorkSheet

        ' Procesar el fichero XLSX de la AEAT y devolver resultados
        Dim data = worksheet.ToDataSet()
        Return Ok(New With {
            .hojas = workbook.WorkSheets.Count,
            .registros = worksheet.RowCount,
            .procesado = DateTime.UtcNow
        })
    End Using
End Function

¿Cómo convertir entre Excel y CSV en flujos de trabajo de declaraciones AEAT?

Aunque StreamReader puede gestionar archivos CSV, a menudo es necesario convertir entre los formatos Excel y CSV. En el contexto de la AEAT, es habitual recibir datos en CSV y necesitar convertirlos a XLSX para su procesamiento, o a la inversa. IronXL simplifica esta conversión, lo que resulta especialmente útil para los flujos de trabajo de ETL en sistemas de declaraciones fiscales:

using IronXL;
// Cargar fichero XLSX del SII y guardar como CSV
WorkBook workbook = WorkBook.Load("RegistrosSII.xlsx");
workbook.SaveAsCsv("RegistrosSII_export.csv");
// Cargar datos CSV de operaciones y guardar como XLSX para auditoría
WorkBook csvWorkbook = WorkBook.LoadCSV("operaciones_aeat.csv");
csvWorkbook.SaveAs("operaciones_aeat.xlsx");
// Exportar hoja específica a CSV para integración con otros sistemas
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("FacturasEmitidas.csv");

using IronXL;
// Cargar fichero XLSX del SII y guardar como CSV
WorkBook workbook = WorkBook.Load("RegistrosSII.xlsx");
workbook.SaveAsCsv("RegistrosSII_export.csv");
// Cargar datos CSV de operaciones y guardar como XLSX para auditoría
WorkBook csvWorkbook = WorkBook.LoadCSV("operaciones_aeat.csv");
csvWorkbook.SaveAs("operaciones_aeat.xlsx");
// Exportar hoja específica a CSV para integración con otros sistemas
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("FacturasEmitidas.csv");

Imports IronXL

' Cargar fichero XLSX del SII y guardar como CSV
Dim workbook As WorkBook = WorkBook.Load("RegistrosSII.xlsx")
workbook.SaveAsCsv("RegistrosSII_export.csv")

' Cargar datos CSV de operaciones y guardar como XLSX para auditoría
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("operaciones_aeat.csv")
csvWorkbook.SaveAs("operaciones_aeat.xlsx")

' Exportar hoja específica a CSV para integración con otros sistemas
Dim worksheet As WorkSheet = workbook.WorkSheets(0)
worksheet.SaveAsCsv("FacturasEmitidas.csv")

Estas conversiones preservan tus datos mientras cambian el formato de archivo. Al convertir Excel a CSV, IronXL aplana la primera hoja de cálculo de forma predeterminada. La conversión de CSV a Excel crea una hoja de cálculo con el formato adecuado que conserva los tipos de datos.

Para los flujos de datos automatizados, también puede exportar a formatos JSON o XML:

// Exportar datos de declaraciones AEAT a múltiples formatos
var workbook = WorkBook.Load("Modelo303_Q1_2024.xlsx");

// Exportar a JSON para respuestas de API internas
string jsonData = workbook.ToJson();

// Exportar a HTML para visualización en portal web
workbook.SaveAsHtml("Modelo303_Q1_2024.html");

// Exportar a XML para integración con sistemas de la AEAT
workbook.SaveAsXml("Modelo303_Q1_2024.xml");

// Exportar rango específico a DataTable para inserción en base de datos
var dataTable = workbook.DefaultWorkSheet["A1:D10"].ToDataTable();

// Exportar datos de declaraciones AEAT a múltiples formatos
var workbook = WorkBook.Load("Modelo303_Q1_2024.xlsx");

// Exportar a JSON para respuestas de API internas
string jsonData = workbook.ToJson();

// Exportar a HTML para visualización en portal web
workbook.SaveAsHtml("Modelo303_Q1_2024.html");

// Exportar a XML para integración con sistemas de la AEAT
workbook.SaveAsXml("Modelo303_Q1_2024.xml");

// Exportar rango específico a DataTable para inserción en base de datos
var dataTable = workbook.DefaultWorkSheet["A1:D10"].ToDataTable();

' Exportar datos de declaraciones AEAT a múltiples formatos
Dim workbook = WorkBook.Load("Modelo303_Q1_2024.xlsx")

' Exportar a JSON para respuestas de API internas
Dim jsonData As String = workbook.ToJson()

' Exportar a HTML para visualización en portal web
workbook.SaveAsHtml("Modelo303_Q1_2024.html")

' Exportar a XML para integración con sistemas de la AEAT
workbook.SaveAsXml("Modelo303_Q1_2024.xml")

' Exportar rango específico a DataTable para inserción en base de datos
Dim dataTable = workbook.DefaultWorkSheet("A1:D10").ToDataTable()

Prácticas recomendadas para la implementación en contenedores de sistemas SII

Para los ingenieros que implementan aplicaciones de procesamiento de ficheros XLSX de la AEAT (SII, modelos 303/347/390), IronXL ofrece varias ventajas. A continuación se muestra un archivo Dockerfile listo para producción y optimizado para el procesamiento de ficheros Excel en entornos de declaraciones fiscales:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

# Instalar fuentes de sistema necesarias para el procesamiento de Excel
RUN apt-get update && apt-get install -y \
    fontconfig \
    libfreetype6 \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["SistemasSII.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build

FROM build AS publish
RUN dotnet publish -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .

# Variables de entorno para IronXL (sin Office instalado)
ENV IRONXL_LICENSE_KEY=${IRONXL_LICENSE_KEY}
ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=false

ENTRYPOINT ["dotnet", "SistemasSII.dll"]

Este Dockerfile garantiza que tu aplicación de procesamiento de ficheros XLSX (para SII, modelo 303, TicketBAI o VeriFactu) se ejecute sin problemas en contenedores con un mínimo de dependencias. La gestión de las licencias se realiza a través de variables de entorno, lo que facilita su administración en diferentes entornos de implementación.

Cumplimiento LOPDGDD al importar plantillas XLSX de la AEAT

Al importar plantillas XLSX del SII o modelos AEAT enviados por la asesoría, la LOPDGDD exige tratar con cuidado los datos personales contenidos en esos ficheros (nombres, NIF, direcciones). IronXL permite leer solo las celdas o columnas necesarias para el procesamiento, sin cargar la hoja completa en memoria ni exponer datos personales innecesarios. El principio de minimización de datos se puede aplicar directamente a nivel de código:

// Leer únicamente las columnas necesarias para el proceso SII (LOPDGDD: minimización de datos)
WorkBook workbook = WorkBook.Load("FacturasEmitidas_SII.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Solo se leen NIF (col A), Base Imponible (col D) y Cuota IVA (col E)
// No se carga la columna B (Nombre) ni la C (Dirección) para cumplir LOPDGDD
var nif = worksheet["A2:A1000"];
var baseImponible = worksheet["D2:D1000"];
var cuotaIVA = worksheet["E2:E1000"];

// Leer únicamente las columnas necesarias para el proceso SII (LOPDGDD: minimización de datos)
WorkBook workbook = WorkBook.Load("FacturasEmitidas_SII.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Solo se leen NIF (col A), Base Imponible (col D) y Cuota IVA (col E)
// No se carga la columna B (Nombre) ni la C (Dirección) para cumplir LOPDGDD
var nif = worksheet["A2:A1000"];
var baseImponible = worksheet["D2:D1000"];
var cuotaIVA = worksheet["E2:E1000"];

Imports IronXL

' Leer únicamente las columnas necesarias para el proceso SII (LOPDGDD: minimización de datos)
Dim workbook As WorkBook = WorkBook.Load("FacturasEmitidas_SII.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Solo se leen NIF (col A), Base Imponible (col D) y Cuota IVA (col E)
' No se carga la columna B (Nombre) ni la C (Dirección) para cumplir LOPDGDD
Dim nif = worksheet("A2:A1000")
Dim baseImponible = worksheet("D2:D1000")
Dim cuotaIVA = worksheet("E2:E1000")

TicketBAI y VeriFactu: importar y procesar ficheros XLSX en C

Las empresas del País Vasco que reciben ficheros XLSX de respuesta de las haciendas forales (TicketBAI) pueden procesarlos directamente con IronXL, leyendo los registros de facturas y validando los datos sin dependencias de Office. Del mismo modo, las empresas sujetas a VeriFactu (Real Decreto-Ley 15/2025) pueden importar los ficheros XLSX de registros de facturas verificables para su posterior procesamiento, almacenamiento y verificación en sus sistemas de gestión.

Estos flujos de trabajo son especialmente importantes porque tanto TicketBAI como VeriFactu requieren que los sistemas informáticos de facturación mantengan registros XLSX auditables, y IronXL proporciona la herramienta C# adecuada para gestionarlos en entornos Linux/Docker de producción.

¿Cuáles son los próximos pasos para el procesamiento de ficheros XLSX de la AEAT en C#?

La incapacidad de StreamReader para procesar archivos de Excel se debe a la diferencia fundamental entre el texto sin formato y la compleja estructura de archivos de Excel. Aunque StreamReader funciona perfectamente con CSV y otros formatos de texto, los archivos Excel auténticos requieren una biblioteca especializada como IronXL que comprenda las estructuras binarias y XML que contienen.

IronXL ofrece una solución con su API intuitiva, su amplia compatibilidad con formatos y sus capacidades de procesamiento de flujos. Tanto si estás creando un sistema de importación de plantillas SII, procesando modelos 303/347 enviados por tu asesoría, generando informes prudenciales para el Banco de España o la CNMV, o gestionando ficheros TicketBAI y VeriFactu, IronXL gestiona archivos de Excel de forma fiable en todas las plataformas. La compatibilidad de la biblioteca con el formato condicional, los gráficos, las fórmulas y las funciones avanzadas de Excel la convierte en una solución para aplicaciones Enterprise de cumplimiento fiscal en España.

Para los equipos de DevOps, la arquitectura compatible con contenedores de IronXL, sus mínimas dependencias del sistema y sus sólidas características de rendimiento lo convierten en la opción ideal para las aplicaciones modernas nativas de la nube, incluidos los sistemas SII que procesan millones de registros de facturas. La biblioteca admite el escalado horizontal, funciona a la perfección en pods de Kubernetes y se integra bien con los procesos de CI/CD.

¿Listo para empezar a importar correctamente los ficheros XLSX del SII y de la AEAT en tus aplicaciones C#? Descarga la versión de prueba gratuita de IronXL que mejor se adapte a las necesidades de tu proyecto. La biblioteca ofrece opciones de licencia flexibles que incluyen implementaciones de desarrollo, staging y producción, con opciones para entornos en contenedores y aplicaciones nativas de la nube.