Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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.
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.
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.
Instale
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")
Salida:
**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.
**Datos visualizados en Microsoft 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
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
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
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
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()
Utilice el siguiente espacio de nombres
using IronXL;
using System.Data;
using IronXL;
using System.Data;
Imports IronXL
Imports System.Data
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
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
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
Salida de consola del objeto Dataset
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.
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
Salida de la consola de DataTable
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()
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.
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
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.
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
Este código mostrará la siguiente salida:
Salida de la consola con el tipo de datos correcto
Y aquí podemos ver los valores del archivo Excel sample.xlsx:
**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
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
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
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
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
El código anterior muestra la siguiente salida:
Salida de consola para acceder a todos los valores del rango B3:B8
Y produce el archivo Excel muestra.xlsx valores:
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.
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
A partir de aquí, obtenemos el resultado:
**Salida de la consola para obtener datos booleanos.
Y el archivo Excel sample.xlsx con valores de C1 a C10:
Ejemplo Excel para comparar con la salida de la consola
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
Salida de la consola de la lectura de todos los valores
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:
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
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
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.
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.
5 productos de Iron Suite
9 productos API .NET para sus documentos de oficina