IronXL para SII AEAT: La mejor manera de leer Excel en C# sin Office | Guía IronXL

¿Cuál es la mejor manera de leer archivos de Excel en C#?

El mejor enfoque es utilizar una biblioteca dedicada e independiente de Office, como IronXL. Los métodos tradicionales como Microsoft.Office.Interop.Excel funcionan en máquinas donde está instalado Excel, pero son frágiles en entornos de servidores o contenedores porque activan un proceso COM detrás de escena. OpenXML SDK es gratuito y seguro para servidores, pero expone un modelo XML de bajo nivel que requiere un código repetitivo significativo para las tareas cotidianas.

IronXL se sitúa entre estos extremos. La API refleja cómo los desarrolladores ya piensan sobre las hojas de cálculo: los libros de trabajo contienen hojas de cálculo, las hojas de cálculo contienen celdas y las celdas contienen valores escritos. La biblioteca maneja la detección de formato, la evaluación de fórmulas y la codificación internamente, por lo que usted dedica tiempo a la lógica empresarial en lugar de analizar los detalles. Para la librería Excel C# SII AEAT, IronXL es la opción natural al ejecutarse en Linux/Docker sin Office, ideal para flujos de preparación de declaraciones AEAT en infraestructuras cloud.

La documentación de lectura de IronXL Excel cubre toda la superficie de la API. Por ahora, las secciones a continuación muestran los patrones principales que utilizarás en cada proyecto.

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

La instalación tarda menos de un minuto utilizando el Administrador de paquetes NuGet . Abra una terminal en el directorio de su proyecto y ejecute:

dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

Alternativamente, utilice la consola del Administrador de paquetes de Visual Studio:

Install-Package IronXL.Excel

Install-Package IronXL.Excel

Después de la instalación, agregue la directiva using IronXL; a cualquier archivo que necesite acceso a la hoja de cálculo. La biblioteca es compatible con .NET 10, .NET 8, .NET 6, .NET Framework 4.6.2 y .NET Standard 2.0, por lo que se integra en proyectos existentes sin necesidad de actualizar el entorno de ejecución. Consulte la guía de instalación de IronXL para obtener información específica de cada plataforma y detalles sobre los paquetes NuGet .

No se requieren componentes de ejecución adicionales, entradas de registro ni licencias de Office. El paquete NuGet incluye todo lo que necesita la biblioteca.

¿Cómo cargar y leer un libro de Excel?

Para cargar un libro de trabajo se requiere una única llamada al método. WorkBook.Load acepta una ruta de archivo y devuelve un objeto WorkBook que representa el archivo completo en la memoria.

using IronXL;

// Load any supported format -- XLSX, XLS, or CSV
WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access the first worksheet by position
WorkSheet worksheet = workbook.WorkSheets[0];

// Or retrieve a named worksheet
WorkSheet expenses = workbook.GetWorkSheet("Expenses");

Console.WriteLine($"Sheets loaded: {workbook.WorkSheets.Count}");
Console.WriteLine($"Default sheet rows: {worksheet.RowCount}");

using IronXL;

// Load any supported format -- XLSX, XLS, or CSV
WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access the first worksheet by position
WorkSheet worksheet = workbook.WorkSheets[0];

// Or retrieve a named worksheet
WorkSheet expenses = workbook.GetWorkSheet("Expenses");

Console.WriteLine($"Sheets loaded: {workbook.WorkSheets.Count}");
Console.WriteLine($"Default sheet rows: {worksheet.RowCount}");

Imports IronXL

' Load any supported format -- XLSX, XLS, or CSV
Dim workbook As WorkBook = WorkBook.Load("financial_report.xlsx")

' Access the first worksheet by position
Dim worksheet As WorkSheet = workbook.WorkSheets(0)

' Or retrieve a named worksheet
Dim expenses As WorkSheet = workbook.GetWorkSheet("Expenses")

Console.WriteLine($"Sheets loaded: {workbook.WorkSheets.Count}")
Console.WriteLine($"Default sheet rows: {worksheet.RowCount}")

El objeto WorkBook mantiene accesibles todos los datos de la hoja de cálculo. Cada instancia de WorkSheet se asigna a una pestaña del archivo. El acceso por índice (WorkSheets[0]) es fiable para archivos de una sola hoja. Acceder por nombre es más seguro cuando el archivo contiene varias pestañas con nombres conocidos.

IronXL evalúa las fórmulas automáticamente cuando lees una celda. Si la celda B10 contiene =SUM(B2:B9), la lectura de sheet["B10"].DecimalValue devuelve el total calculado, no la cadena de fórmula. Para obtener más detalles sobre las opciones de carga de libros de trabajo, consulte la guía práctica de carga de hojas de cálculo .

¿Cómo leer los valores de celda de una hoja de cálculo?

IronXL proporciona propiedades fuertemente tipadas en cada celda para que pueda leer valores directamente en el tipo .NET correcto sin análisis manual.

using IronXL;

WorkBook workbook = WorkBook.Load("Products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Address-based access with typed properties
string productName = sheet["A2"].StringValue;
int quantity       = sheet["B2"].IntValue;
decimal price      = sheet["C2"].DecimalValue;
bool inStock       = sheet["D2"].BoolValue;

// Check for empty cells before processing
var statusCell = sheet["E2"];
if (statusCell.Value != null && statusCell.StringValue.Length > 0)
{
    Console.WriteLine($"Status: {statusCell.StringValue}");
}

// Row/column index access (zero-based)
var firstDataCell = sheet.Rows[1].Columns[0];
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");

using IronXL;

WorkBook workbook = WorkBook.Load("Products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Address-based access with typed properties
string productName = sheet["A2"].StringValue;
int quantity       = sheet["B2"].IntValue;
decimal price      = sheet["C2"].DecimalValue;
bool inStock       = sheet["D2"].BoolValue;

// Check for empty cells before processing
var statusCell = sheet["E2"];
if (statusCell.Value != null && statusCell.StringValue.Length > 0)
{
    Console.WriteLine($"Status: {statusCell.StringValue}");
}

// Row/column index access (zero-based)
var firstDataCell = sheet.Rows[1].Columns[0];
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("Products.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Address-based access with typed properties
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim price As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue

' Check for empty cells before processing
Dim statusCell = sheet("E2")
If statusCell.Value IsNot Nothing AndAlso statusCell.StringValue.Length > 0 Then
    Console.WriteLine($"Status: {statusCell.StringValue}")
End If

' Row/column index access (zero-based)
Dim firstDataCell = sheet.Rows(1).Columns(0)
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}")

La sintaxis sheet["A2"] utiliza la notación estándar de Excel. Las letras de las columnas no distinguen entre mayúsculas y minúsculas, y los números de fila comienzan en 1, lo que coincide con la forma en que Excel etiqueta las celdas. La documentación de lectura de valores de celda muestra accesores tipificados adicionales, incluido DateTimeValue para celdas formateadas como fechas.

Cuando una celda contiene un número almacenado como texto (un problema común de calidad de datos en hojas de cálculo exportadas), StringValue devuelve el texto tal como está, mientras que DecimalValue intenta un análisis y devuelve 0 en caso de error. Siempre valide los datos inesperados antes de tratarlos como un valor escrito en el código de producción.

¿Cómo iterar a través de filas y celdas?

Para iterar a través de un conjunto de datos se requiere un rango o una colección de filas. IronXL admite ambos enfoques y puedes combinarlos para que coincidan con la forma de los datos.

using IronXL;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");
WorkSheet sheet = workbook.WorkSheets[0];

// Iterate a cell range -- skips header row
foreach (var cell in sheet["A2:D100"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Row-by-row with column access
for (int rowIndex = 1; rowIndex < sheet.RowCount; rowIndex++)
{
    var row = sheet.Rows[rowIndex];
    var values = new System.Text.StringBuilder();

    foreach (var cell in row)
    {
        if (cell.Value != null)
            values.Append($"{cell.StringValue}\t");
    }

    Console.WriteLine(values.ToString().TrimEnd());
}

using IronXL;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");
WorkSheet sheet = workbook.WorkSheets[0];

// Iterate a cell range -- skips header row
foreach (var cell in sheet["A2:D100"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Row-by-row with column access
for (int rowIndex = 1; rowIndex < sheet.RowCount; rowIndex++)
{
    var row = sheet.Rows[rowIndex];
    var values = new System.Text.StringBuilder();

    foreach (var cell in row)
    {
        if (cell.Value != null)
            values.Append($"{cell.StringValue}\t");
    }

    Console.WriteLine(values.ToString().TrimEnd());
}

Imports IronXL
Imports System.Text

Dim workbook As WorkBook = WorkBook.Load("financial_report.xlsx")
Dim sheet As WorkSheet = workbook.WorkSheets(0)

' Iterate a cell range -- skips header row
For Each cell In sheet("A2:D100")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

' Row-by-row with column access
For rowIndex As Integer = 1 To sheet.RowCount - 1
    Dim row = sheet.Rows(rowIndex)
    Dim values As New StringBuilder()

    For Each cell In row
        If cell.Value IsNot Nothing Then
            values.Append($"{cell.StringValue}" & vbTab)
        End If
    Next

    Console.WriteLine(values.ToString().TrimEnd())
Next

La cadena de rango "A2:D100" crea una colección de celdas planas. Las filas dentro del rango se procesan de arriba a abajo y de izquierda a derecha. Este patrón funciona bien para exportar a un List<t>, un DataTable o una base de datos.

La propiedad sheet.RowCount refleja la última fila utilizada en la hoja de cálculo, por lo que el bucle finaliza automáticamente cuando finalizan los datos. La guía de iteración de rangos de Excel cubre patrones de iteración adicionales, incluido el recorrido desde la columna primero.

¿Cómo leer un XLSX del SII para preparar el modelo 303 de la AEAT?

Un caso de uso real en España es la lectura del fichero XLSX de conciliación del SII para calcular los totales del modelo 303 (declaración trimestral de IVA) de la AEAT. El siguiente ejemplo usa la API de LINQ de IronXL para sumar la base imponible y la cuota de IVA de las columnas relevantes del XLSX, respetando la LOPDGDD al procesar sólo las columnas estrictamente necesarias. Este flujo se ejecuta en Linux/Docker sin Office, lo que lo hace apto para pipelines automatizados de empresas reguladas por el Banco de España o la CNMV:

using IronXL;
using System.Linq;

// Cargar el XLSX de conciliación del SII exportado por el ERP
// IronXL genera ficheros SII y los procesa sin Microsoft Office
WorkBook siiWorkbook = WorkBook.Load("conciliacion_sii_t1_2026.xlsx");
WorkSheet hojaSII = siiWorkbook.DefaultWorkSheet;

// LOPDGDD: procesar sólo las columnas requeridas para el modelo 303 AEAT
// Col C: Base Imponible, Col D: Cuota IVA 21%
decimal baseImponibleTotal = hojaSII["C2:C500"].Sum();
decimal cuotaIVATotal      = hojaSII["D2:D500"].Sum();

// Filtrar con LINQ: operaciones tipo F1 (facturas emitidas) para casilla 01 del modelo 303
var operacionesF1 = hojaSII["E2:E500"]
    .Where(c => c.StringValue == "F1")
    .Count();

Console.WriteLine($"Modelo 303 T1 2026:");
Console.WriteLine($"  Casilla 01 (Base IVA 21%): {baseImponibleTotal:C2}");
Console.WriteLine($"  Casilla 11 (Cuota IVA 21%): {cuotaIVATotal:C2}");
Console.WriteLine($"  Facturas tipo F1: {operacionesF1}");

// Generar el XLSX resumen para presentación AEAT
WorkBook resumen303 = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet ws = resumen303.CreateWorkSheet("Modelo303_T1_2026");
ws["A1"].Value = "Casilla";
ws["B1"].Value = "Descripción";
ws["C1"].Value = "Importe (€)";
ws["A2"].Value = "01";
ws["B2"].Value = "Base IVA repercutido 21%";
ws["C2"].Value = baseImponibleTotal;
ws["A3"].Value = "11";
ws["B3"].Value = "Cuota IVA repercutida 21%";
ws["C3"].Value = cuotaIVATotal;
resumen303.SaveAs("AEAT_Modelo303_T1_2026_Resumen.xlsx");

using IronXL;
using System.Linq;

// Cargar el XLSX de conciliación del SII exportado por el ERP
// IronXL genera ficheros SII y los procesa sin Microsoft Office
WorkBook siiWorkbook = WorkBook.Load("conciliacion_sii_t1_2026.xlsx");
WorkSheet hojaSII = siiWorkbook.DefaultWorkSheet;

// LOPDGDD: procesar sólo las columnas requeridas para el modelo 303 AEAT
// Col C: Base Imponible, Col D: Cuota IVA 21%
decimal baseImponibleTotal = hojaSII["C2:C500"].Sum();
decimal cuotaIVATotal      = hojaSII["D2:D500"].Sum();

// Filtrar con LINQ: operaciones tipo F1 (facturas emitidas) para casilla 01 del modelo 303
var operacionesF1 = hojaSII["E2:E500"]
    .Where(c => c.StringValue == "F1")
    .Count();

Console.WriteLine($"Modelo 303 T1 2026:");
Console.WriteLine($"  Casilla 01 (Base IVA 21%): {baseImponibleTotal:C2}");
Console.WriteLine($"  Casilla 11 (Cuota IVA 21%): {cuotaIVATotal:C2}");
Console.WriteLine($"  Facturas tipo F1: {operacionesF1}");

// Generar el XLSX resumen para presentación AEAT
WorkBook resumen303 = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet ws = resumen303.CreateWorkSheet("Modelo303_T1_2026");
ws["A1"].Value = "Casilla";
ws["B1"].Value = "Descripción";
ws["C1"].Value = "Importe (€)";
ws["A2"].Value = "01";
ws["B2"].Value = "Base IVA repercutido 21%";
ws["C2"].Value = baseImponibleTotal;
ws["A3"].Value = "11";
ws["B3"].Value = "Cuota IVA repercutida 21%";
ws["C3"].Value = cuotaIVATotal;
resumen303.SaveAs("AEAT_Modelo303_T1_2026_Resumen.xlsx");

Imports IronXL
Imports System.Linq

' Cargar el XLSX de conciliación del SII exportado por el ERP
' IronXL genera ficheros SII y los procesa sin Microsoft Office
Dim siiWorkbook As WorkBook = WorkBook.Load("conciliacion_sii_t1_2026.xlsx")
Dim hojaSII As WorkSheet = siiWorkbook.DefaultWorkSheet

' LOPDGDD: procesar sólo las columnas requeridas para el modelo 303 AEAT
' Col C: Base Imponible, Col D: Cuota IVA 21%
Dim baseImponibleTotal As Decimal = hojaSII("C2:C500").Sum()
Dim cuotaIVATotal As Decimal = hojaSII("D2:D500").Sum()

' Filtrar con LINQ: operaciones tipo F1 (facturas emitidas) para casilla 01 del modelo 303
Dim operacionesF1 = hojaSII("E2:E500") _
    .Where(Function(c) c.StringValue = "F1") _
    .Count()

Console.WriteLine("Modelo 303 T1 2026:")
Console.WriteLine($"  Casilla 01 (Base IVA 21%): {baseImponibleTotal:C2}")
Console.WriteLine($"  Casilla 11 (Cuota IVA 21%): {cuotaIVATotal:C2}")
Console.WriteLine($"  Facturas tipo F1: {operacionesF1}")

' Generar el XLSX resumen para presentación AEAT
Dim resumen303 As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim ws As WorkSheet = resumen303.CreateWorkSheet("Modelo303_T1_2026")
ws("A1").Value = "Casilla"
ws("B1").Value = "Descripción"
ws("C1").Value = "Importe (€)"
ws("A2").Value = "01"
ws("B2").Value = "Base IVA repercutido 21%"
ws("C2").Value = baseImponibleTotal
ws("A3").Value = "11"
ws("B3").Value = "Cuota IVA repercutida 21%"
ws("C3").Value = cuotaIVATotal
resumen303.SaveAs("AEAT_Modelo303_T1_2026_Resumen.xlsx")

Este mismo patrón de lectura con LINQ se puede aplicar al modelo 347 (operaciones con terceros > 3.005,06 €), al modelo 390 (resumen anual IVA) y al modelo 130 (pago fraccionado IRPF para autónomos). Para empresas del País Vasco sujetas a TicketBAI (Bizkaia, Gipuzkoa, Araba) o a VeriFactu (Real Decreto-Ley 15/2025), IronXL puede leer los XLSX de trazabilidad de facturación y procesarlos en el mismo pipeline sin necesidad de Office.

¿Cómo manejar múltiples formatos de Excel?

IronXL detecta automáticamente el formato del archivo a partir de la extensión y el encabezado del archivo. La API es idéntica para los archivos XLSX, XLS y CSV, lo que significa que el mismo código de análisis funciona en los tres formatos sin lógica condicional.

using IronXL;

// Load different formats with identical API
WorkBook xlsxBook = WorkBook.Load("Modern.xlsx");
WorkBook xlsBook  = WorkBook.Load("Legacy.xls");
WorkBook csvBook  = WorkBook.Load("Export.csv");

// Access worksheets identically across formats
WorkSheet sheet1 = xlsxBook.DefaultWorkSheet;
WorkSheet sheet2 = xlsBook.DefaultWorkSheet;
WorkSheet sheet3 = csvBook.DefaultWorkSheet;

// Cross-format conversion -- save XLSX as CSV, or CSV as XLSX
xlsxBook.SaveAs("converted_output.csv");
csvBook.SaveAs("structured_output.xlsx");

Console.WriteLine($"XLSX rows: {sheet1.RowCount}");
Console.WriteLine($"XLS rows:  {sheet2.RowCount}");
Console.WriteLine($"CSV rows:  {sheet3.RowCount}");

using IronXL;

// Load different formats with identical API
WorkBook xlsxBook = WorkBook.Load("Modern.xlsx");
WorkBook xlsBook  = WorkBook.Load("Legacy.xls");
WorkBook csvBook  = WorkBook.Load("Export.csv");

// Access worksheets identically across formats
WorkSheet sheet1 = xlsxBook.DefaultWorkSheet;
WorkSheet sheet2 = xlsBook.DefaultWorkSheet;
WorkSheet sheet3 = csvBook.DefaultWorkSheet;

// Cross-format conversion -- save XLSX as CSV, or CSV as XLSX
xlsxBook.SaveAs("converted_output.csv");
csvBook.SaveAs("structured_output.xlsx");

Console.WriteLine($"XLSX rows: {sheet1.RowCount}");
Console.WriteLine($"XLS rows:  {sheet2.RowCount}");
Console.WriteLine($"CSV rows:  {sheet3.RowCount}");

Imports IronXL

' Load different formats with identical API
Dim xlsxBook As WorkBook = WorkBook.Load("Modern.xlsx")
Dim xlsBook As WorkBook = WorkBook.Load("Legacy.xls")
Dim csvBook As WorkBook = WorkBook.Load("Export.csv")

' Access worksheets identically across formats
Dim sheet1 As WorkSheet = xlsxBook.DefaultWorkSheet
Dim sheet2 As WorkSheet = xlsBook.DefaultWorkSheet
Dim sheet3 As WorkSheet = csvBook.DefaultWorkSheet

' Cross-format conversion -- save XLSX as CSV, or CSV as XLSX
xlsxBook.SaveAs("converted_output.csv")
csvBook.SaveAs("structured_output.xlsx")

Console.WriteLine($"XLSX rows: {sheet1.RowCount}")
Console.WriteLine($"XLS rows:  {sheet2.RowCount}")
Console.WriteLine($"CSV rows:  {sheet3.RowCount}")

Para los archivos CSV, IronXL respeta las convenciones RFC 4180, incluidos los campos entre comillas que contienen comas, nuevas líneas dentro de valores entre comillas y comillas dobles escapadas. La guía de conversión de CSV a XLSX cubre la personalización de delimitadores para exportaciones CSV no estándar.

Cuando su aplicación debe aceptar archivos de sistemas externos, es una buena práctica inspeccionar la extensión del archivo y validar el contenido antes de cargarlo. IronXL lanza una excepción descriptiva si el archivo está dañado o tiene un formato no compatible, que puedes detectar y mostrarle al usuario.

¿Cómo ejecutar consultas avanzadas en datos de Excel?

Más allá de la lectura celda por celda, IronXL expone funciones agregadas y compatibilidad LINQ que convierten un rango de una hoja de cálculo en una colección consultable.

using IronXL;
using System.Linq;

WorkBook workbook = WorkBook.Load("Financials.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Built-in aggregates -- no manual looping needed
decimal totalSales = sheet["B2:B50"].Sum();
decimal maxRevenue = sheet["C2:C50"].Max(c => c.DecimalValue);
decimal avgMargin  = sheet["D2:D50"].Avg();

// LINQ filtering directly on a range
var highValueRows = sheet["C2:C50"]
    .Where(c => c.DecimalValue > 1000)
    .Select(c => new { c.AddressString, c.DecimalValue });

foreach (var row in highValueRows)
    Console.WriteLine($"Alto value at {row.AddressString}: {row.DecimalValue:C}");

// Write a calculated result back to the sheet
sheet["E2"].Value = totalSales;
workbook.SaveAs("Financials_Updated.xlsx");

Console.WriteLine($"Total: {totalSales:C}, Max: {maxRevenue:C}, Avg: {avgMargin:C}");

using IronXL;
using System.Linq;

WorkBook workbook = WorkBook.Load("Financials.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Built-in aggregates -- no manual looping needed
decimal totalSales = sheet["B2:B50"].Sum();
decimal maxRevenue = sheet["C2:C50"].Max(c => c.DecimalValue);
decimal avgMargin  = sheet["D2:D50"].Avg();

// LINQ filtering directly on a range
var highValueRows = sheet["C2:C50"]
    .Where(c => c.DecimalValue > 1000)
    .Select(c => new { c.AddressString, c.DecimalValue });

foreach (var row in highValueRows)
    Console.WriteLine($"Alto value at {row.AddressString}: {row.DecimalValue:C}");

// Write a calculated result back to the sheet
sheet["E2"].Value = totalSales;
workbook.SaveAs("Financials_Updated.xlsx");

Console.WriteLine($"Total: {totalSales:C}, Max: {maxRevenue:C}, Avg: {avgMargin:C}");

Imports IronXL
Imports System.Linq

Dim workbook As WorkBook = WorkBook.Load("Financials.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Built-in aggregates -- no manual looping needed
Dim totalSales As Decimal = sheet("B2:B50").Sum()
Dim maxRevenue As Decimal = sheet("C2:C50").Max(Function(c) c.DecimalValue)
Dim avgMargin As Decimal = sheet("D2:D50").Avg()

' LINQ filtering directly on a range
Dim highValueRows = sheet("C2:C50") _
    .Where(Function(c) c.DecimalValue > 1000) _
    .Select(Function(c) New With {Key .AddressString = c.AddressString, Key .DecimalValue = c.DecimalValue})

For Each row In highValueRows
    Console.WriteLine($"Alto value at {row.AddressString}: {row.DecimalValue:C}")
Next

' Write a calculated result back to the sheet
sheet("E2").Value = totalSales
workbook.SaveAs("Financials_Updated.xlsx")

Console.WriteLine($"Total: {totalSales:C}, Max: {maxRevenue:C}, Avg: {avgMargin:C}")

La compatibilidad con LINQ es útil cuando necesita filtrar filas antes de importarlas a una base de datos o validar que todos los valores de una columna cumplan con un umbral. La biblioteca evalúa fórmulas antes de que se ejecute LINQ, por lo que las consultas agregadas siempre operan en valores calculados finales en lugar de cadenas de fórmulas.

El tutorial de LINQ con IronXL cubre la unión de hojas de trabajo, la agrupación por columnas y la proyección de resultados en objetos fuertemente tipados: patrones que eliminan una gran cantidad de código repetitivo en el código de canalización de datos.

¿Cómo exportar datos de Excel a una DataTable?

Muchas aplicaciones .NET cargan datos de hojas de cálculo en un ADO.NET DataTable para su posterior procesamiento o inserción en una base de datos. IronXL proporciona un método de conversión directa que elimina la necesidad de mapeo manual de columnas.

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Convert worksheet to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);

Console.WriteLine($"Columns: {dataTable.Columns.Count}");
Console.WriteLine($"Rows:    {dataTable.Rows.Count}");

// Iterate the DataTable normally
foreach (DataRow row in dataTable.Rows)
{
    Console.WriteLine($"{row["ProductName"]} -- {row["Quantity"]} -- {row["Price"]}");
}

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Convert worksheet to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);

Console.WriteLine($"Columns: {dataTable.Columns.Count}");
Console.WriteLine($"Rows:    {dataTable.Rows.Count}");

// Iterate the DataTable normally
foreach (DataRow row in dataTable.Rows)
{
    Console.WriteLine($"{row["ProductName"]} -- {row["Quantity"]} -- {row["Price"]}");
}

Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("SalesData.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Convert worksheet to DataTable -- first row becomes column headers
Dim dataTable As DataTable = sheet.ToDataTable(True)

Console.WriteLine($"Columns: {dataTable.Columns.Count}")
Console.WriteLine($"Rows:    {dataTable.Rows.Count}")

' Iterate the DataTable normally
For Each row As DataRow In dataTable.Rows
    Console.WriteLine($"{row("ProductName")} -- {row("Quantity")} -- {row("Price")}")
Next

Al pasar true a ToDataTable se trata la primera fila de la hoja de cálculo como encabezados de columna. El DataTable resultante utiliza nombres de columnas de cadena que coinciden con el texto del encabezado, lo que hace que las consultas LINQ-to-DataSet posteriores sean legibles. La documentación de exportación de DataTable cubre las opciones de manejo de valores nulos e inferencia de tipos.

Este patrón es particularmente útil cuando el código descendente ya espera un DataTable, por ejemplo, al llamar a SqlBulkCopy para insertar filas en SQL Server. Puede cargar el archivo XLSX, convertirlo a un DataTable e insertarlo en masa sin escribir ningún código repetitivo de mapeo de columnas.

Para obtener una lista completa de API, consulte la referencia de API de IronXL . La referencia cubre cada propiedad y método con descripciones de parámetros y detalles del tipo de retorno.

¿Cuales son tus próximos pasos?

Leer archivos de Excel en C# es sencillo una vez que tienes la biblioteca adecuada. IronXL elimina la dependencia de Office, simplifica la superficie de la API y maneja los formatos XLSX, XLS y CSV con la misma ruta de código. Los patrones que se tratan aquí —cargar un libro de trabajo, leer valores de celdas tipificados, iterar rangos, ejecutar agregados LINQ sobre datos del SII AEAT, y exportar a un DataTable— cubren la mayoría de los requisitos de lectura de hojas de cálculo del mundo real, incluidos los flujos de cumplimiento fiscal español.

Para continuar desarrollando estos patrones:

• Lea la documentación de inicio de IronXL para obtener orientación sobre la configuración del proyecto y los requisitos de tiempo de ejecución.
• Explore las guías prácticas para escribir, formatear y generar gráficos.
• Revise la guía de soporte de fórmulas de Excel para comprender qué funciones de Excel IronXL evalúa automáticamente.
• Consulte la página de licencias de IronXL para conocer las opciones de implementación de producción.
• Explore el blog de IronXL para obtener ejemplos prácticos que cubren validación de datos, exportaciones de tablas dinámicas y manejo de archivos protegidos con contraseña.

Para los equipos que evalúan IronXL frente a otras bibliotecas, la comparación IronXL vs EPPlus y la comparación IronXL vs NPOI cubren puntos de referencia de rendimiento y diferencias de API. Ambas comparaciones incluyen ejemplos de código para operaciones equivalentes en cada biblioteca.

La especificación del formato de archivo Excel de Microsoft es una referencia útil si encuentra estructuras de hojas de cálculo inusuales en sistemas heredados. El estándar ECMA-376 define el formato OOXML que siguen los archivos XLSX.

Comience con una licencia de prueba gratuita de IronXL para probar la API completa en su propio proyecto antes de comprometerse con una licencia de producción.