Travailler avec différents formats Excel nécessite souvent de lire les données puis de les reconfigurer par programmation. Dans cet article, nous apprendrons comment lire un fichier CSV et analyser les données d'une feuille de calcul Excel en C# à l'aide d'IronXL, l'outil idéal pour cette tâche.
Le format CSV est un format de données simple, mais il peut exister de nombreuses différences ; Il peut être difficile de le lire par programmation dans nos projets C# car il utilise plusieurs délimiteurs pour distinguer les lignes et les colonnes de données. Cet article vous montrera comment utiliser la bibliothèque IronXL pour lire des fichiers CSV.
Avant de pouvoir utiliser IronXL pour lire des fichiers CSV dans MVC, ASP.NET ou .NET Core, vous devez l'installer. Voici un aperçu rapide.
Recherchez IronXL dans le gestionnaire de packages NuGet de Visual Studio.
Lorsque vous avez besoin de lire des fichiers CSV en C#, IronXL est l'outil idéal. Vous pouvez lire un fichier CSV avec des virgules, ou tout autre délimiteur, comme le montrent les segments de code ci-dessous.
// 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")Sortie :
Fichier CSV de sortie avec séparateur de virgules
Explication du code :
A WorkBook object is created. La méthode LoadCSV de l'objet WorkBook est ensuite utilisée pour spécifier le nom du CSV, son format, et quels délimiteurs sont utilisés dans le fichier CSV en cours de lecture. Dans ce cas, les virgules sont utilisées comme séparateurs.
Un objet WorkSheet est ensuite créé. C'est ici que le contenu du fichier CSV sera placé. Le fichier est enregistré sous un nouveau nom et dans un nouveau format.
Données affichées dans Microsoft Excel
Utilisez IronXL pour votre projet : c'est une méthode simplifiée pour travailler avec les formats de fichiers Excel en C#. Vous pouvez installer IronXL par téléchargement direct . Vous pouvez également utiliser NuGet Install pour Visual Studio . Le logiciel est gratuit pour le développement.
WorkBook et accéder à WorkSheetWorkBook est la classe d'IronXL dont l'objet fournit un accès complet au fichier Excel et à toutes ses fonctions. Par exemple, si nous voulons accéder à un fichier Excel, nous utiliserions le code suivant :
// 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 pathPour accéder à la feuille de calcul spécifique d'un fichier Excel, IronXL fournit la classe 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 nameUne fois que vous avez obtenu la feuille de calcul Excel ws, vous pouvez en extraire n'importe quel type de données et effectuer toutes les fonctions Excel dessus. Les données peuvent être accédées à partir de la feuille de calcul Excel ws grâce à ce processus :
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 ClassAvec IronXL, il est très facile de travailler avec un Excel WorkSheet comme 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 namesUtilisez les espaces de noms suivants :
using IronXL;
using System.Data;Imports IronXL
Imports System.DataÉcrivez le code suivant :
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
Sortie console d'un objet DataTable
Dans cet exemple, nous allons voir comment utiliser un fichier Excel comme 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
Accédez au nom de la feuille à partir de l'objet DataSet
Prenons un autre exemple pour illustrer comment accéder à la valeur de chaque cellule dans toutes les feuilles Excel. Ici, nous pouvons accéder à la valeur de chaque cellule de chaque feuille de calcul d'un fichier 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
Sortie console de l'objet Dataset
Les fichiers CSV présentent de nombreux problèmes liés à la gestion des sauts de ligne dans les champs, ou à la manière dont les champs peuvent être contenus entre guillemets, ce qui bloque complètement une approche simple de division de chaîne. J'ai récemment découvert les options suivantes lors de la conversion de CSV en C# .NET en spécifiant un délimiteur personnalisable au lieu d'utiliser string.Split(',') pour séparer les valeurs par une virgule.
Ce processus permet de passer au fichier suivant. Nous lisons les fichiers de champs CSV dans TryGetField. Nous utilisons la fonction de lecture sur les champs des fichiers CSV en tant que champs d'enregistrement.
// 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
Sortie de la console depuis DataTable
Nous pouvons maintenant facilement obtenir n'importe quel type de données, en utilisant une variété de méthodes, à partir de l'Excel ouvert WorkSheet. Dans l'exemple suivant, nous pouvons voir comment accéder à une valeur de cellule spécifique et l'analyser à 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()Dans la ligne ci-dessus, ws est le WorkSheet, qui a été défini à l'étape 2. C'est 'l'approche simple', mais vous pouvez lire plus et voir différents exemples de comment accéder aux données des fichiers Excel.
Lors de l'utilisation de feuilles de calcul Excel pour le développement d'applications, nous analysons souvent les résultats en fonction des données et devons analyser les données du fichier Excel en C# pour les mettre au format requis afin d'obtenir les résultats corrects. L'analyse des données en différents formats est facilitée dans l'environnement C# grâce à l'utilisation d'IronXL ; voir les étapes ci-dessous.
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 ClassNous allons maintenant aborder la manière d'analyser les données d'un fichier Excel. Nous allons d'abord examiner comment traiter les données numériques Excel, puis comment les analyser pour les convertir au format souhaité.
Tableau récapitulatif pour chaque type de données
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 ClassCe code affichera le résultat suivant :
Sortie console avec type de données correct
Et nous pouvons voir ici les valeurs du fichier Excel sample.xlsx :
Afficher le type de données correct dans Excel
Pour analyser les données du fichier Excel en type de données Boolean, IronXL fournit la fonction BoolValue. Il peut être utilisé comme suit :
// 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 Excel dans un DataTableUne excellente fonctionnalité d'IronXL est que nous pouvons facilement convertir un spécifique WorkSheet Excel en DataTable. Pour cela, nous pouvons utiliser la fonction .ToDataTable() d'IronXL de la manière suivante :
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 nous voulons analyser un fichier Excel complet dans un DataSet, alors à cette fin nous pouvons utiliser la fonction .ToDataSet() dans 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 propose une méthode intelligente pour lire les données d'un fichier Excel dans une plage spécifique. La plage peut être appliquée aux lignes et aux colonnes.
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 ClassLe code ci-dessus affiche la sortie suivante :
Sortie console pour accéder à toutes les valeurs de la plage B3:B8
Et produit les valeurs du fichier Excel sample.xlsx :
Affichage des données du fichier sample.xlsx
De plus, IronXL est également compatible avec de nombreuses méthodes Excel permettant d'interagir avec les cellules, notamment la mise en forme et les bordures , les fonctions mathématiques , la mise en forme conditionnelle ou la création de graphiques à partir des données disponibles.
Dans le développement d'applications, nous devons prendre des décisions en fonction du type de données booléennes dans les fichiers 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 ModuleOn obtient ainsi le résultat suivant :
Sortie de la console lors de la récupération de données booléennes
Et le fichier Excel sample.xlsx avec les valeurs de C1 à C10 :
Exemple Excel à comparer avec la sortie de la console
Il est simple de lire une feuille de calcul Excel complète en utilisant les index des lignes et des colonnes. Pour cela, nous utilisons deux boucles : une pour parcourir toutes les lignes et la seconde pour parcourir toutes les colonnes d'une ligne spécifique. Nous pouvons alors facilement obtenir toutes les valeurs des cellules de la feuille de calcul 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
Sortie de la console suite à la lecture de toutes les valeurs
IronXL est une bibliothèque Excel pour C# et .NET qui permet aux développeurs de lire et de modifier des données Excel à partir de documents XLS et XLSX sans utiliser Microsoft.Office.Interop.Excel .
L'API nous permet de créer, lire, manipuler, enregistrer et exporter intuitivement des fichiers Excel pour :
Ajoutez les espaces de noms suivants :
using IronXL;
using System;
using System.Linq;Imports IronXL
Imports System
Imports System.LinqMaintenant, écrivez le code suivant à l'intérieur de la fonction principale.
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
Sortie console de chaque cellule
IronXL prend également entièrement en charge le développement d'applications mobiles ASP.NET, MVC, Windows, macOS, Linux, iOS et Android.
En plus de l'analyse CSV en C#, IronXL convertit les fichiers CSV en Excel avec seulement deux lignes de code !
L'utilisation de l'API Excel d'IronXL avec C# ou VB.NET est très simple et ne nécessite pas d'interopérabilité. Vous pouvez lire, modifier et créer des feuilles de calcul Excel, ou travailler avec d'autres formats Excel tels que XLS, XLSX, CSV et TSV . Grâce à la prise en charge de plusieurs plateformes, vous pouvez acheter 5 produits pour le prix de deux. Cliquez sur notre page de tarifs pour plus d'informations.
5 produits Iron Suite
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronXL fait partie de IRONSUITE
10 API .NET pour vos documents
L'API Excel dont vous avez besoin, sans tracas Interop Office.
