Cómo importar datos de Excel en C# usando IronXL

¿Cómo se instala IronXL y se empieza a utilizar la importación de Excel?

Comenzar con la importación de Excel en C# toma sólo unos minutos con IronXL. La biblioteca de Excel admite tanto el formato XLS heredado como el moderno XLSX, además de CSV, TSV y otros formatos de hoja de cálculo. A diferencia de las soluciones que dependen de Microsoft.Office.Interop.Excel, IronXL se ejecuta de forma independiente en cualquier plataforma .NET o .NET Core.

Instala IronXL a través del Gestor de paquetes NuGet o la CLI de .NET. También puede utilizar el cuadro de diálogo "Administrar paquetes NuGet" en Visual Studio y buscar "IronXL":

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Para obtener todos los detalles de la instalación, incluidas las notas sobre compatibilidad de versiones y dependencias, consulte la guía de instalación de IronXL NuGet. No se requieren dependencias de tiempo de ejecución ni componentes de Office adicionales: el paquete es autónomo. Una vez instalado el paquete, importar datos de Excel es muy sencillo:

using IronXL;

// Load any Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
// Access the first worksheet
WorkSheet sheet = workBook.WorkSheets[0];
// Read a cell value
string value = sheet["B1"].StringValue;
Console.WriteLine(value);

using IronXL;

// Load any Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
// Access the first worksheet
WorkSheet sheet = workBook.WorkSheets[0];
// Read a cell value
string value = sheet["B1"].StringValue;
Console.WriteLine(value);

Imports IronXL

' Load any Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
' Access the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets(0)
' Read a cell value
Dim value As String = sheet("B1").StringValue
Console.WriteLine(value)

Este código muestra el flujo de trabajo principal: cargar un libro de trabajo, acceder a una hoja de cálculo y leer los valores de las celdas. El método WorkBook.Load() detecta automáticamente el formato del archivo, ya sea XLS, XLSX o CSV. La intuitiva sintaxis del indexador sheet["B1"] hace que acceder a las celdas sea tan natural como trabajar con matrices. Para obtener una referencia completa de los miembros y sobrecargas disponibles, consulte la documentación de la API de IronXL.

¿Cómo se leen los datos de Excel en objetos C#?

Las aplicaciones reales necesitan algo más que valores unicelulares. IronXL destaca en la importación de conjuntos de datos completos y su conversión en objetos C# utilizables. Cuando necesites importar datos estructurados de Excel, la biblioteca ofrece múltiples enfoques que se mapean directamente a tus modelos de dominio.

El ejemplo siguiente lee filas de una hoja de cálculo y asigna cada fila a un objeto tipado Product:

using IronXL;

// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Map rows to typed objects
var products = new List<Product>();
foreach (var row in sheet.Rows)
{
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        IsAvailable = row.Columns[3].BoolValue
    };
    products.Add(product);
}

foreach (var product in products)
{
    Console.WriteLine(
        $"Id: {product.Id}, Name: {product.Name}, " +
        $"Price: {product.Price}, Available: {product.IsAvailable}"
    );
}

using IronXL;

// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Map rows to typed objects
var products = new List<Product>();
foreach (var row in sheet.Rows)
{
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        IsAvailable = row.Columns[3].BoolValue
    };
    products.Add(product);
}

foreach (var product in products)
{
    Console.WriteLine(
        $"Id: {product.Id}, Name: {product.Name}, " +
        $"Price: {product.Price}, Available: {product.IsAvailable}"
    );
}

Imports IronXL

' Load the Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

' Map rows to typed objects
Dim products As New List(Of Product)()
For Each row In sheet.Rows
    Dim product As New Product With {
        .Id = row.Columns(0).IntValue,
        .Name = row.Columns(1).StringValue,
        .Price = row.Columns(2).DecimalValue,
        .IsAvailable = row.Columns(3).BoolValue
    }
    products.Add(product)
Next

For Each product In products
    Console.WriteLine(
        $"Id: {product.Id}, Name: {product.Name}, " &
        $"Price: {product.Price}, Available: {product.IsAvailable}"
    )
Next

Las propiedades tipadas -- IntValue, StringValue, DecimalValue y BoolValue -- gestionan la conversión de tipos automáticamente. Este enfoque elimina el análisis sintáctico manual y reduce los errores al trabajar con columnas de tipos de datos mixtos. Muchos desarrolladores en Stack Overflow aprecian este enfoque seguro en cuanto a tipos para la importación de datos de Excel.

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Read a named cell range
Range dataRange = sheet["A1:D5"];

// Calculate aggregates directly on a range
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");

decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");

// Filter using LINQ
var highValueOrders = dataRange
    .Where(cell => cell.DecimalValue > 100)
    .Select(cell => cell.Value)
    .ToList();

Console.WriteLine("Orders above 100:");
foreach (var order in highValueOrders)
{
    Console.WriteLine(order);
}

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Read a named cell range
Range dataRange = sheet["A1:D5"];

// Calculate aggregates directly on a range
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");

decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");

// Filter using LINQ
var highValueOrders = dataRange
    .Where(cell => cell.DecimalValue > 100)
    .Select(cell => cell.Value)
    .ToList();

Console.WriteLine("Orders above 100:");
foreach (var order in highValueOrders)
{
    Console.WriteLine(order);
}

Imports IronXL

Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

' Read a named cell range
Dim dataRange As Range = sheet("A1:D5")

' Calculate aggregates directly on a range
Dim sum As Decimal = sheet("C1:C5").Sum()
Console.WriteLine($"Sum of C1:C5: {sum}")

Dim max As Decimal = sheet("C1:C5").Max(Function(c) c.DecimalValue)
Console.WriteLine($"Max of C1:C5: {max}")

' Filter using LINQ
Dim highValueOrders = dataRange _
    .Where(Function(cell) cell.DecimalValue > 100) _
    .Select(Function(cell) cell.Value) _
    .ToList()

Console.WriteLine("Orders above 100:")
For Each order In highValueOrders
    Console.WriteLine(order)
Next

¿Cómo se convierte Excel a DataTable en C#?

La conversión de DataTable es esencial para las operaciones de base de datos y los escenarios de vinculación de datos. IronXL proporciona métodos integrados que gestionan la conversión de Excel a DataSet o DataTable. Esta función resulta especialmente útil cuando necesitas importar hojas de cálculo de Excel a SQL Server u otras bases de datos relacionales. Dado que el objeto resultante es un System.Data.DataTable estándar, funciona con cualquier ruta de código compatible con ADO.NET sin necesidad de realizar cambios en la capa de acceso a datos.

using IronXL;
using System.Data;
using System.Data.SqlClient;

// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select the first worksheet
WorkSheet sheet = workBook.WorkSheets.First();

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

// Use SqlBulkCopy to insert directly into SQL Server
string connectionString = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;";
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
    bulkCopy.DestinationTableName = "Inventory";
    bulkCopy.WriteToServer(dataTable);
}

using IronXL;
using System.Data;
using System.Data.SqlClient;

// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select the first worksheet
WorkSheet sheet = workBook.WorkSheets.First();

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

// Use SqlBulkCopy to insert directly into SQL Server
string connectionString = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;";
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
    bulkCopy.DestinationTableName = "Inventory";
    bulkCopy.WriteToServer(dataTable);
}

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

' Load Excel file
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
' Select the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets.First()

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

' Use SqlBulkCopy to insert directly into SQL Server
Dim connectionString As String = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;"
Using bulkCopy As New SqlBulkCopy(connectionString)
    bulkCopy.DestinationTableName = "Inventory"
    bulkCopy.WriteToServer(dataTable)
End Using

El método ToDataTable() acepta un parámetro booleano que indica si la primera fila contiene encabezados. Cuando se establece en true, IronXL utiliza automáticamente los valores de la primera fila como nombres de columna. La tabla de datos resultante se integra con ADO.NET Framework, Entity Framework y controles de enlace de datos sin necesidad de configuración adicional.

Para tener un mayor control sobre el proceso de conversión, puede crear la DataTable manualmente:

using IronXL;
using System.Data;

WorkBook workBook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workBook.WorkSheets.First();

// Build DataTable manually for custom column types or validation
DataTable customTable = new DataTable();

for (int col = 0; col < sheet.ColumnCount; col++)
{
    customTable.Columns.Add($"Column{col + 1}", typeof(string));
}

foreach (var row in sheet.Rows)
{
    var dataRow = customTable.NewRow();
    for (int col = 0; col < sheet.ColumnCount; col++)
    {
        dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
    }
    customTable.Rows.Add(dataRow);
}

// Print headers
foreach (DataColumn column in customTable.Columns)
{
    Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();

// Print data rows
foreach (DataRow row in customTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

using IronXL;
using System.Data;

WorkBook workBook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workBook.WorkSheets.First();

// Build DataTable manually for custom column types or validation
DataTable customTable = new DataTable();

for (int col = 0; col < sheet.ColumnCount; col++)
{
    customTable.Columns.Add($"Column{col + 1}", typeof(string));
}

foreach (var row in sheet.Rows)
{
    var dataRow = customTable.NewRow();
    for (int col = 0; col < sheet.ColumnCount; col++)
    {
        dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
    }
    customTable.Rows.Add(dataRow);
}

// Print headers
foreach (DataColumn column in customTable.Columns)
{
    Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();

// Print data rows
foreach (DataRow row in customTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

Imports IronXL
Imports System.Data

Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workBook.WorkSheets.First()

' Build DataTable manually for custom column types or validation
Dim customTable As New DataTable()

For col As Integer = 0 To sheet.ColumnCount - 1
    customTable.Columns.Add($"Column{col + 1}", GetType(String))
Next

For Each row In sheet.Rows
    Dim dataRow = customTable.NewRow()
    For col As Integer = 0 To sheet.ColumnCount - 1
        dataRow(col) = If(row.Columns(col).Value, DBNull.Value)
    Next
    customTable.Rows.Add(dataRow)
Next

' Print headers
For Each column As DataColumn In customTable.Columns
    Console.Write($"{column.ColumnName}" & vbTab)
Next
Console.WriteLine()

' Print data rows
For Each row As DataRow In customTable.Rows
    For Each item In row.ItemArray
        Console.Write($"{item}" & vbTab)
    Next
    Console.WriteLine()
Next

Este enfoque le ofrece total flexibilidad durante la importación. Los valores nulos se gestionan correctamente convirtiéndolos a DBNull.Value, lo que garantiza la compatibilidad con las restricciones de las columnas de la base de datos. Para obtener más información sobre cómo escribir datos en archivos, consulte la guía de IronXL para escribir archivos de Excel.

¿Cómo se trabaja con fórmulas, libros de varias hojas y Entity Framework?

IronXL va más allá de la lectura básica con funciones para escenarios complejos del mundo real. La biblioteca conserva las fórmulas de Excel, lo que permite evaluar los cálculos de forma dinámica. Para los desarrolladores que trabajan con libros de Excel complejos, esto mantiene la integridad de los datos durante todo el proceso de importación.

using IronXL;

WorkBook workBook = WorkBook.Load("FinancialReport.xlsx");
WorkSheet sheet = workBook.GetWorkSheet("Reports");

// Read the evaluated result of a formula cell
decimal calculatedTotal = sheet["E10"].DecimalValue;
Console.WriteLine($"Total: {calculatedTotal}");

// Read the formula string itself
string formula = sheet["E10"].Formula;
Console.WriteLine($"Formula: {formula}"); // e.g. "=SUM(E2:E9)"

using IronXL;

WorkBook workBook = WorkBook.Load("FinancialReport.xlsx");
WorkSheet sheet = workBook.GetWorkSheet("Reports");

// Read the evaluated result of a formula cell
decimal calculatedTotal = sheet["E10"].DecimalValue;
Console.WriteLine($"Total: {calculatedTotal}");

// Read the formula string itself
string formula = sheet["E10"].Formula;
Console.WriteLine($"Formula: {formula}"); // e.g. "=SUM(E2:E9)"

Imports IronXL

Dim workBook As WorkBook = WorkBook.Load("FinancialReport.xlsx")
Dim sheet As WorkSheet = workBook.GetWorkSheet("Reports")

' Read the evaluated result of a formula cell
Dim calculatedTotal As Decimal = sheet("E10").DecimalValue
Console.WriteLine($"Total: {calculatedTotal}")

' Read the formula string itself
Dim formula As String = sheet("E10").Formula
Console.WriteLine($"Formula: {formula}") ' e.g. "=SUM(E2:E9)"

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Skip the header row, map remaining rows to entity objects
var products = sheet.Rows
    .Skip(1)
    .Select(row => new Product
    {
        Name = row.Columns[0].StringValue,
        Price = row.Columns[1].DecimalValue
    })
    .ToList();

using var context = new AppDbContext();
await context.Products.AddRangeAsync(products);
await context.SaveChangesAsync();

Console.WriteLine($"Imported {products.Count} products.");

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Skip the header row, map remaining rows to entity objects
var products = sheet.Rows
    .Skip(1)
    .Select(row => new Product
    {
        Name = row.Columns[0].StringValue,
        Price = row.Columns[1].DecimalValue
    })
    .ToList();

using var context = new AppDbContext();
await context.Products.AddRangeAsync(products);
await context.SaveChangesAsync();

Console.WriteLine($"Imported {products.Count} products.");

Imports IronXL

Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

' Skip the header row, map remaining rows to entity objects
Dim products = sheet.Rows _
    .Skip(1) _
    .Select(Function(row) New Product With {
        .Name = row.Columns(0).StringValue,
        .Price = row.Columns(1).DecimalValue
    }) _
    .ToList()

Using context As New AppDbContext()
    Await context.Products.AddRangeAsync(products)
    Await context.SaveChangesAsync()
End Using

Console.WriteLine($"Imported {products.Count} products.")

¿Cómo se gestiona el formato de las celdas durante la importación?

Al importar archivos de Excel, conservar o inspeccionar el formato de las celdas suele ser tan importante como leer los valores sin procesar. IronXL expone las propiedades de fuente, color, alineación y borde de cada celda, para que puedas aplicar reglas de validación o reproducir estilos mediante programación. Esto resulta especialmente útil en informes en los que el formato visual tiene un significado semántico, por ejemplo, celdas de colores que indican niveles de riesgo o filas en negrita que marcan totales.

Por ejemplo, es posible que desee comprobar si las celdas contienen texto en negrita —una señal habitual de que una fila es una fila de resumen o de totales— antes de decidir si incluirla en su conjunto de datos importado:

using IronXL;

WorkBook workBook = WorkBook.Load("StyledReport.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

foreach (var row in sheet.Rows)
{
    var firstCell = row.Columns[0];

    // Skip rows where the first cell is bold (typically header or total rows)
    if (firstCell.Style.Font.Bold)
    {
        continue;
    }

    Console.WriteLine($"Data row: {firstCell.StringValue}");
}

using IronXL;

WorkBook workBook = WorkBook.Load("StyledReport.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

foreach (var row in sheet.Rows)
{
    var firstCell = row.Columns[0];

    // Skip rows where the first cell is bold (typically header or total rows)
    if (firstCell.Style.Font.Bold)
    {
        continue;
    }

    Console.WriteLine($"Data row: {firstCell.StringValue}");
}

Imports IronXL

Dim workBook As WorkBook = WorkBook.Load("StyledReport.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

For Each row In sheet.Rows
    Dim firstCell = row.Columns(0)

    ' Skip rows where the first cell is bold (typically header or total rows)
    If firstCell.Style.Font.Bold Then
        Continue For
    End If

    Console.WriteLine($"Data row: {firstCell.StringValue}")
Next

Para obtener información completa sobre el formato de celdas y rangos, incluidas las cadenas de formato numérico y el acceso al color de fondo, consulte la guía de formato de celdas de IronXL. También puede aplicar operaciones de fusión a los archivos de salida tras el procesamiento; consulte la guía de fusión de celdas de IronXL.

¿Cómo elegir la licencia de IronXL adecuada para tu proyecto?

IronXL ofrece opciones de licencia flexibles que se adaptan a la envergadura de su proyecto. Hay disponible una licencia de prueba gratuita para su evaluación, que le da acceso a todas las funciones sin restricciones de tiempo durante el desarrollo. La versión de prueba añade una marca de agua a los archivos de salida, que se elimina con una licencia de producción válida.

Para los equipos que crean aplicaciones de producción, las licencias de IronXL incluyen opciones para desarrolladores individuales, equipos e implementaciones a nivel de toda la organización. Todas las licencias de producción incluyen:

• Derechos de redistribución libres de regalías
• Asistencia prioritaria por parte del equipo de desarrollo de IronXL
• Acceso a todas las actualizaciones actuales y de versiones menores durante el periodo de licencia

Si está evaluando IronXL junto con otras bibliotecas IronXL, la descripción general de las características de IronXL ofrece un desglose detallado de lo que se incluye en cada nivel.

Para empezar a utilizar IronXL en su proyecto hoy mismo, visite la página del producto IronXL o acceda directamente a la documentación de IronXL, donde encontrará guías de configuración, artículos prácticos y referencias de la API que cubren todas las características de la biblioteca IronXL.