Leer XLSX del SII y AEAT con streaming en C# — IronXL vs StreamReader

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

StreamReader es un lector basado en texto. Lee los datos de caracteres línea por línea utilizando una codificación especificada (UTF-8, ASCII, etc.) y no tiene conocimiento de estructuras binarias ni de archivos comprimidos. La documentación oficial de .NET StreamReader confirma que esta clase está diseñada exclusivamente para texto codificado por caracteres. Los archivos Excel, a pesar de parecer simples hojas de cálculo, son en realidad complejas estructuras binarias o XML comprimidas en ZIP que StreamReader no puede interpretar.

Cuando se abre un archivo XLSX con StreamReader, básicamente se está intentando leer un archivo ZIP como texto sin formato. El resultado es un flujo de ruido binario en lugar de los datos de tu hoja de cálculo.

// This code will NOT work -- demonstrates the problem
using StreamReader reader = new StreamReader("ProductData.xlsx");
string content = reader.ReadLine();
Console.WriteLine(content); // Outputs garbled binary data like "PK♥♦"

// This code will NOT work -- demonstrates the problem
using StreamReader reader = new StreamReader("ProductData.xlsx");
string content = reader.ReadLine();
Console.WriteLine(content); // Outputs garbled binary data like "PK♥♦"

Imports System.IO

' This code will NOT work -- demonstrates the problem
Using reader As New StreamReader("ProductData.xlsx")
    Dim content As String = reader.ReadLine()
    Console.WriteLine(content) ' Outputs garbled binary data like "PK♥♦"
End Using

Cuando ejecutas este fragmento, en lugar de ver las filas de tu hoja de cálculo, te encuentras con caracteres binarios como PK♥♦ o ruidos similares. Esto ocurre porque:

• Los archivos XLSX son archivos ZIP que contienen múltiples archivos XML: hojas de cálculo, estilos, cadenas compartidas y relaciones. La documentación del SDK de Open XML ofrece un desglose detallado de esta estructura.
• Los archivos XLS utilizan un formato binario propietario (BIFF, Binary Interchange Formato de archivo).
• StreamReader aplica una codificación de caracteres a los bytes que lee, produciendo una salida sin sentido para ambos formatos

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

IronXL es una biblioteca .NET que lee, escribe y crea archivos de Excel sin necesidad de tener instalado Microsoft Excel. Es compatible con los formatos XLSX, XLS, XLSM, CSV y TSV, y funciona en Windows, Linux, macOS y contenedores Docker.

Para instalar IronXL, utilice la consola del gestor de paquetes NuGet o la CLI de .NET. El paquete está publicado en NuGet.org como IronXL:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Tras la instalación, añada la directiva using IronXL; a su archivo y estará listo para trabajar con documentos Excel.

Alternativa para leer archivos de Excel utilizando StreamReader en C# - IronXL: Imagen 5 - Instalación

Para obtener información detallada sobre los pasos de instalación y las opciones de configuración de NuGet, consulte la guía de instalación de IronXL NuGet. Hay disponible una licencia de prueba gratuita para que puedas evaluar IronXL en tu proyecto antes de comprarlo.

Alternativa para leer archivos de Excel usando StreamReader en C# - IronXL: Imagen 4 - Plataforma cruzada

¿Cómo se leen archivos de Excel con IronXL?

IronXL proporciona una API intuitiva para leer archivos de Excel en C#. A diferencia de StreamReader, IronXL entiende la estructura interna de Excel y le da un acceso limpio a las filas, columnas y valores de celda. La documentación de IronXL proporciona referencias completas de la API para todas las operaciones compatibles.

A continuación se muestra cómo leer un archivo de Excel utilizando IronXL con sentencias de nivel superior:

using IronXL;

// Load the Excel file from disk
WorkBook workbook = WorkBook.Load("ProductData.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Read a specific cell by address
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Iterate over a range of cells
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Read a numeric value
decimal price = worksheet["B2"].DecimalValue;
Console.WriteLine($"Price: {price:C}");

using IronXL;

// Load the Excel file from disk
WorkBook workbook = WorkBook.Load("ProductData.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Read a specific cell by address
string cellValue = worksheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");

// Iterate over a range of cells
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Read a numeric value
decimal price = worksheet["B2"].DecimalValue;
Console.WriteLine($"Price: {price:C}");

Imports IronXL

' Load the Excel file from disk
Dim workbook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell by address
Dim cellValue As String = worksheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")

' Iterate over a range of cells
For Each cell In worksheet("A1:C10")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

' Read a numeric value
Dim price As Decimal = worksheet("B2").DecimalValue
Console.WriteLine($"Price: {price:C}")

El método WorkBook.Load detecta automáticamente el formato del archivo (XLSX, XLS, XLSM, CSV) y se encarga de todo el análisis sintáctico complejo. Se accede a las celdas utilizando la notación estándar de Excel como "A1" o rangos como "A1:C10", lo que hace que el código sea inmediatamente legible para cualquier persona familiarizada con las hojas de cálculo.

using IronXL;

WorkBook workbook = WorkBook.Load("MultiSheet.xlsx");

// List all worksheets
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}");
}

// Access a sheet by name
WorkSheet summary = workbook.GetWorkSheet("Summary");
string totalRevenue = summary["B20"].StringValue;
Console.WriteLine($"Total Revenue: {totalRevenue}");

// Access a sheet by index
WorkSheet firstSheet = workbook.WorkSheets[0];
int lastRow = firstSheet.RowCount;
Console.WriteLine($"Last row in first sheet: {lastRow}");

using IronXL;

WorkBook workbook = WorkBook.Load("MultiSheet.xlsx");

// List all worksheets
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}");
}

// Access a sheet by name
WorkSheet summary = workbook.GetWorkSheet("Summary");
string totalRevenue = summary["B20"].StringValue;
Console.WriteLine($"Total Revenue: {totalRevenue}");

// Access a sheet by index
WorkSheet firstSheet = workbook.WorkSheets[0];
int lastRow = firstSheet.RowCount;
Console.WriteLine($"Last row in first sheet: {lastRow}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("MultiSheet.xlsx")

' List all worksheets
For Each sheet As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {sheet.Name}, Rows: {sheet.RowCount}")
Next

' Access a sheet by name
Dim summary As WorkSheet = workbook.GetWorkSheet("Summary")
Dim totalRevenue As String = summary("B20").StringValue
Console.WriteLine($"Total Revenue: {totalRevenue}")

' Access a sheet by index
Dim firstSheet As WorkSheet = workbook.WorkSheets(0)
Dim lastRow As Integer = firstSheet.RowCount
Console.WriteLine($"Last row in first sheet: {lastRow}")

¿Cómo se leen los datos de Excel desde un flujo de memoria?

Las aplicaciones del mundo real a menudo necesitan procesar archivos de Excel desde flujos en lugar de archivos de disco. Entre los escenarios habituales se incluyen la gestión de cargas de archivos desde formularios web, la recuperación de libros de trabajo de una columna BLOB de una base de datos o el procesamiento de archivos descargados de un almacenamiento en la nube (Azure Blob Storage, AWS S3). IronXL maneja estos escenarios a través de WorkBook.FromStream:

using IronXL;
using System.IO;

// Simulate reading file bytes (e.g., from a database or web upload)
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");

using MemoryStream stream = new MemoryStream(fileBytes);
WorkBook workbook = WorkBook.FromStream(stream);
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Get row and column counts
Console.WriteLine($"Rows: {worksheet.RowCount}, Columns: {worksheet.ColumnCount}");

// Convert to DataTable for database or grid binding
var dataTable = worksheet.ToDataTable(useHeaderRow: true);
Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");

foreach (System.Data.DataRow row in dataTable.Rows)
{
    string productName = row["ProductName"]?.ToString() ?? string.Empty;
    string sku = row["SKU"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Product: {productName}, SKU: {sku}");
}

using IronXL;
using System.IO;

// Simulate reading file bytes (e.g., from a database or web upload)
byte[] fileBytes = File.ReadAllBytes("ProductData.xlsx");

using MemoryStream stream = new MemoryStream(fileBytes);
WorkBook workbook = WorkBook.FromStream(stream);
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Get row and column counts
Console.WriteLine($"Rows: {worksheet.RowCount}, Columns: {worksheet.ColumnCount}");

// Convert to DataTable for database or grid binding
var dataTable = worksheet.ToDataTable(useHeaderRow: true);
Console.WriteLine($"Loaded {dataTable.Rows.Count} data rows");

foreach (System.Data.DataRow row in dataTable.Rows)
{
    string productName = row["ProductName"]?.ToString() ?? string.Empty;
    string sku = row["SKU"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Product: {productName}, SKU: {sku}");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

WorkBook.FromStream acepta cualquier Stream -- MemoryStream, FileStream, o un flujo de red. Esta flexibilidad significa que nunca tendrás que escribir archivos temporales en el disco solo para leer datos de Excel. La conversión a DataTable también se integra directamente con SqlBulkCopy, controles de enlace de datos y marcos de generación de informes.

using IronXL;
using System.IO;

// Leer fichero SII del almacenamiento seguro (sin persistir en disco temporal)
byte[] siiFileBytes = await ObtenerFicheroSiiDesdeAlmacenamientoSeguro("facturas_emitidas_mayo2026.xlsx");

using MemoryStream siiStream = new MemoryStream(siiFileBytes);
WorkBook siiWorkbook = WorkBook.FromStream(siiStream);

// El fichero SII suele tener múltiples hojas: Emitidas, Recibidas, Resumen
foreach (WorkSheet sheet in siiWorkbook.WorkSheets)
{
    Console.WriteLine($"Hoja SII: {sheet.Name}, Registros: {sheet.RowCount - 1}");
    var dt = sheet.ToDataTable(useHeaderRow: true);
    // Procesar y validar datos antes de la remisión a la AEAT
    ValidarRegistrosSII(dt, sheet.Name);
}

using IronXL;
using System.IO;

// Leer fichero SII del almacenamiento seguro (sin persistir en disco temporal)
byte[] siiFileBytes = await ObtenerFicheroSiiDesdeAlmacenamientoSeguro("facturas_emitidas_mayo2026.xlsx");

using MemoryStream siiStream = new MemoryStream(siiFileBytes);
WorkBook siiWorkbook = WorkBook.FromStream(siiStream);

// El fichero SII suele tener múltiples hojas: Emitidas, Recibidas, Resumen
foreach (WorkSheet sheet in siiWorkbook.WorkSheets)
{
    Console.WriteLine($"Hoja SII: {sheet.Name}, Registros: {sheet.RowCount - 1}");
    var dt = sheet.ToDataTable(useHeaderRow: true);
    // Procesar y validar datos antes de la remisión a la AEAT
    ValidarRegistrosSII(dt, sheet.Name);
}

Imports IronXL
Imports System.IO

' Leer fichero SII del almacenamiento seguro (sin persistir en disco temporal)
Dim siiFileBytes As Byte() = Await ObtenerFicheroSiiDesdeAlmacenamientoSeguro("facturas_emitidas_mayo2026.xlsx")

Using siiStream As New MemoryStream(siiFileBytes)
    Dim siiWorkbook As WorkBook = WorkBook.FromStream(siiStream)

    ' El fichero SII suele tener múltiples hojas: Emitidas, Recibidas, Resumen
    For Each sheet As WorkSheet In siiWorkbook.WorkSheets
        Console.WriteLine($"Hoja SII: {sheet.Name}, Registros: {sheet.RowCount - 1}")
        Dim dt = sheet.ToDataTable(useHeaderRow:=True)
        ' Procesar y validar datos antes de la remisión a la AEAT
        ValidarRegistrosSII(dt, sheet.Name)
    Next
End Using

¿Cómo se convierte entre los formatos Excel y CSV?

Aunque StreamReader puede manejar archivos CSV, las aplicaciones de producción a menudo necesitan mover datos entre Excel y CSV. IronXL facilita la conversión de formatos. Puedes exportar datos de Excel a CSV o importar datos CSV a un libro de Excel con solo unas pocas líneas:

using IronXL;

// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
workbook.SaveAsCsv("output.csv");

// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("legacy-report.csv");
csvWorkbook.SaveAs("converted.xlsx");

// Export a specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("sheet1-export.csv");

using IronXL;

// Load an Excel file and save as CSV
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
workbook.SaveAsCsv("output.csv");

// Load a CSV file and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("legacy-report.csv");
csvWorkbook.SaveAs("converted.xlsx");

// Export a specific worksheet to CSV
WorkSheet worksheet = workbook.WorkSheets[0];
worksheet.SaveAsCsv("sheet1-export.csv");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Estas conversiones conservan tus datos al cambiar el formato del contenedor. Al convertir Excel a CSV, IronXL exporta la primera hoja de cálculo de forma predeterminada; puedes especificar cualquier hoja que elijas. Al convertir un archivo CSV a Excel, se crea un libro de trabajo correctamente estructurado al que luego se le puede aplicar formato, añadir fórmulas e introducir datos adicionales.

¿Cómo se crean y se formatean archivos de Excel con IronXL?

La lectura de datos de Excel es solo una parte del flujo de trabajo. Muchas aplicaciones también necesitan crear nuevos archivos de Excel y aplicarles formato. IronXL admite el formato de celdas, incluyendo fuentes, colores, bordes, formatos numéricos y fusión de celdas:

using IronXL;

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");

// Write headers with formatting
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Apply bold formatting to header row
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.SetBackgroundColor("#4472C4");
sheet["A1:C1"].Style.Font.Color = "#FFFFFF";

// Write data rows
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] units = { 120, 85, 210 };
decimal[] revenues = { 2400.00m, 1700.00m, 4200.00m };

for (int i = 0; i < products.Length; i++)
{
    sheet[$"A{i + 2}"].Value = products[i];
    sheet[$"B{i + 2}"].Value = units[i];
    sheet[$"C{i + 2}"].Value = revenues[i];
    sheet[$"C{i + 2}"].FormatString = "$#,##0.00";
}

// Save the workbook
workbook.SaveAs("FormattedReport.xlsx");
Console.WriteLine("Report created successfully.");

using IronXL;

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");

// Write headers with formatting
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";

// Apply bold formatting to header row
sheet["A1:C1"].Style.Font.Bold = true;
sheet["A1:C1"].Style.SetBackgroundColor("#4472C4");
sheet["A1:C1"].Style.Font.Color = "#FFFFFF";

// Write data rows
string[] products = { "Widget A", "Widget B", "Widget C" };
int[] units = { 120, 85, 210 };
decimal[] revenues = { 2400.00m, 1700.00m, 4200.00m };

for (int i = 0; i < products.Length; i++)
{
    sheet[$"A{i + 2}"].Value = products[i];
    sheet[$"B{i + 2}"].Value = units[i];
    sheet[$"C{i + 2}"].Value = revenues[i];
    sheet[$"C{i + 2}"].FormatString = "$#,##0.00";
}

// Save the workbook
workbook.SaveAs("FormattedReport.xlsx");
Console.WriteLine("Report created successfully.");

Imports IronXL

' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")

' Write headers with formatting
sheet("A1").Value = "Product"
sheet("B1").Value = "Units Sold"
sheet("C1").Value = "Revenue"

' Apply bold formatting to header row
sheet("A1:C1").Style.Font.Bold = True
sheet("A1:C1").Style.SetBackgroundColor("#4472C4")
sheet("A1:C1").Style.Font.Color = "#FFFFFF"

' Write data rows
Dim products As String() = {"Widget A", "Widget B", "Widget C"}
Dim units As Integer() = {120, 85, 210}
Dim revenues As Decimal() = {2400.0D, 1700.0D, 4200.0D}

For i As Integer = 0 To products.Length - 1
    sheet($"A{i + 2}").Value = products(i)
    sheet($"B{i + 2}").Value = units(i)
    sheet($"C{i + 2}").Value = revenues(i)
    sheet($"C{i + 2}").FormatString = "$#,##0.00"
Next

' Save the workbook
workbook.SaveAs("FormattedReport.xlsx")
Console.WriteLine("Report created successfully.")

Esta capacidad tanto para leer libros de trabajo existentes como para crear nuevos archivos formateados convierte a IronXL en una solución completa de Excel para aplicaciones .NET. Consulte la página completa de características de IronXL para obtener un desglose detallado de las operaciones compatibles.

¿Cómo se licencia y se implementa IronXL en producción?

IronXL es gratuito para desarrollo y pruebas. Para aplicaciones de producción, se requiere una licencia. Puede explorar las opciones de licencia de IronXL en la página del producto, que incluye los niveles Developer, Team y Organization en función de sus requisitos de implementación.

Tras la compra, aplique su clave de licencia en el código antes de cualquier llamada a IronXL:

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Como alternativa, establezca la variable de entorno IRONXL_LICENSE_KEY en su entorno de implementación y IronXL la recogerá automáticamente. Este es el enfoque preferido para implementaciones en contenedores (Docker, Kubernetes) y entornos en la nube, donde no es aceptable codificar claves de forma estática.

A efectos de evaluación, una licencia de prueba gratuita ofrece todas las funcionalidades para que puedas comprobar IronXL con tus cargas de trabajo específicas antes de comprometerte a la compra. La versión de prueba está disponible sin necesidad de tarjeta de crédito y se activa de inmediato.

En comparación con alternativas como Microsoft.Office.Interop.Excel, IronXL presenta varias ventajas de implementación:

• No es necesario tener instalado Microsoft Excel en el servidor
• Compatible con Linux y Docker: fundamental para aplicaciones nativas de la nube
• Sin problemas de gestión del ciclo de vida de objetos COM ni de subprocesos de apartamentos
• Arranque más rápido y menor consumo de memoria en entornos de servidor
• Comportamiento coherente en todas las plataformas compatibles

Estas cualidades hacen de IronXL una opción práctica para cualquier aplicación .NET que necesite procesar archivos de Excel en producción, ya sea en las instalaciones o en la nube. Para los proyectos de cumplimiento normativo en España — desde el streaming de ficheros XLSX del SII y la AEAT hasta la ingesta de datos regulatorios del Banco de España y la CNMV — IronXL ofrece la combinación de fiabilidad, compatibilidad LOPDGDD y rendimiento en streaming que exigen los entornos de producción modernos.