USO DE IRONXL

Lectura de archivos CSV en C#: un tutorial

Actualizado 9 de diciembre, 2021
Compartir:

Trabajar con varios formatos de Excel requiere a menudo leer los datos y luego reconfigurarlos mediante programación. En este artículo, aprenderemos cómo leer un archivo CSV y analizar los datos de una hoja de cálculo Excel en C# utilizando IronXL, la herramienta perfecta para el trabajo.

¿Qué es CSV?

CSV es un formato de datos sencillo, aunque puede haber muchas diferencias, pero puede ser difícil leerlo mediante programación en nuestros proyectos de C# porque utiliza varios delimitadores para distinguir entre filas y columnas de datos. Este artículo le mostrará cómo utilizar la función Biblioteca IronXL para leer archivos CSV.


1. Cómo leer un archivo CSV en C#

Antes de que puedas hacer uso de IronXL para leer archivos CSV en MVC, ASP.NET o .NET Core, necesitas instalarlo. He aquí un rápido recorrido.

  1. En Visual Studio, seleccione el menú Proyecto
  2. Gestión de paquetes NuGet
  3. Buscar IronXL.Excel
  4. Instale

    Lectura de archivos CSV en C#: un tutorial, Figura 1: Búsqueda de IronXL en el gestor de paquetes NuGet en Visual Studio

    Busca IronXL en el gestor de paquetes NuGet de Visual Studio.

    Cuando necesite leer archivos CSV en C#, IronXL es la herramienta perfecta. Puede leer un archivo CSV con comas, o cualquier otro delimitador, como se ve en los segmentos de código siguientes.

WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
workbook.SaveAs("Csv_To_Excel.xlsx");
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
workbook.SaveAs("Csv_To_Excel.xlsx");
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
workbook.SaveAs("Csv_To_Excel.xlsx")
VB   C#

Salida:

Lectura de archivos CSV en C#: un tutorial, Figura 2: Archivo CSV de salida con delimitador de comas

**Archivo CSV de salida con delimitador por comas.

Explicación del código:

A Libro de trabajo se crea el objeto. En CargarCSV del objeto WorkBook se utiliza para especificar el nombre del archivo CSV y su formato, así como los delimitadores que se utilizan en el archivo CSV que se está leyendo. En este caso, se utilizan comas como delimitadores.

A Hoja de trabajo . Aquí se colocará el contenido del archivo CSV. A continuación, el archivo se guarda con un nuevo nombre y formato.

Lectura de archivos CSV en C#: un tutorial, Figura 3: Datos mostrados en Microsoft Excel

**Datos visualizados en Microsoft Excel


2. IronXL para archivos Excel

Utilice IronXL para su proyecto como una forma simplificada de trabajar con formatos de archivo Excel en C#. Puede instalar IronXL mediante descarga directa. También puede utilizar Instalación de NuGet para Visual Studio. El software es gratuito para el desarrollo.

Install-Package IronXL.Excel

3. Cargar WorkBook y acceder a WorkSheet.

WorkBook es la clase de IronXL cuyo objeto proporciona acceso completo al archivo Excel y a todas sus funciones. Por ejemplo, si queremos acceder a un fichero Excel, utilizaríamos el código

WorkBook wb = WorkBook.Load("sample.xlsx");//Ruta del archivo Excel
WorkBook wb = WorkBook.Load("sample.xlsx");//Ruta del archivo Excel
IRON VB CONVERTER ERROR developers@ironsoftware.com
VB   C#

Para acceder a la hoja de trabajo específica de un archivo de Excel, IronXL proporciona la clase WorkSheet.

WorkSheet ws = wb.GetWorkSheet("Sheet1"); //por nombre de hoja
WorkSheet ws = wb.GetWorkSheet("Sheet1"); //por nombre de hoja
IRON VB CONVERTER ERROR developers@ironsoftware.com
VB   C#

Una vez obtenida la hoja de cálculo Excel ws, puede extraer de ella cualquier tipo de dato y realizar en ella todas las funciones de Excel. En este proceso se puede acceder a los datos desde la hoja de cálculo Excel ws:

using IronXL;
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    foreach (var cell in ws ["A2:A10"])
    {
        Console.WriteLine("value is: {0}", cell.Text);
    }
    Console.ReadKey();
}
using IronXL;
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    foreach (var cell in ws ["A2:A10"])
    {
        Console.WriteLine("value is: {0}", cell.Text);
    }
    Console.ReadKey();
}
Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	For Each cell In ws ("A2:A10")
		Console.WriteLine("value is: {0}", cell.Text)
	Next cell
	Console.ReadKey()
End Sub
VB   C#

4. Lectura de una hoja de Excel como tabla de datos

Usando IronXL, es muy fácil operar con una Hoja de Trabajo de Excel como una Tabla de Datos.

DataTable dt = WorkSheet.ToDataTable();
DataTable dt = WorkSheet.ToDataTable();
Dim dt As DataTable = WorkSheet.ToDataTable()
VB   C#

Utilice el siguiente espacio de nombres

using IronXL;
using System.Data;
using IronXL;
using System.Data;
Imports IronXL
Imports System.Data
VB   C#

Escribe el siguiente código:

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); //  Nombre de su archivo Excel
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    DataTable dt = ws.ToDataTable(true);//convertir la hoja1 del archivo sample.xlsx en una tabla de datos
    foreach (DataRow row in dt.Rows) //filas de acceso
    {
        for (int i = 0; i < dt.Columns.Count; i++) //acceder a las columnas de la fila correspondiente
        {
            Console.Write(row [i] + "  ");
        }
        Console.WriteLine();
    }
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); //  Nombre de su archivo Excel
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    DataTable dt = ws.ToDataTable(true);//convertir la hoja1 del archivo sample.xlsx en una tabla de datos
    foreach (DataRow row in dt.Rows) //filas de acceso
    {
        for (int i = 0; i < dt.Columns.Count; i++) //acceder a las columnas de la fila correspondiente
        {
            Console.Write(row [i] + "  ");
        }
        Console.WriteLine();
    }
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") '  Nombre de su archivo Excel
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	Dim dt As DataTable = ws.ToDataTable(True) 'convertir la hoja1 del archivo sample.xlsx en una tabla de datos
	For Each row As DataRow In dt.Rows 'filas de acceso
		For i As Integer = 0 To dt.Columns.Count - 1 'acceder a las columnas de la fila correspondiente
			Console.Write(row (i) & "  ")
		Next i
		Console.WriteLine()
	Next row
End Sub
VB   C#

Lectura de archivos CSV en C#: un tutorial, Figura 4: Salida de consola de un objeto DataTable

Salida de consola de un objeto DataTable

En este ejemplo, veremos cómo utilizar un fichero Excel como DataSet.

static void Main(string [] args)
{          
    WorkBook wb = WorkBook.Load("sample.xlsx");
    DataSet ds = wb.ToDataSet(); //Parse WorkBook wb into DataSet
    foreach (DataTable dt in ds.Tables)
    {
        Console.WriteLine(dt.TableName);
    }
}
static void Main(string [] args)
{          
    WorkBook wb = WorkBook.Load("sample.xlsx");
    DataSet ds = wb.ToDataSet(); //Parse WorkBook wb into DataSet
    foreach (DataTable dt in ds.Tables)
    {
        Console.WriteLine(dt.TableName);
    }
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ds As DataSet = wb.ToDataSet() 'Parse WorkBook wb into DataSet
	For Each dt As DataTable In ds.Tables
		Console.WriteLine(dt.TableName)
	Next dt
End Sub
VB   C#

Lectura de archivos CSV en C#: un tutorial, Figura 5: Acceso al nombre de la hoja desde el objeto DataSet

Acceder al nombre de la hoja desde el objeto DataSet

Veamos otro ejemplo de cómo acceder al valor de cada celda en todas las hojas de Excel. Aquí, podemos acceder a cada valor de celda de cada WorkSheet en un archivo Excel.

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx");
    DataSet ds = wb.ToDataSet();//comportar archivo Excel completo como DataSet
    foreach (DataTable dt in ds.Tables)//comportar Excel WorkSheet como DataTable.
    {
        foreach (DataRow row in dt.Rows)//Filas de la hoja correspondiente
        {
            for (int i = 0; i < dt.Columns.Count; i++)//Columnas de hoja de la fila correspondiente
            {
                Console.Write(row [i] + "  ");
            }
            Console.WriteLine();
        }
    }
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx");
    DataSet ds = wb.ToDataSet();//comportar archivo Excel completo como DataSet
    foreach (DataTable dt in ds.Tables)//comportar Excel WorkSheet como DataTable.
    {
        foreach (DataRow row in dt.Rows)//Filas de la hoja correspondiente
        {
            for (int i = 0; i < dt.Columns.Count; i++)//Columnas de hoja de la fila correspondiente
            {
                Console.Write(row [i] + "  ");
            }
            Console.WriteLine();
        }
    }
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("Weather.xlsx")
	Dim ds As DataSet = wb.ToDataSet() 'comportar archivo Excel completo como DataSet
	For Each dt As DataTable In ds.Tables 'comportar Excel WorkSheet como DataTable.
		For Each row As DataRow In dt.Rows 'Filas de la hoja correspondiente
			For i As Integer = 0 To dt.Columns.Count - 1 'Columnas de hoja de la fila correspondiente
				Console.Write(row (i) & "  ")
			Next i
			Console.WriteLine()
		Next row
	Next dt
End Sub
VB   C#

Lectura de archivos CSV en C#: un tutorial, Figura 6: Salida de consola del objeto Dataset

Salida de consola del objeto Dataset

5. Análisis sintáctico de CSV en C# .NET

Los CSV tienen muchos problemas con el tratamiento de los saltos de línea en los campos, o con el hecho de que los campos puedan estar entre comillas, lo que bloquea completamente un enfoque simple de división de cadenas. Recientemente he descubierto las siguientes opciones a la hora de convertir CSV en C# .NET especificando un delimitador personalizable en lugar de utilizar string.Split(',') para separar los valores en una coma.

6. Lectura de datos CSV en C# Registros

Este proceso hace avanzar al lector por el siguiente fichero. Leemos los archivos de campo CSV en trygetfield. Utilizamos la función de lectura en los campos de los ficheros CSV como campos de registro.

WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
DataTable dt = ws.ToDataTable(true);//convertir la hoja1 del archivo sample.xlsx en una tabla de datos
foreach (DataRow row in dt.Rows) //filas de acceso
{
    for (int i = 0; i < dt.Columns.Count; i++) //acceder a las columnas de la fila correspondiente
    {
        Console.Write(row [i] + "  ");
    }
    Console.WriteLine();
}
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
WorkSheet ws = workbook.DefaultWorkSheet;
DataTable dt = ws.ToDataTable(true);//convertir la hoja1 del archivo sample.xlsx en una tabla de datos
foreach (DataRow row in dt.Rows) //filas de acceso
{
    for (int i = 0; i < dt.Columns.Count; i++) //acceder a las columnas de la fila correspondiente
    {
        Console.Write(row [i] + "  ");
    }
    Console.WriteLine();
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
VB   C#

Lectura de archivos CSV en C#: un tutorial, Figura 7: Salida de consola de DataTable

Salida de la consola de DataTable

7. Obtención de datos de archivos Excel

Ahora podemos obtener fácilmente cualquier tipo de datos, utilizando una variedad de métodos, desde la Hoja de Trabajo Excel abierta. En el siguiente ejemplo, podemos ver cómo acceder a un valor de celda específico y parsearlo a string:

//Acceso a los datos por direccionamiento celular
string val = ws ["Cell Address"].ToString();
//Acceso a los datos por direccionamiento celular
string val = ws ["Cell Address"].ToString();
'Acceso a los datos por direccionamiento celular
Dim val As String = ws ("Cell Address").ToString()
VB   C#

En la línea anterior ws es la Hoja de Trabajo, que se definió en el Paso 2. Este es 'el enfoque simple', pero puedes leer más y ver diferentes ejemplos de cómo acceder a datos de archivos Excel.

8. Cómo analizar archivos Excel en C#

Cuando utilizamos hojas de cálculo Excel para crear aplicaciones, a menudo analizamos los resultados basándonos en los datos y necesitamos analizar los datos del archivo Excel dentro de C# en el formato requerido para obtener los resultados correctos. El análisis sintáctico de datos en diferentes formatos es muy sencillo en el entorno C# con el uso de IronXL; consulte los pasos siguientes.

using IronXL;
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Convertir el valor de una celda de Excel en una cadena
    string str_val = ws ["B3"].Value.ToString();
    //Convertir el valor de una celda Excel en int32
    Int32 int32_val = ws ["G3"].Int32Value;
    //Parse Excel cell value into Decimal
    decimal decimal_val = ws ["E5"].DecimalValue;

    Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
    Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
    Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
    Console.ReadKey();
}
using IronXL;
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Convertir el valor de una celda de Excel en una cadena
    string str_val = ws ["B3"].Value.ToString();
    //Convertir el valor de una celda Excel en int32
    Int32 int32_val = ws ["G3"].Int32Value;
    //Parse Excel cell value into Decimal
    decimal decimal_val = ws ["E5"].DecimalValue;

    Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
    Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
    Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
    Console.ReadKey();
}
Imports IronXL
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'Convertir el valor de una celda de Excel en una cadena
	Dim str_val As String = ws ("B3").Value.ToString()
	'Convertir el valor de una celda Excel en int32
	Dim int32_val As Int32 = ws ("G3").Int32Value
	'Parse Excel cell value into Decimal
	Dim decimal_val As Decimal = ws ("E5").DecimalValue

	Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val)
	Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val)
	Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val)
	Console.ReadKey()
End Sub
VB   C#

9. Cómo analizar datos de Excel en valores numéricos y booleanos

Ahora pasamos a cómo analizar datos de archivos Excel. En primer lugar, veremos cómo tratar los datos numéricos de Excel y, a continuación, cómo convertirlos al formato que necesitamos.

Lectura de archivos CSV en C#: un tutorial, Figura 8: Tabla resumen para cada tipo de datos

Tabla resumen para cada tipo de datos

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Convertir el valor de una celda de Excel en una cadena
    string str_val = ws ["B3"].Value.ToString();
    //Convertir el valor de una celda Excel en int32
    Int32 int32_val = ws ["G3"].Int32Value;
    //Parse Excel cell value into Decimal
    decimal decimal_val = ws ["E5"].DecimalValue;
    Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
    Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
    Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
    Console.ReadKey();
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Convertir el valor de una celda de Excel en una cadena
    string str_val = ws ["B3"].Value.ToString();
    //Convertir el valor de una celda Excel en int32
    Int32 int32_val = ws ["G3"].Int32Value;
    //Parse Excel cell value into Decimal
    decimal decimal_val = ws ["E5"].DecimalValue;
    Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
    Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
    Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);
    Console.ReadKey();
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'Convertir el valor de una celda de Excel en una cadena
	Dim str_val As String = ws ("B3").Value.ToString()
	'Convertir el valor de una celda Excel en int32
	Dim int32_val As Int32 = ws ("G3").Int32Value
	'Parse Excel cell value into Decimal
	Dim decimal_val As Decimal = ws ("E5").DecimalValue
	Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val)
	Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val)
	Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val)
	Console.ReadKey()
End Sub
VB   C#

Este código mostrará la siguiente salida:

Lectura de archivos CSV en C#: un tutorial, Figura 9: Salida de la consola con el tipo de datos correcto

Salida de la consola con el tipo de datos correcto

Y aquí podemos ver los valores del archivo Excel sample.xlsx:

Lectura de archivos CSV en C#: un tutorial, Figura 10: Mostrar el tipo de datos correcto en Excel

**Mostrar el tipo de datos correcto en Excel.

Para convertir los datos de un archivo de Excel en datos de tipo booleano, IronXL proporciona la función BoolValue función. Puede utilizarse del siguiente modo:

bool Val = ws ["Cell Address"].BoolValue;
bool Val = ws ["Cell Address"].BoolValue;
Dim Val As Boolean = ws ("Cell Address").BoolValue
VB   C#

10. Cómo analizar archivos Excel en C# Colecciones

static void Main(string [] args)
{
   WorkBook wb = WorkBook.Load("sample.xlsx");
   WorkSheet ws = wb.GetWorkSheet("Sheet1");
   var array = ws ["B6:F6"].ToArray();
   int item = array.Count();
   string total_items = array [0].Value.ToString();
   Console.WriteLine("First item in the array: {0}", item);
   Console.WriteLine("Total items from B6 to F6: {0}",total_items);
   Console.ReadKey();
}
static void Main(string [] args)
{
   WorkBook wb = WorkBook.Load("sample.xlsx");
   WorkSheet ws = wb.GetWorkSheet("Sheet1");
   var array = ws ["B6:F6"].ToArray();
   int item = array.Count();
   string total_items = array [0].Value.ToString();
   Console.WriteLine("First item in the array: {0}", item);
   Console.WriteLine("Total items from B6 to F6: {0}",total_items);
   Console.ReadKey();
}
Shared Sub Main(ByVal args() As String)
   Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
   Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
   Dim array = ws ("B6:F6").ToArray()
   Dim item As Integer = array.Count()
   Dim total_items As String = array (0).Value.ToString()
   Console.WriteLine("First item in the array: {0}", item)
   Console.WriteLine("Total items from B6 to F6: {0}",total_items)
   Console.ReadKey()
End Sub
VB   C#

10.1 Cómo convertir una hoja de trabajo de Excel en una tabla de datos

Una excelente característica de IronXL es que podemos convertir fácilmente una WorkSheet específica de Excel en una DataTable. Para ello, podemos utilizar la función .ToDataTable() de IronXL de la siguiente manera:

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //parsear la hoja1 del archivo sample.xlsx en DataTable.
    //establecemos el parámetro true de la función ToDataTable(),así la primera fila del archivo Excel se convierte en el nombre de la columna de DataTable
    DataTable dt = ws.ToDataTable(true);
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //parsear la hoja1 del archivo sample.xlsx en DataTable.
    //establecemos el parámetro true de la función ToDataTable(),así la primera fila del archivo Excel se convierte en el nombre de la columna de DataTable
    DataTable dt = ws.ToDataTable(true);
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'parsear la hoja1 del archivo sample.xlsx en DataTable.
	'establecemos el parámetro true de la función ToDataTable(),así la primera fila del archivo Excel se convierte en el nombre de la columna de DataTable
	Dim dt As DataTable = ws.ToDataTable(True)
End Sub
VB   C#

10.2 Cómo convertir un archivo Excel en un DataSet

Si queremos convertir un archivo Excel completo en un DataSet, podemos utilizar la función .ToDataSet() en IronXL.

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    //parse WorkBook wb into DataSet
    DataSet ds = wb.ToDataSet();
    //también podemos obtener DataTable de ds que es en realidad WorkSheet como:
    DataTable dt=ds.Tables [0];
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    //parse WorkBook wb into DataSet
    DataSet ds = wb.ToDataSet();
    //también podemos obtener DataTable de ds que es en realidad WorkSheet como:
    DataTable dt=ds.Tables [0];
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	'parse WorkBook wb into DataSet
	Dim ds As DataSet = wb.ToDataSet()
	'también podemos obtener DataTable de ds que es en realidad WorkSheet como:
	Dim dt As DataTable=ds.Tables (0)
End Sub
VB   C#

10.3 Lectura de datos Excel dentro de un rango específico

IronXL proporciona un método inteligente para leer datos de archivos Excel dentro de un rango específico. El rango puede aplicarse tanto a filas como a columnas.

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //obtener valores de rango especificados por bucle
    foreach (var item in ws ["B3:B8"])
    {
        Console.WriteLine("Value is: {0}", item);
    }
    Console.ReadKey();
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //obtener valores de rango especificados por bucle
    foreach (var item in ws ["B3:B8"])
    {
        Console.WriteLine("Value is: {0}", item);
    }
    Console.ReadKey();
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'obtener valores de rango especificados por bucle
	For Each item In ws ("B3:B8")
		Console.WriteLine("Value is: {0}", item)
	Next item
	Console.ReadKey()
End Sub
VB   C#

El código anterior muestra la siguiente salida:

Lectura de archivos CSV en C#: un tutorial, Figura 11: Salida de la consola para acceder a todos los valores del rango B3:B8

Salida de consola para acceder a todos los valores del rango B3:B8

Y produce el archivo Excel muestra.xlsx valores:

Lectura de archivos CSV en C#: un tutorial, Figura 12: Visualización de datos de sample.xlsx

Visualización de datos de sample.xlsx

Además, IronXL también es compatible con muchos métodos de Excel para interactuar con las celdas, incluyendo estilo y borde, funciones matemáticas, [condicional formato o crear gráficos a partir de los datos disponibles.

11. Cómo leer datos booleanos en un archivo Excel

En el desarrollo de aplicaciones, necesitamos tomar decisiones basadas en el tipo de datos booleanos en archivos Excel.

static void Main(string [] args)
{
   WorkBook wb = WorkBook.Load("sample.xlsx");
   WorkSheet ws = wb.GetWorkSheet("Sheet1");
   foreach (var item in ws ["G1:G10"])
   {
   Console.WriteLine("  Condition is: {0}", item.BoolValue);
   }
   Console.ReadKey();
}
static void Main(string [] args)
{
   WorkBook wb = WorkBook.Load("sample.xlsx");
   WorkSheet ws = wb.GetWorkSheet("Sheet1");
   foreach (var item in ws ["G1:G10"])
   {
   Console.WriteLine("  Condition is: {0}", item.BoolValue);
   }
   Console.ReadKey();
}
Shared Sub Main(ByVal args() As String)
   Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
   Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
   For Each item In ws ("G1:G10")
   Console.WriteLine("  Condition is: {0}", item.BoolValue)
   Next item
   Console.ReadKey()
End Sub
VB   C#

A partir de aquí, obtenemos el resultado:

Lectura de archivos CSV en C#: un tutorial, Figura 13: Salida de la consola al obtener datos booleanos

**Salida de la consola para obtener datos booleanos.

Y el archivo Excel sample.xlsx con valores de C1 a C10:

Lectura de archivos CSV en C#: un tutorial, Figura 14: Ejemplo de Excel para comparar con la salida de la consola

Ejemplo Excel para comparar con la salida de la consola

12. Cómo leer una hoja de cálculo Excel completa

Es sencillo leer una hoja de cálculo Excel completa utilizando índices de filas y columnas. Para ello, utilizamos dos bucles: uno para recorrer todas las filas y otro para recorrer todas las columnas de una fila determinada. Entonces podemos obtener fácilmente todos los valores de las celdas dentro de toda la Hoja de Trabajo de Excel.

static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); //  el nombre de su archivo Excel
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Recorrer todas las filas de Excel WorkSheet
    for (int i = 0;  i< ws.Rows.Count(); i++)
    {
        //Recorrer todas las columnas de una Fila específica
        for (int j = 0; j < ws.Columns.Count(); j++)
        {
            //Obtener los valores
            string val = ws.Rows [i].Columns [j].Value.ToString();
            Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j,val);
        }
    }
    Console.ReadKey();
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); //  el nombre de su archivo Excel
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Recorrer todas las filas de Excel WorkSheet
    for (int i = 0;  i< ws.Rows.Count(); i++)
    {
        //Recorrer todas las columnas de una Fila específica
        for (int j = 0; j < ws.Columns.Count(); j++)
        {
            //Obtener los valores
            string val = ws.Rows [i].Columns [j].Value.ToString();
            Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j,val);
        }
    }
    Console.ReadKey();
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") '  el nombre de su archivo Excel
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'Recorrer todas las filas de Excel WorkSheet
	For i As Integer = 0 To ws.Rows.Count() - 1
		'Recorrer todas las columnas de una Fila específica
		For j As Integer = 0 To ws.Columns.Count() - 1
			'Obtener los valores
			Dim val As String = ws.Rows (i).Columns (j).Value.ToString()
			Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j,val)
		Next j
	Next i
	Console.ReadKey()
End Sub
VB   C#

Lectura de archivos CSV en C#: un tutorial, Figura 15: Salida de consola de la lectura de todos los valores

Salida de la consola de la lectura de todos los valores

13. Cómo leer archivos Excel sin Interop

IronXL es un Biblioteca Excel para C# y .NET que permite a los desarrolladores leer y editar datos de Excel desde documentos XLS y XLSX sin utilizar Microsoft.Office.Interop.Excel.

La API nos permite crear, leer, manipular, guardar y exportar archivos Excel de forma intuitiva para:

  1. .NET Framework 4.5+
  2. .NET Core 2+
  3. estándar .NET
  4. Xamarin
  5. Windows Mobile
  6. Mono
  7. & Alojamiento en la nube Azure
  8. Blazor
  9. .NET MAUI

    Añade el siguiente espacio de nombres:

using IronXL;
using System;
using System.Linq;
using IronXL;
using System;
using System.Linq;
Imports IronXL
Imports System
Imports System.Linq
VB   C#

Ahora escribe el siguiente código dentro de la función principal.

WorkBook workbook = WorkBook.Load("Weather.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

//Seleccionar celdas fácilmente en notación Excel y devolver el valor calculado
int cellValue = sheet ["A2"].IntValue;
//  Lee desde Rangos de células con elegancia.
foreach (var cell in sheet ["A2:A10"])
{
   Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}
WorkBook workbook = WorkBook.Load("Weather.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

//Seleccionar celdas fácilmente en notación Excel y devolver el valor calculado
int cellValue = sheet ["A2"].IntValue;
//  Lee desde Rangos de células con elegancia.
foreach (var cell in sheet ["A2:A10"])
{
   Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}
Dim workbook As WorkBook = WorkBook.Load("Weather.xlsx")
Dim sheet As WorkSheet = workbook.WorkSheets.First()

'Seleccionar celdas fácilmente en notación Excel y devolver el valor calculado
Dim cellValue As Integer = sheet ("A2").IntValue
'  Lee desde Rangos de células con elegancia.
For Each cell In sheet ("A2:A10")
   Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next cell
VB   C#

Lectura de archivos CSV en C#: un tutorial, Figura 16: Salida de consola de cada celda

Salida de la consola de cada celda

IronXL también es totalmente compatible con ASP.NET, MVC, Windows, macOS, Linux, iOS y Android Desarrollo de aplicaciones móviles.

14. Conclusión y oferta especial Iron XL

Además de Análisis de CSV en C#, IronXL convierte archivos CSV a Excel con sólo dos líneas de código!

Usando C# o VB.NET, es muy fácil utilizar la API de Excel de IronXL sin necesidad de Interop. Puede leer, editar y crear hojas de cálculo de Excel o trabajar con otros formatos de Excel como XLS/XLSX/CSV/TSV. Con el soporte de múltiples marcos, puede comprar 5 productos por el precio de dos. Haga clic en nuestra página de precios para más información.

Lectura de archivos CSV en C#: un tutorial, Figura 17: 5 productos de Iron Suite

5 productos de Iron Suite

< ANTERIOR
Cómo resaltar cada dos filas en Excel
SIGUIENTE >
Cómo bloquear celdas en Excel: un tutorial paso a paso

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 850,626
Ver licencias >