Leer y procesar archivos OpenDocument Spreadsheet (SAD) y Excel en C# es sencillo cuando se utiliza la biblioteca adecuada. Con IronXL, puedes cargar cualquier archivo XLS, XLSX, SAD o CSV en un objeto WorkBook usando una sola llamada de método -- no se requiere instalación de Microsoft Excel, registro COM, ni enfrentarte a problemas de Interop. Esta guía le guía paso a paso: instalación del paquete, carga de archivos, extracción de valores de celdas con tipo, trabajo con hojas de cálculo con nombre, manejo de celdas combinadas e implementación en entornos Linux o en contenedores.
Añade IronXL a tu proyecto a través del Gestor de paquetes NuGet. Abra la consola del gestor de paquetes en Visual Studio y ejecute:
IronXL es compatible con .NET 8, .NET 9, .NET 10, .NET Framework 4.6.2+ y .NET Standard 2.0, por lo que se adapta tanto a código moderno como a código heredado. Una vez que se instala el paquete, agrega la directiva using IronXL; en la parte superior de cualquier archivo que trabaje con hojas de cálculo, y estarás listo para cargar tu primer libro de trabajo.
Para Azure Functions, contenedores Docker o API alojadas en Linux, no se requiere ninguna configuración de tiempo de ejecución adicional. La biblioteca incluye todo lo que necesita internamente y no recurre a componentes de automatización de Excel.
IronXL trata los archivos SAD, XLS, XLSX y CSV de manera idéntica a través del método WorkBook.Load. Se pasa una ruta de archivo absoluta o relativa, y la biblioteca detecta el formato a partir del encabezado del archivo, no solo de la extensión. Esto significa que un archivo renombrado de .ods a .xlsx todavía se lee correctamente.
using IronXL;
// Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
WorkBook workbook = WorkBook.Load("quarterly_report.ods");
// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];
// Read a cell value
string companyName = sheet["A1"].StringValue;
int recordCount = sheet["B1"].IntValue;
Console.WriteLine($"Company : {companyName}");
Console.WriteLine($"Records : {recordCount}");Imports IronXL
' Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
Dim workbook As WorkBook = WorkBook.Load("quarterly_report.ods")
' Access the first worksheet by index
Dim sheet As WorkSheet = workbook.WorkSheets(0)
' Read a cell value
Dim companyName As String = sheet("A1").StringValue
Dim recordCount As Integer = sheet("B1").IntValue
Console.WriteLine($"Company : {companyName}")
Console.WriteLine($"Records : {recordCount}")La misma llamada funciona para archivos XLSX y XLS; solo hay que cambiar la ruta. WorkBook.Load devuelve el mismo objeto fuertemente tipado sin importar el formato de origen, por lo que el resto de tu código permanece idéntico ya sea que el archivo provenga de Microsoft Excel, LibreOffice o cualquier otra aplicación compatible con ODF.
Iterar sobre todas las filas y celdas es la tarea de procesamiento de Excel más común -- ya sea que estés validando datos de importación, transformando registros o alimentando una canalización de informes. IronXL expone una colección Rows en cada WorkSheet:
using IronXL;
WorkBook workbook = WorkBook.Load("customers.xlsx");
WorkSheet worksheet = workbook.WorkSheets[0];
Console.WriteLine($"Total rows : {worksheet.RowCount}");
Console.WriteLine($"Total columns : {worksheet.ColumnCount}");
Console.WriteLine();
foreach (var row in worksheet.Rows)
{
foreach (var cell in row)
{
if (!cell.IsEmpty)
Console.Write($"{cell.StringValue,-20}");
}
Console.WriteLine();
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")
Dim worksheet As WorkSheet = workbook.WorkSheets(0)
Console.WriteLine($"Total rows : {worksheet.RowCount}")
Console.WriteLine($"Total columns : {worksheet.ColumnCount}")
Console.WriteLine()
For Each row In worksheet.Rows
For Each cell In row
If Not cell.IsEmpty Then
Console.Write($"{cell.StringValue,-20}")
End If
Next
Console.WriteLine()
NextLas propiedades RowCount y ColumnCount devuelven solo el rango poblado -- no se incluyen filas y columnas finales vacías. Comprobar cell.IsEmpty antes de leer evita un procesamiento innecesario en hojas dispersas.
Para archivos grandes, considera usar acceso basado en rangos (worksheet["A1:D500"]) en lugar de iteración completa de hoja. Esto limita las celdas cargadas en la memoria y acelera el procesamiento cuando solo se necesita un subconjunto de los datos.
Las celdas de una hoja de cálculo real contienen cadenas, números enteros, decimales, valores booleanos y fechas. IronXL expone propiedades tipadas específicas para que nunca tengas que analizar cadenas sin procesar manualmente:
using IronXL;
WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workbook.GetWorkSheet("Products");
// Typed accessors handle conversion automatically
string productName = sheet["A2"].StringValue;
int quantity = sheet["B2"].IntValue;
decimal unitPrice = sheet["C2"].DecimalValue;
bool inStock = sheet["D2"].BoolValue;
DateTime? lastAudit = sheet["E2"].DateTimeValue;
Console.WriteLine($"Product : {productName}");
Console.WriteLine($"Qty : {quantity}");
Console.WriteLine($"Price : {unitPrice:C}");
Console.WriteLine($"In Stock : {inStock}");
Console.WriteLine($"Audited : {lastAudit?.ToString("d") ?? "Never"}");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workbook.GetWorkSheet("Products")
' Typed accessors handle conversion automatically
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim unitPrice As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue
Dim lastAudit As DateTime? = sheet("E2").DateTimeValue
Console.WriteLine($"Product : {productName}")
Console.WriteLine($"Qty : {quantity}")
Console.WriteLine($"Price : {unitPrice:C}")
Console.WriteLine($"In Stock : {inStock}")
Console.WriteLine($"Audited : {If(lastAudit?.ToString("d"), "Never")}")Cuando una celda contiene una fórmula, IronXL la evalúa y devuelve el resultado calculado a través de las mismas propiedades tipadas. No es necesario llamar a un método de evaluación independiente. En el caso de las celdas que puedan estar vacías o contener un tipo incompatible, la biblioteca devuelve el valor predeterminado para ese tipo en lugar de lanzar una excepción, lo que simplifica la lógica de validación de entradas.
| Propiedad | Tipo .NET | Devuelve un valor cuando está vacío | Notas |
|---|---|---|---|
ValorDeCadena | cadena | Cadena vacía | Siempre seguro; convierte cualquier celda en texto |
IntValue | int | 0 | Trunca los decimales |
ValorDecimal | decimal | 0m | Preserva la precisión de los datos financieros |
ValorDoble | doble | 0.0 | Uso para valores científicos o estadísticos |
BoolValue | bool | falso | Lee celdas TRUE/FALSE de Excel |
DateTimeValue | ¿DateTime? | null | Nullable: compruebe antes de usar |
Las hojas de cálculo empresariales suelen contener varias hojas con nombre: una por mes, una por región o una por línea de productos. IronXL te ofrece múltiples formas de acceder a ellas:
using IronXL;
WorkBook workbook = WorkBook.Load("annual_sales.xlsx");
// Option 1: access by name (throws if the sheet does not exist)
WorkSheet januarySheet = workbook.GetWorkSheet("January");
// Option 2: iterate all sheets in the workbook
foreach (WorkSheet ws in workbook.WorkSheets)
{
Console.WriteLine($"Sheet: {ws.Name} | Rows: {ws.RowCount}");
// Read the header row from each sheet
string header = ws["A1"].StringValue;
Console.WriteLine($" Header: {header}");
}
// Option 3: access by zero-based index
WorkSheet lastSheet = workbook.WorkSheets[workbook.WorkSheets.Count - 1];
Console.WriteLine($"Last sheet: {lastSheet.Name}");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("annual_sales.xlsx")
' Option 1: access by name (throws if the sheet does not exist)
Dim januarySheet As WorkSheet = workbook.GetWorkSheet("January")
' Option 2: iterate all sheets in the workbook
For Each ws As WorkSheet In workbook.WorkSheets
Console.WriteLine($"Sheet: {ws.Name} | Rows: {ws.RowCount}")
' Read the header row from each sheet
Dim header As String = ws("A1").StringValue
Console.WriteLine($" Header: {header}")
Next
' Option 3: access by zero-based index
Dim lastSheet As WorkSheet = workbook.WorkSheets(workbook.WorkSheets.Count - 1)
Console.WriteLine($"Last sheet: {lastSheet.Name}")Cuando el nombre de la hoja es conocido en tiempo de diseño, GetWorkSheet es la opción más clara. Para procesamiento dinámico -- donde los nombres de las hojas provienen de la entrada del usuario o de la configuración -- iterar la colección WorkSheets previene suposiciones codificadas y maneja libros de trabajo con números variables de hojas.
Los informes y los paneles de control suelen utilizar celdas combinadas para encabezados, etiquetas agrupadas y filas de resumen. IronXL lee el valor de la celda superior izquierda de una región combinada, exactamente tal y como lo muestra Excel:
using IronXL;
WorkBook workbook = WorkBook.Load("report_with_merges.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// The merged region A1:D1 stores its value in cell A1
string reportTitle = sheet["A1"].StringValue;
Console.WriteLine($"Report title : {reportTitle}");
// Read cell formatting metadata
var titleCell = sheet["A1"];
Console.WriteLine($"Bold : {titleCell.Style.Font.Bold}");
Console.WriteLine($"Font size : {titleCell.Style.Font.Height}");
// Scan an entire column for non-empty section headers
foreach (var cell in sheet["A1:A100"])
{
if (!cell.IsEmpty && cell.Style.Font.Bold)
Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}");
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("report_with_merges.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' The merged region A1:D1 stores its value in cell A1
Dim reportTitle As String = sheet("A1").StringValue
Console.WriteLine($"Report title : {reportTitle}")
' Read cell formatting metadata
Dim titleCell = sheet("A1")
Console.WriteLine($"Bold : {titleCell.Style.Font.Bold}")
Console.WriteLine($"Font size : {titleCell.Style.Font.Height}")
' Scan an entire column for non-empty section headers
For Each cell In sheet("A1:A100")
If Not cell.IsEmpty AndAlso cell.Style.Font.Bold Then
Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}")
End If
NextEl árbol de propiedades Style refleja la estructura de la especificación OOXML SpreadsheetML, por lo que los nombres de las propiedades resultan familiares si has trabajado con el SDK de Open XML. Sin embargo, IronXL envuelve toda esa complejidad en una API limpia que no requiere ninguna manipulación de XML por tu parte.
Los archivos CSV producidos por exportaciones de bases de datos, sistemas CRM y aplicaciones heredadas pueden leerse a través de la misma llamada WorkBook.Load. IronXL deduce el delimitador a partir del contenido del archivo:
using IronXL;
// Load a comma-separated values file -- same method, same API
WorkBook csvWorkbook = WorkBook.Load("export.csv");
WorkSheet csvSheet = csvWorkbook.DefaultWorkSheet;
Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}");
// Process rows exactly like any other worksheet
foreach (var row in csvSheet.Rows)
{
string id = row[0].StringValue;
string name = row[1].StringValue;
Console.WriteLine($"{id,-10} {name}");
}Imports IronXL
' Load a comma-separated values file -- same method, same API
Dim csvWorkbook As WorkBook = WorkBook.Load("export.csv")
Dim csvSheet As WorkSheet = csvWorkbook.DefaultWorkSheet
Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}")
' Process rows exactly like any other worksheet
For Each row In csvSheet.Rows
Dim id As String = row(0).StringValue
Dim name As String = row(1).StringValue
Console.WriteLine($"{id,-10} {name}")
NextDespués de cargar, puedes guardar los datos como XLSX usando csvWorkbook.SaveAs("output.xlsx"). Este es un patrón habitual en los procesos de conversión de CSV a Excel: recibir un archivo CSV, enriquecerlo con columnas calculadas o formato, y devolver al usuario un informe XLSX formateado.
Para archivos separados por tabuladores o delimitadores personalizados, usa WorkBook.LoadCSV("file.tsv", fileFormato: ExcelFileFormato.TSV) para especificar el formato explícitamente.
| Formato | Extensión | Producido por | Notas |
|---|---|---|---|
| XLSX | .xlsx | Excel 2007+, LibreOffice | Formatoo moderno predeterminado; basado en XML |
| XLS | .xls | Excel 97-2003 | Formatoo binario; compatibilidad total de lectura/escritura |
| SAD | .ods | LibreOffice, OpenOffice | Estándar OpenDocument para hojas de cálculo |
| CSV | .csv | Cualquier aplicación | Delimitador detectado automáticamente; sin formato |
| TSV | .tsv | Exportaciones de bases de datos | Delimitado por tabulaciones; especificar el formato explícitamente |
La alternativa más común a IronXL for .NET para la automatización de Excel es Microsoft.Office.Interop.Excel. Comprender las ventajas y desventajas te ayuda a elegir la herramienta adecuada para tu proyecto.
Microsoft Interop envuelve el modelo de objetos COM de Excel. Esto significa que Excel debe estar instalado en todos los equipos que ejecuten su código, incluidos servidores web, agentes de compilación y máquinas virtuales en la nube. La gestión del ciclo de vida de los objetos COM es manual: debes liberar cada objeto Range, Worksheet y Workbook explícitamente, o los procesos de Excel se acumulan en el fondo y consumen memoria hasta que el servidor se reinicia. La licencia también es un tema a tener en cuenta: el EULA de Office prohíbe la automatización del lado del servidor en muchos casos.
IronXL evita todas estas limitaciones. Se trata de una biblioteca gestionada pura sin dependencia de COM. El objeto WorkBook es una clase estándar de .NET; El recolector de basura se encarga de la limpieza. Puedes ejecutar el mismo código en un portátil de desarrollador, un Azure App Service, un contenedor Docker o una Raspberry Pi con Linux.
El SDK de Open XML de Microsoft es otra alternativa. Proporciona acceso directo al formato de archivo OOXML sin necesidad de Excel, pero opera a un nivel muy bajo: se manipulan los elementos XML directamente. Para leer el valor de una sola celda es necesario navegar por tablas de cadenas compartidas, referencias de celdas e índices de estilos. IronXL envuelve todo eso en la llamada de una sola línea sheet["A1"].StringValue que se muestra a lo largo de esta guía.
Las implementaciones en servidor son donde la independencia de IronXL respecto a Excel resulta más valiosa. El mismo código que escribes en Windows se ejecuta sin cambios en Ubuntu, Alpine Linux o macOS. Para implementaciones en contenedores, tu Dockerfile no requiere ninguna configuración especial:
# Standard .NET runtime image -- no Office packages needed
FROM mcr.microsoft.com/dotnet/runtime:10.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ExcelProcessor.dll"]Para Azure Functions y AWS Lambda, IronXL funciona dentro del entorno de ejecución gestionado sin necesidad de configuración adicional. La sobrecarga de arranque en frío es mínima, ya que no hay ningún paso de inicialización COM.
La seguridad de los hilos está incorporada: múltiples hilos pueden abrir diferentes instancias WorkBook concurrentemente sin coordinación. Si necesitas procesar miles de archivos en paralelo -- por ejemplo, en un trabajo en segundo plano que ingiere hojas de cálculo subidas por los usuarios -- puedes usar Parallel.ForEach o Task.WhenAll a lo largo de un grupo de instancias WorkBook sin riesgo de corrupción.
El uso de memoria sigue siendo predecible porque IronXL solo carga en memoria la hoja de cálculo solicitada, no todo el libro de trabajo al iniciarse. En el caso de archivos muy grandes, esta distinción es importante: un libro con diez hojas de 50 MB no requiere 500 MB de RAM solo para leer una única hoja. La documentación de rendimiento de IronXL cubre estrategias adicionales para manejar escenarios de procesamiento de archivos de gran volumen.
La forma más rápida de probar IronXL en tu proyecto es instalar el paquete NuGet y ejecutar los ejemplos de esta guía con un archivo real de tu Entorno. Una licencia de prueba gratuita desbloquea todas las funciones sin necesidad de cambios en el código cuando esté listo para la producción.
Explora las capacidades relacionadas de IronXL que complementan la lectura de archivos:
Para preguntas sobre licencias, compatibilidad multiplataforma o requisitos específicos de formatos de archivo, el equipo de soporte de IronXL está disponible a través del chat en vivo y el correo electrónico.
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.
