1. IronXL
  2. Blog de IronXL
  3. Uso de IronXL
  4. C# Tutorial de lectura de archivos CSV
USO DE IRONXL

Lectura de archivos CSV en C#: un tutorial

Actualizado 6 de enero, 2024
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ónBiblioteca 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:

ALibro de trabajo se crea el objeto. EnCargarCSV 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.

AHoja 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#. Puedeinstalar IronXL mediante descarga directa. También puede utilizarInstalació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");//Excel file path
WorkBook wb = WorkBook.Load("sample.xlsx");//Excel file path
Dim wb As WorkBook = WorkBook.Load("sample.xlsx") 'Excel file path
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"); //by sheet name
WorkSheet ws = wb.GetWorkSheet("Sheet1"); //by sheet name
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1") 'by sheet name
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"); // Your Excel file Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    DataTable dt = ws.ToDataTable(true);//parse sheet1 of sample.xlsx file into datatable
    foreach (DataRow row in dt.Rows) //access rows
    {
        for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
        {
            Console.Write(row [i] + "  ");
        }
        Console.WriteLine();
    }
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel file Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    DataTable dt = ws.ToDataTable(true);//parse sheet1 of sample.xlsx file into datatable
    foreach (DataRow row in dt.Rows) //access rows
    {
        for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
        {
            Console.Write(row [i] + "  ");
        }
        Console.WriteLine();
    }
}
Shared Sub Main(ByVal args() As String)
	Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' Your Excel file Name
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	Dim dt As DataTable = ws.ToDataTable(True) 'parse sheet1 of sample.xlsx file into datatable
	For Each row As DataRow In dt.Rows 'access rows
		For i As Integer = 0 To dt.Columns.Count - 1 'access columns of corresponding row
			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();//behave complete Excel file as DataSet
    foreach (DataTable dt in ds.Tables)//behave Excel WorkSheet as DataTable.
    {
        foreach (DataRow row in dt.Rows)//corresponding Sheet's Rows
        {
            for (int i = 0; i < dt.Columns.Count; i++)//Sheet columns of corresponding row
            {
                Console.Write(row [i] + "  ");
            }
            Console.WriteLine();
        }
    }
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("Weather.xlsx");
    DataSet ds = wb.ToDataSet();//behave complete Excel file as DataSet
    foreach (DataTable dt in ds.Tables)//behave Excel WorkSheet as DataTable.
    {
        foreach (DataRow row in dt.Rows)//corresponding Sheet's Rows
        {
            for (int i = 0; i < dt.Columns.Count; i++)//Sheet columns of corresponding row
            {
                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() 'behave complete Excel file as DataSet
	For Each dt As DataTable In ds.Tables 'behave Excel WorkSheet as DataTable.
		For Each row As DataRow In dt.Rows 'corresponding Sheet's Rows
			For i As Integer = 0 To dt.Columns.Count - 1 'Sheet columns of corresponding row
				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);//parse sheet1 of sample.xlsx file into datatable
foreach (DataRow row in dt.Rows) //access rows
{
    for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
    {
        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);//parse sheet1 of sample.xlsx file into datatable
foreach (DataRow row in dt.Rows) //access rows
{
    for (int i = 0; i < dt.Columns.Count; i++) //access columns of corresponding row
    {
        Console.Write(row [i] + "  ");
    }
    Console.WriteLine();
}
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim dt As DataTable = ws.ToDataTable(True) 'parse sheet1 of sample.xlsx file into datatable
For Each row As DataRow In dt.Rows 'access rows
	For i As Integer = 0 To dt.Columns.Count - 1 'access columns of corresponding row
		Console.Write(row (i) & "  ")
	Next i
	Console.WriteLine()
Next row
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:

//Access the Data by Cell Addressing
string val = ws ["Cell Address"].ToString();
//Access the Data by Cell Addressing
string val = ws ["Cell Address"].ToString();
'Access the Data by Cell Addressing
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ómoacceder 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");
    //Parse Excel cell value into string
    string str_val = ws ["B3"].Value.ToString();
    //Parse Excel cell value into 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");
    //Parse Excel cell value into string
    string str_val = ws ["B3"].Value.ToString();
    //Parse Excel cell value into 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")
	'Parse Excel cell value into string
	Dim str_val As String = ws ("B3").Value.ToString()
	'Parse Excel cell value into 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");
    //Parse Excel cell value into string
    string str_val = ws ["B3"].Value.ToString();
    //Parse Excel cell value into 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");
    //Parse Excel cell value into string
    string str_val = ws ["B3"].Value.ToString();
    //Parse Excel cell value into 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")
	'Parse Excel cell value into string
	Dim str_val As String = ws ("B3").Value.ToString()
	'Parse Excel cell value into 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ónBoolValue 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");
    //parse sheet1 of sample.xlsx file into DataTable.
    //we set parameter true of ToDataTable() function,so first row of Excel file becomes columnname of DataTable
    DataTable dt = ws.ToDataTable(true);
}
static void Main(string [] args)
{
    WorkBook wb = WorkBook.Load("sample.xlsx");
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //parse sheet1 of sample.xlsx file into DataTable.
    //we set parameter true of ToDataTable() function,so first row of Excel file becomes columnname of 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")
	'parse sheet1 of sample.xlsx file into DataTable.
	'we set parameter true of ToDataTable() function,so first row of Excel file becomes columnname of 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();
    //we also can get DataTable from ds which is actually WorkSheet as:
    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();
    //we also can get DataTable from ds which is actually WorkSheet as:
    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()
	'we also can get DataTable from ds which is actually WorkSheet as:
	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");
    //get specified range values by loop
    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");
    //get specified range values by loop
    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")
	'get specified range values by loop
	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, incluyendoestilo 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"); // your Excel File Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Traverse all rows of Excel WorkSheet
    for (int i = 0;  i< ws.Rows.Count(); i++)
    {
        //Traverse all columns of specific Row
        for (int j = 0; j < ws.Columns.Count(); j++)
        {
            //Get the values
            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"); // your Excel File Name
    WorkSheet ws = wb.GetWorkSheet("Sheet1");
    //Traverse all rows of Excel WorkSheet
    for (int i = 0;  i< ws.Rows.Count(); i++)
    {
        //Traverse all columns of specific Row
        for (int j = 0; j < ws.Columns.Count(); j++)
        {
            //Get the values
            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") ' your Excel File Name
	Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
	'Traverse all rows of Excel WorkSheet
	For i As Integer = 0 To ws.Rows.Count() - 1
		'Traverse all columns of specific Row
		For j As Integer = 0 To ws.Columns.Count() - 1
			'Get the values
			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 unBiblioteca 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. .NET Standard

  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();

//Select cells easily in Excel notation and return the calculated value
int cellValue = sheet ["A2"].IntValue;
// Read from Ranges of cells elegantly.
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();

//Select cells easily in Excel notation and return the calculated value
int cellValue = sheet ["A2"].IntValue;
// Read from Ranges of cells elegantly.
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()

'Select cells easily in Excel notation and return the calculated value
Dim cellValue As Integer = sheet ("A2").IntValue
' Read from Ranges of cells elegantly.
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 deAná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 comoXLS/XLSX/CSV/TSV. Con el soporte de múltiples marcos, puede comprar 5 productos por el precio de dos. Haga clic ennuestra 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

Informar un Problema

¿Listo para empezar? Versión: 2024.11 acaba de salir

Descarga gratuita de NuGet Descargas totales: 1,111,773 Ver licencias >

Consigue GRATIS

Clave de prueba de 30 días al instante.

Clave de prueba de 15 días al instante.

bullet_checkedNo se necesita tarjeta de crédito ni crear una cuenta
Greencheck In Yellowcircle related to Lectura de archivos CSV en C#: un tutorial
El formulario de prueba se presentó
con éxito.

Tu clave de prueba debería estar en el correo electrónico.
Si no es así, póngase en contacto con
support@ironsoftware.com

prueba_balasPrueba en producción
sin marcas de agua
bullet_calendar30 días totalmente
producto funcional
apoyo_balas24/5 técnico
apoyo durante el juicio