Leyendo archivos CSV en C#: un tutorial

¿Qué es CSV?

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.

1. How to read a CSV File in C

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.

1. En Visual Studio, selecciona el menú Proyecto
2. Administrar paquetes NuGet
3. Buscar IronXl.Excel
4. Instalar

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

Salida:

Archivo CSV de salida con delimitador de coma

Explicación del Código:

Se crea un objeto WorkBook. A continuación, se utiliza el método LoadCSV del objeto WorkBook para especificar el nombre del CSV, su formato y los delimitadores que se utilizan en el archivo CSV que se está leyendo. En este caso, se utilizan comas como delimitadores.

A continuación, 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

2. IronXL para archivos de 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.

dotnet add package IronXl.Excel

3. Cargar WorkBook y acceder a WorkSheet

WorkBook es la clase de IronXL cuyo objeto proporciona acceso completo al archivo de Excel y a 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
WorkBook wb = WorkBook.Load("sample.xlsx"); // Excel file path

Para acceder a una hoja de cálculo específica de un archivo de 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
WorkSheet ws = wb.GetWorkSheet("Sheet1"); // by sheet name

Una vez que haya obtenido la hoja de cálculo de Excel ws, podrá extraer cualquier tipo de datos de ella y aplicar todas las funciones de Excel. Se puede acceder a los datos desde la hoja de cálculo de Excel ws mediante 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();
    }
}

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

4. Leer una hoja de cálculo de Excel como una tabla de datos

Con IronXL, es muy fácil trabajar con un archivo Excel WorkSheet como una tabla de datos (DataTable).

DataTable dt = ws.ToDataTable(true); // Converts the worksheet to a DataTable, using the first row as column names

DataTable dt = ws.ToDataTable(true); // Converts the worksheet to a DataTable, using the first row as column names

Usa los siguientes espacios de nombres:

using IronXL;
using System.Data;

using IronXL;
using System.Data;

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

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

Salida de consola desde un objeto DataTable

En este ejemplo, veremos cómo utilizar un archivo de Excel como 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);
        }
    }
}

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

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

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

Salida de consola del objeto Dataset

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

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 a la hora de convertir CSV en C# .NET especificando un delimitador personalizable en lugar de utilizar string.Split(',') para separar los valores con una coma.

6. Lectura de datos CSV en registros de C

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

Salida de consola desde DataTable

7. Obtener datos de archivos de Excel

Ahora podemos obtener fácilmente cualquier tipo de datos, utilizando diversos métodos, desde el Excel abierto WorkSheet. En el siguiente ejemplo, podemos ver cómo acceder al valor de una celda específica y analizarlo en 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();

En la línea anterior, ws es el WorkSheet, que se definió en el paso 2. Este es el enfoque "sencillo", pero puede leer más y ver diferentes ejemplos de cómo acceder a los datos de un archivo de Excel.

8. How to Parse Excel Files in C

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

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

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

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

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

Este 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 y convertirlos al tipo de datos 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
bool Val = ws["Cell Address"].BoolValue;

10. Cómo analizar archivos de Excel en colecciones de C

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

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

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

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

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

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

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];
    }
}

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];
    }
}

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

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

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

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

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

De 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

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

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

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

Salida de consola leyendo todos los valores

13. Cómo leer archivos de Excel sin interoperabilidad

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:

1. .NET Framework 4.5+
2. .NET Core 2+
3. .NET Standard
4. Xamarin
5. Windows Mobile
6. Mono
7. & Azure Cloud Hosting
8. Blazor
9. .NET MAUI

Agrega los siguientes espacios de nombres:

using IronXL;
using System;
using System.Linq;

using IronXL;
using System;
using System.Linq;

Ahora 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);
        }
    }
}

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

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.

14. Conclusión y oferta especial de Iron XL

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