Trabajar con varios formatos de Excel a menudo requiere leer los datos y luego reconfigurarlos programáticamente. En este artículo, aprenderemos cómo leer un archivo CSV y analizar datos de una hoja de cálculo de Excel en C# usando IronXL, la herramienta perfecta para el trabajo.
CSV es un formato de datos simple, pero puede haber muchas diferencias; puede ser difícil de leer programáticamente en nuestros proyectos C# porque utiliza varios delimitadores para distinguir entre filas y columnas de datos. Este artículo te mostrará cómo usar la biblioteca IronXL para leer archivos CSV.
Antes de poder usar IronXL para leer archivos CSV en MVC, ASP.NET o .NET Core, necesitas instalarlo. Aquí hay una guía rápida.
Buscar IronXL en el Administrador de Paquetes NuGet en Visual Studio
Cuando necesites leer archivos CSV en C#, IronXL es la herramienta perfecta. Puedes leer un archivo CSV con comas, o cualquier otro delimitador, como se ve en los segmentos de código a continuación.
// Load a CSV file and interpret it as an Excel-like workbook
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
// Access the default worksheet in the workbook
WorkSheet ws = workbook.DefaultWorkSheet;
// Save the workbook to a new Excel file
workbook.SaveAs("Csv_To_Excel.xlsx");' Load a CSV file and interpret it as an Excel-like workbook
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
' Access the default worksheet in the workbook
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Save the workbook to a new Excel file
workbook.SaveAs("Csv_To_Excel.xlsx")Salida:
Archivo CSV de salida con delimitador de coma
Explicación del Código:
Se crea un objeto WorkBook. Luego se utiliza el método LoadCSV para el objeto WorkBook para especificar el nombre del CSV, su formato, y qué delimitadores se utilizan en el archivo CSV que se está leyendo. En este caso, se utilizan comas como delimitadores.
Luego se crea un objeto WorkSheet. Aquí es donde se colocará el contenido del archivo CSV. El archivo se guarda con un nuevo nombre y formato.
Datos mostrados en Microsoft Excel
Usa IronXL para tu proyecto como una forma simplificada de trabajar con formatos de archivo Excel en C#. Puedes instalar IronXL mediante descarga directa. Alternativamente, puedes usar NuGet Install para Visual Studio. El software es gratuito para el desarrollo.
WorkBook y Acceder a WorkSheetWorkBook es la clase de IronXL cuyo objeto proporciona acceso completo al archivo Excel y todas sus funciones. Por ejemplo, si queremos acceder a un archivo de Excel, usaríamos el código:
// Load the Excel file
WorkBook wb = WorkBook.Load("sample.xlsx"); // Excel file path' Load the Excel file
Dim wb As WorkBook = WorkBook.Load("sample.xlsx") ' Excel file pathPara acceder a la hoja de cálculo específica de un archivo Excel, IronXL proporciona la clase WorkSheet.
// Access a specific worksheet by name
WorkSheet ws = wb.GetWorkSheet("Sheet1"); // by sheet name' Access a specific worksheet by name
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1") ' by sheet nameUna vez que haya obtenido la hoja de cálculo Excel ws, puede extraer cualquier tipo de datos de ella y realizar todas las funciones de Excel sobre ella. El acceso a los datos de la hoja de cálculo Excel ws se realiza a través de este proceso:
using IronXL;
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Iterate through a range of cells and display their values
foreach (var cell in ws["A2:A10"])
{
Console.WriteLine("Value is: {0}", cell.Text);
}
Console.ReadKey();
}
}Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Iterate through a range of cells and display their values
For Each cell In ws("A2:A10")
Console.WriteLine("Value is: {0}", cell.Text)
Next cell
Console.ReadKey()
End Sub
End ClassUsando IronXL, es muy fácil operar con un Excel WorkSheet como un DataTable.
DataTable dt = ws.ToDataTable(true); // Converts the worksheet to a DataTable, using the first row as column namesDim dt As DataTable = ws.ToDataTable(True) ' Converts the worksheet to a DataTable, using the first row as column namesUsa los siguientes espacios de nombres:
using IronXL;
using System.Data;Imports IronXL
Imports System.DataEscribe el siguiente código:
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel file Name
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Parse worksheet into datatable
DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable
// Iterate through rows and columns to display their values
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();
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' Your Excel file Name
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Parse worksheet into datatable
Dim dt As DataTable = ws.ToDataTable(True) ' Parse Sheet1 of sample.xlsx file into DataTable
' Iterate through rows and columns to display their values
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
End Class
Salida de consola desde un objeto DataTable
En este ejemplo, veremos cómo usar un archivo Excel como un DataSet.
class Program
{
static void Main(string[] args)
{
// Load the workbook and convert it to a DataSet
WorkBook wb = WorkBook.Load("sample.xlsx");
DataSet ds = wb.ToDataSet(); // Parse WorkBook wb into DataSet
// Iterate through tables to display their names
foreach (DataTable dt in ds.Tables)
{
Console.WriteLine(dt.TableName);
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and convert it to a DataSet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ds As DataSet = wb.ToDataSet() ' Parse WorkBook wb into DataSet
' Iterate through tables to display their names
For Each dt As DataTable In ds.Tables
Console.WriteLine(dt.TableName)
Next dt
End Sub
End Class
Acceder al nombre de la hoja desde el objeto DataSet
Veamos otro ejemplo de cómo acceder a cada valor de celda en todas las hojas de Excel. Aquí, podemos acceder a cada valor de celda de cada WorkSheet en un archivo Excel.
class Program
{
static void Main(string[] args)
{
// Load the workbook and convert it to a DataSet
WorkBook wb = WorkBook.Load("Weather.xlsx");
DataSet ds = wb.ToDataSet(); // Treat the complete Excel file as DataSet
// Iterate through each table and its rows and columns
foreach (DataTable dt in ds.Tables) // Treat 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();
}
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and convert it to a DataSet
Dim wb As WorkBook = WorkBook.Load("Weather.xlsx")
Dim ds As DataSet = wb.ToDataSet() ' Treat the complete Excel file as DataSet
' Iterate through each table and its rows and columns
For Each dt As DataTable In ds.Tables ' Treat 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
End Class
Salida de consola del objeto Dataset
Los archivos CSV tienen una gran cantidad de problemas con cómo se manejan los saltos de línea en los campos, o cómo los campos pueden estar contenidos entre comillas que bloquean completamente un enfoque simple de división de cadena. Recientemente he descubierto las siguientes opciones para convertir CSV en C# .NET especificando un delimitador personalizable en lugar de usar string.Split(',') para separar los valores por una coma.
Este proceso avanza al lector a través del siguiente archivo. Leemos los archivos de campo CSV en TryGetField. Usamos la función de lectura en campos de campo de los archivos CSV como campos de registro.
// Load a CSV file, specify the file format and delimiter
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");
// Access the default worksheet from the workbook
WorkSheet ws = workbook.DefaultWorkSheet;
// Convert worksheet to DataTable
DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable
// Iterate through rows and columns to display their values
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();
}' Load a CSV file, specify the file format and delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")
' Access the default worksheet from the workbook
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Convert worksheet to DataTable
Dim dt As DataTable = ws.ToDataTable(True) ' Parse Sheet1 of sample.xlsx file into DataTable
' Iterate through rows and columns to display their values
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
Salida de consola desde DataTable
Ahora podemos obtener fácilmente cualquier tipo de datos, usando una variedad de métodos, del Excel abierto WorkSheet. En el siguiente ejemplo, podemos ver cómo acceder a un valor de celda específico y analizarlo en string:
// 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()En la línea anterior, ws es el WorkSheet, que se definió en el Paso 2. Este es 'el enfoque simple', pero puede leer más y ver diferentes ejemplos de cómo acceder a los datos del archivo Excel.
Al usar hojas de cálculo de Excel para construir aplicaciones, a menudo analizamos los resultados basados en datos y debemos analizar los datos de los archivos Excel dentro de C# en el formato requerido para obtener los resultados correctos. Analizar datos en diferentes formatos es fácil en el entorno C# con el uso de IronXL; ve los pasos a continuación.
using IronXL;
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
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;
// Output parsed values to the console
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
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
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
' Output parsed values to the console
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
End ClassAhora pasamos a cómo analizar datos de archivos Excel. Primero, miramos cómo tratar con datos numéricos de Excel, y luego cómo analizarlos en nuestro formato requerido.
Tabla resumen para cada tipo de dato
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
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;
// Output parsed values to the console
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();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
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
' Output parsed values to the console
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
End ClassEste código mostrará la siguiente salida:
Salida de consola con tipo de dato correcto
Y podemos ver los valores del archivo Excel sample.xlsx aquí:
Mostrar tipo de dato correcto en Excel
Para analizar los datos de un archivo Excel en un tipo de dato Booleano, IronXL proporciona la función BoolValue. Se puede usar de la siguiente manera:
// Access a cell value as a boolean
bool Val = ws["Cell Address"].BoolValue;' Access a cell value as a boolean
Dim Val As Boolean = ws("Cell Address").BoolValueclass Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Convert a range into an array
var array = ws["B6:F6"].ToArray();
// Get the count of items in the array
int item = array.Count();
// Get the first item as a string
string total_items = array[0].Value.ToString();
// Output information about the array to the console
Console.WriteLine("First item in the array: {0}", item);
Console.WriteLine("Total items from B6 to F6: {0}", total_items);
Console.ReadKey();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Convert a range into an array
Dim array = ws("B6:F6").ToArray()
' Get the count of items in the array
Dim item As Integer = array.Count()
' Get the first item as a string
Dim total_items As String = array(0).Value.ToString()
' Output information about the array to the console
Console.WriteLine("First item in the array: {0}", item)
Console.WriteLine("Total items from B6 to F6: {0}", total_items)
Console.ReadKey()
End Sub
End ClassWorkSheet en un DataTableUna excelente característica de IronXL es que podemos convertir fácilmente un Excel específico WorkSheet en un DataTable. Para este propósito, podemos usar la función .ToDataTable() de IronXL de la siguiente manera:
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Parse Sheet1 of sample.xlsx file into DataTable
// Setting 'true' makes the first row in Excel as the column names in DataTable
DataTable dt = ws.ToDataTable(true);
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Parse Sheet1 of sample.xlsx file into DataTable
' Setting 'true' makes the first row in Excel as the column names in DataTable
Dim dt As DataTable = ws.ToDataTable(True)
End Sub
End ClassSi queremos analizar un archivo Excel completo en un DataSet, para este propósito podemos usar la función .ToDataSet() en IronXL.
class Program
{
static void Main(string[] args)
{
// Load an entire workbook into a DataSet
WorkBook wb = WorkBook.Load("sample.xlsx");
// Convert workbook to DataSet
DataSet ds = wb.ToDataSet();
// We can also get a DataTable from the DataSet which corresponds to a WorkSheet
DataTable dt = ds.Tables[0];
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load an entire workbook into a DataSet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
' Convert workbook to DataSet
Dim ds As DataSet = wb.ToDataSet()
' We can also get a DataTable from the DataSet which corresponds to a WorkSheet
Dim dt As DataTable = ds.Tables(0)
End Sub
End ClassIronXL proporciona un método inteligente para leer datos de archivos Excel dentro de un rango específico. El rango se puede aplicar tanto a filas como a columnas.
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
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();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
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
End ClassEl código anterior muestra la siguiente salida:
Salida de consola para acceder a todos los valores en el rango B3:B8
Y produce los valores del archivo Excel sample.xlsx:
Mostrar datos de sample.xlsx
Además, IronXL también es compatible con muchos métodos de Excel para interactuar con celdas, incluyendo estilización y bordes, funciones matemáticas, formato condicional o crear gráficos a partir de datos disponibles.
En el desarrollo de aplicaciones, necesitamos tomar decisiones basadas en el tipo de dato booleano en archivos Excel.
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
WorkBook wb = WorkBook.Load("sample.xlsx");
WorkSheet ws = wb.GetWorkSheet("Sheet1");
// Traverse a range and output boolean values
foreach (var item in ws["G1:G10"])
{
Console.WriteLine("Condition is: {0}", item.BoolValue);
}
Console.ReadKey();
}
}Module Program
Sub Main(args As String())
' Load the workbook and access a specific worksheet
Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")
' Traverse a range and output boolean values
For Each item In ws("G1:G10")
Console.WriteLine("Condition is: {0}", item.BoolValue)
Next
Console.ReadKey()
End Sub
End ModuleDe esto obtenemos la salida:
Salida de consola obteniendo datos booleanos
Y el archivo Excel sample.xlsx con valores de C1 a C10:
Ejemplo de Excel para comparar con la salida de consola
Es simple leer una hoja completa de Excel usando índices de filas y columnas. Para este propósito, usamos dos bucles: uno para recorrer todas las filas y el segundo para recorrer todas las columnas de una fila específica. Luego podemos obtener fácilmente todos los valores de celda dentro de toda la hoja de Excel.
class Program
{
static void Main(string[] args)
{
// Load the workbook and access a specific worksheet
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();
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load the workbook and access a specific worksheet
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
End Class
Salida de consola leyendo todos los valores
IronXL es una Biblioteca de Excel para C# y .NET que permite a los desarrolladores leer y editar datos de Excel desde documentos XLS y XLSX sin usar Microsoft.Office.Interop.Excel.
La API nos permite crear, leer, manipular, guardar y exportar archivos de Excel de manera intuitiva para:
Agrega los siguientes espacios de nombres:
using IronXL;
using System;
using System.Linq;Imports IronXL
Imports System
Imports System.LinqAhora escribe el siguiente código dentro de la función principal.
class Program
{
static void Main(string[] args)
{
// Load an Excel file and access the first worksheet
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);
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
' Load an Excel file and access the first worksheet
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
End Sub
End Class
Salida de consola de cada celda
IronXL también es totalmente compatible con el desarrollo de aplicaciones ASP.NET, MVC, Windows, macOS, Linux, iOS y Android Mobile.
Además del análisis de CSV en C#, ¡IronXL convierte archivos CSV a Excel con solo dos líneas de código!
Usando C# o VB.NET, es muy fácil usar la API de Excel de IronXL sin necesidad de Interop. Puedes 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 frameworks, puedes comprar 5 productos por el precio de dos. Haz clic en nuestra página de precios para más información.
5 productos de Iron Suite
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronXL es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
La API de Excel que necesita, sin la molestia de Office Interop.
