Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Leer Open Office Excel
USANDO IRONXL

Cómo leer archivos de Excel de Open Office en C# sin tener Excel instalado

Jordi Bardia
Jordi Bardia
Actualizado:

Leer y procesar archivos de hojas de cálculo OpenDocument (SAO) y Excel en C# es sencillo cuando se utiliza la biblioteca adecuada. Con IronXL , puede cargar cualquier archivo XLS, XLSX, SAO o CSV en un objeto WorkBook usando una única llamada de método: no se requiere la instalación de Microsoft Excel, ni registro COM, ni dolores de cabeza por interoperabilidad. Esta guía lo guiará a través de cada paso: instalar el paquete, cargar archivos, extraer valores de celdas tipificados, trabajar con hojas de trabajo con nombre, manejar celdas fusionadas e implementar en entornos Linux o en contenedores.

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

Instalación del administrador de paquetes NuGet

Agregue IronXL a su proyecto a través del Administrador de paquetes NuGet . Abra la consola del gestor de paquetes en Visual Studio y ejecute:

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

IronXL es compatible con .NET 8, .NET 9, .NET 10, .NET Framework 4.6.2+ y .NET Standard 2.0, por lo que es compatible con bases de código modernas y antiguas. Una vez instalado el paquete, agregue la directiva using IronXL; al principio de cualquier archivo compatible con hojas de cálculo y estará listo para cargar su primer libro.

Para Azure Functions, contenedores Docker o API alojadas en Linux, no se requiere ninguna configuración de tiempo de ejecución adicional. La biblioteca reúne todo lo que necesita internamente y no llama a los componentes de automatización de Excel.

¿Cómo cargar un archivo de OpenOffice o Excel en C#?

IronXL trata los archivos SAO, XLS, XLSX y CSV de manera idéntica a través del método WorkBook.Load. Pasa una ruta de archivo absoluta o relativa y la biblioteca detecta el formato del encabezado del archivo, no solo 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}");
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}");
$vbLabelText   $csharpLabel

La misma llamada funciona para archivos XLSX y XLS: solo cambie la ruta. WorkBook.Load devuelve el mismo objeto fuertemente tipado independientemente del formato de origen, por lo que el resto de su código permanece idéntico independientemente de si el archivo se origina en Microsoft Excel, LibreOffice o cualquier otra aplicación compatible con ODF.

¿Cómo leer cada fila y celda de una hoja de cálculo?

Iterando la colección de filas

Iterar sobre todas las filas y celdas es la tarea más común de procesamiento de Excel, ya sea para validar datos de importación, transformar registros o alimentar una secuencia 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();
}
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();
}
$vbLabelText   $csharpLabel

Las propiedades RowCount y ColumnCount devuelven solo el rango completado: no se incluyen las filas y columnas finales vacías. Marcar cell.IsEmpty antes de leer evita el procesamiento innecesario en hojas dispersas.

Para archivos grandes, considere usar acceso basado en rango (worksheet["A1:D500"]) en lugar de iteración de hoja completa. Esto limita las celdas cargadas en la memoria y acelera el procesamiento cuando solo se necesita un subconjunto de los datos.

¿Cómo extraer valores tipificados de las celdas?

Accesores de propiedad tipificados

Las celdas de una hoja de cálculo del mundo real contienen cadenas, números enteros, decimales, valores booleanos y fechas. IronXL expone propiedades tipificadas dedicadas para que nunca tengas que analizar cadenas sin formato 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"}");
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"}");
$vbLabelText   $csharpLabel

Cuando una celda contiene una fórmula, IronXL la evalúa y devuelve el resultado calculado a través de las mismas propiedades escritas. No es necesario llamar a un método de evaluación independiente. Para las celdas que pueden estar vacías o contener un tipo incompatible, la biblioteca devuelve el valor predeterminado para ese tipo en lugar de generar una excepción, lo que simplifica la lógica de validación de entrada.

Propiedades de valores de celda de IronXL y sus tipos .NET equivalentes
Propiedad Tipo .NET Devuelve cuando está vacío Notas
`StringValue` `cadena` Cadena vacía Siempre seguro; convierte cualquier celda en texto
`IntValue` `int` `0` Trunca decimales
`DecimalValue` `decimal` `0m` Preserva la precisión de los datos financieros
`DoubleValue` `doble` `0.0` Úselo para valores científicos o estadísticos
`BoolValue` `bool` `false` Lee celdas VERDADERO/FALSO de Excel
`DateTimeValue` `DateTime?` `null` Nullable - comprobar antes de usar

¿Cómo trabajar con múltiples hojas de trabajo con nombre?

Acceso por nombre, índice o iteración

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 producto. IronXL ofrece varias maneras 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}");
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}");
$vbLabelText   $csharpLabel

Cuando el nombre de la hoja se conoce en el momento del diseño, GetWorkSheet es la opción más clara. Para el procesamiento dinámico (donde los nombres de las hojas provienen de la entrada o configuración del usuario), iterar la colección WorkSheets evita suposiciones codificadas y maneja libros de trabajo con diferentes cantidades de hojas.

¿Cómo manejar celdas fusionadas y regiones formateadas?

Los informes y paneles con frecuencia utilizan celdas fusionadas para encabezados, etiquetas agrupadas y filas de resumen. IronXL lee el valor de la celda superior izquierda de una región fusionada, exactamente 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}");
}
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}");
}
$vbLabelText   $csharpLabel

El árbol de propiedades Style refleja la estructura de la especificación OOXML SpreadsheetML , por lo que los nombres de propiedades le resultarán familiares si ha trabajado con Open XML SDK. Sin embargo, IronXL envuelve toda esa complejidad en una API limpia que no requiere ninguna manipulación de XML de su parte.

¿Cómo importar archivos CSV con la misma API?

Los archivos CSV producidos por exportaciones de bases de datos, sistemas CRM y aplicaciones heredadas se pueden leer a través de la misma llamada WorkBook.Load. IronXL infiere el delimitador 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}");
}
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}");
}
$vbLabelText   $csharpLabel

Después de cargar, puede guardar los datos como XLSX usando csvWorkbook.SaveAs("output.xlsx"). Este es un patrón común para los procesos de conversión de CSV a Excel: recibir un archivo CSV, enriquecerlo con columnas calculadas o formato y devolver un informe XLSX formateado al usuario.

Para archivos separados por tabulaciones o delimitadores personalizados, utilice WorkBook.LoadCSV("file.tsv", fileFormato: ExcelFileFormato.TSV) para especificar el formato explícitamente.

Formatoos de archivo de entrada admitidos en IronXL
Formato Extensión Producido por Notas
XLSX `.xlsx` Excel 2007+, LibreOffice Formatoo moderno predeterminado; basado en XML
XLS `.xls` Excel 97--2003 Formatoo binario; soporte completo de lectura y escritura
SAO `.ods` LibreOffice, OpenOffice Estándar de hoja de cálculo OpenDocument
CSV `.csv` Cualquier aplicación Delimitador detectado automáticamente; sin formato
TSV `.tsv` Exportaciones de bases de datos Delimitado por tabulaciones; especifique el formato explícitamente

¿Cómo se compara IronXL con Microsoft.Office.Interop.Excel?

Interoperabilidad, Open XML SDK e IronXL en paralelo

La alternativa más común a IronXL para la automatización de Excel en .NET es Microsoft.Office.Interop.Excel . Comprender las ventajas y desventajas le ayudará a elegir la herramienta adecuada para su proyecto.

Microsoft Interop envuelve el modelo de objetos COM de Excel. Esto significa que Excel debe estar instalado en cada máquina que ejecute 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: debe liberar cada objeto Range, Worksheet y Workbook de forma explícita, o los procesos de Excel se acumulan en segundo plano y consumen memoria hasta que el servidor se reinicia. Las licencias también son una preocupación: el CLUF de Office prohíbe la automatización del lado del servidor en muchos escenarios.

IronXL evita todas estas restricciones. Es una biblioteca puramente administrada sin dependencia de COM. El objeto WorkBook es una clase .NET estándar; El recolector de elementos no utilizados se encarga de la limpieza. Puedes ejecutar el mismo código en una computadora portátil de desarrollador, en Azure App Service, en un contenedor Docker o en 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 un solo valor de celda es necesario navegar por tablas de cadenas compartidas, referencias de celdas e índices de estilo. 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.

¿Cómo implementar el procesamiento de Excel en Linux y Docker?

Las implementaciones de servidores son donde la independencia de IronXL con respecto a Excel se vuelve más valiosa. El mismo código que escribe en Windows se ejecuta sin cambios en Ubuntu, Alpine Linux o macOS. Para implementaciones en contenedores, su 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"]
# 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"]
SHELL

Para Azure Functions y AWS Lambda, IronXL funciona dentro del tiempo de ejecución administrado sin ninguna configuración adicional. La sobrecarga del arranque en frío es mínima porque no hay ningún paso de inicialización COM.

La seguridad de subprocesos está incorporada: varios subprocesos pueden abrir diferentes instancias WorkBook simultáneamente sin coordinación. Si necesita procesar miles de archivos en paralelo (por ejemplo, en un trabajo en segundo plano que ingiere hojas de cálculo cargadas por el usuario), puede usar Parallel.ForEach o Task.WhenAll en un grupo de instancias WorkBook sin riesgo de corrupción.

El uso de la memoria se mantiene predecible porque IronXL carga en la memoria solo la hoja de trabajo solicitada, no el libro completo durante la inicialización. Para 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 sola hoja. La documentación de rendimiento de IronXL cubre estrategias adicionales para manejar escenarios de procesamiento de archivos de gran volumen.

¿Cuales son tus próximos pasos?

La forma más rápida de validar IronXL en su proyecto es instalar el paquete NuGet y ejecutar los ejemplos de esta guía en un archivo real de su entorno. Una licencia de prueba gratuita desbloquea todas las funciones sin necesidad de realizar cambios en el código cuando esté listo para la producción.

Explore las capacidades relacionadas de IronXL que complementan la lectura de archivos:

Para preguntas sobre licencias, soporte multiplataforma o requisitos de formato de archivo específicos, el equipo de soporte de IronXL está disponible a través del chat en vivo y el correo electrónico.

Empiece con IronXL ahora.
green arrow pointer

Preguntas Frecuentes

¿Cómo puedo leer archivos Excel de Open Office en C# sin tener Excel instalado?

Puede usar la biblioteca IronXL para leer archivos Excel de OpenOffice en C# sin tener Excel instalado en su servidor. Permite cargar archivos XLS, XLSX, ODS y CSV eficientemente con una sola llamada al método WorkBook.Load.

¿Qué tipos de archivos Excel se pueden procesar utilizando IronXL?

IronXL admite el procesamiento de varios formatos de archivos Excel, incluidos XLS, XLSX, ODS (OpenDocument Spreadsheet) y CSV, lo que lo hace versátil para diferentes aplicaciones de hojas de cálculo, incluidas LibreOffice y OpenOffice.

¿Por qué los desarrolladores deberían utilizar IronXL en lugar de Microsoft Interop para leer archivos de Excel?

IronXL proporciona una forma más sencilla y eficiente de manejar archivos Excel sin la necesidad de Microsoft Excel o COM Interop, lo que reduce la complejidad y la sobrecarga en los servidores de producción y permite implementaciones de Linux y Docker.

¿Puede IronXL manejar archivos creados en aplicaciones de hojas de cálculo distintas de MS Excel?

Sí, IronXL puede leer y procesar archivos de otras aplicaciones de hojas de cálculo como OpenOffice Calc y LibreOffice Calc, lo que lo convierte en una herramienta flexible para desarrolladores que trabajan con formatos compatibles con ODS y ODF.

¿Es necesario instalar Excel en servidores de producción para utilizar IronXL?

No, con IronXL no es necesario instalar Excel en servidores de producción, lo que simplifica la implementación y reduce los requisitos de mantenimiento. IronXL funciona en Windows, Linux, macOS y dentro de contenedores Docker.

¿IronXL admite el procesamiento de archivos CSV?

Sí, IronXL admite totalmente la lectura y el procesamiento de archivos CSV junto con otros formatos de Excel como XLS, XLSX y ODS utilizando la misma API WorkBook.Load.

¿Cuáles son los beneficios de utilizar IronXL para los desarrolladores .NET?

IronXL ofrece a los desarrolladores de .NET una biblioteca fácil de usar para leer, escribir y manipular archivos de Excel sin necesidad de Microsoft Excel, lo que mejora la productividad y reduce el tiempo de desarrollo con una API limpia y fuertemente tipada.

¿Cómo mejora IronXL la eficiencia en el manejo de archivos Excel?

IronXL mejora la eficiencia al eliminar la necesidad de software Excel, brindando accesores de valores de celda tipificados, procesamiento concurrente seguro para subprocesos y una solución liviana que procesa archivos Excel directamente dentro de aplicaciones .NET .

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me