Une comparaison entre IronXL et Epplus

Qu'est-ce que le logiciel EPPlus ?

EPPlus est une bibliothèque .NET Framework/.NET Core basée sur NuGet permettant de gérer les feuilles de calcul Office Open XML. La version 5 inclut la prise en charge de .NET Framework 3.5 et de .NET Core 2.0. EPPlus ne dépend d'aucune autre bibliothèque, telle que Microsoft Excel.

EPPlus possède une API qui vous permet de travailler avec des documents Office Excel. EPPlus est une bibliothèque .NET qui lit et écrit des fichiers Excel au format Office OpenXML. Cette bibliothèque est disponible sous forme de package sur NuGet.

Cette bibliothèque a été créée en pensant aux programmeurs. L'objectif a toujours été de permettre à un développeur familier avec Excel ou une autre bibliothèque de tableur d'apprendre rapidement l'API. Ou encore, comme l'a dit quelqu'un, " IntelliSense, votre chemin vers la victoire ! "

Installation EPPlus

Pour installer EPPlus depuis Visual Studio, accédez à Affichage > Autres fenêtres > Console du gestionnaire de packages et saisissez la commande suivante :

Install-Package EPPlus

Si vous préférez utiliser l'interface de ligne de commande .NET, exécutez la commande suivante à partir d'une invite de commandes ou d'une invite PowerShell avec privilèges élevés :

dotnet add package EPPlus

EPPlus est un package dotnet que vous pouvez ajouter à votre projet.

Qu'est-ce qu'IronXL ?

IronXL est une API Excel simple en C# et VB qui vous permet de lire, de modifier et de créer des fichiers de tableur Excel en .NET à une vitesse fulgurante. Il n'est pas nécessaire d'installer Microsoft Office ni même Excel Interop. Cette bibliothèque permet également de travailler avec des fichiers Excel.

IronXL prend tous en charge .NET Core, .NET Framework, Xamarin, les applications mobiles, Linux, macOS et Azure.

Il existe plusieurs façons différentes de lire et d'écrire des données dans et depuis votre feuille de calcul.

Ajout d'IronXL via le package NuGet

Nous pouvons ajouter le forfait IronXL à votre compte de trois manières différentes, vous pouvez donc choisir celle qui vous convient le mieux.

• Utiliser la console du gestionnaire de packages pour installer IronXL

Utilisez la commande suivante pour ouvrir la console du gestionnaire de packages dans votre projet :

Pour accéder à la console du gestionnaire de packages, allez dans Outils => Gestionnaire de packages NuGet => Console du gestionnaire de packages.

Vous accéderez ainsi à la console du gestionnaire de packages. Ensuite, dans le terminal du Gestionnaire de paquets, saisissez la commande suivante :

Install-Package IronXL.Excel

• Utilisation du gestionnaire de packages NuGet pour installer IronXL

Il s'agit d'une approche différente pour installer le gestionnaire de packages NuGet. Vous n'aurez pas besoin d'utiliser cette méthode si vous avez déjà effectué l'installation en utilisant la méthode précédente.

Pour accéder au Gestionnaire de packages NuGet, allez dans Outils > Gestionnaire de packages NuGet => Sélectionnez Gérer les packages NuGet pour la solution dans le menu déroulant.

Cela lancera la solution NuGet ; Sélectionnez " Parcourir " et recherchez IronXL.

Dans la barre de recherche, tapez Excel :

IronXL sera installé pour vous lorsque vous cliquerez sur le bouton " Installer ". Après avoir installé IronXL, vous pouvez accéder à votre formulaire et commencer à le développer.

Création d'un fichier Excel avec IronXL

Créer un nouveau classeur Excel avec IronXL n'a jamais été aussi simple ! Il ne s'agit que d'une seule ligne de code ! Oui, c'est vrai :

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

// Create a new Excel workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

' Create a new Excel workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

IronXL peut créer des fichiers aux formats XLS (l'ancienne version du fichier Excel) et XLSX (la version actuelle et plus récente du fichier Excel).

• Définir une feuille de calcul par défaut

Il est encore plus facile de configurer une feuille de calcul par défaut :

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

// Create a worksheet named "2020 Budget" in the workbook
var sheet = workbook.CreateWorkSheet("2020 Budget");

' Create a worksheet named "2020 Budget" in the workbook
Dim sheet = workbook.CreateWorkSheet("2020 Budget")

Dans l'extrait de code ci-dessus, la feuille de calcul est représentée par sheet , et vous pouvez l'utiliser pour définir les valeurs des cellules et effectuer pratiquement toutes les opérations qu'Excel peut réaliser. Vous pouvez également convertir votre document Excel en fichier en lecture seule et effectuer des opérations de suppression. Vous pouvez également lier vos feuilles de calcul, comme le fait Excel.

Permettez-moi de clarifier la différence entre un cahier d'exercices et une feuille de calcul, au cas où vous ne seriez pas sûr(e).

Les feuilles de travail sont contenues dans un cahier d'exercices. Cela signifie que vous pouvez insérer autant de feuilles de travail que vous le souhaitez dans un classeur. J'expliquerai comment faire cela dans un article ultérieur. Les lignes et les colonnes constituent une feuille de calcul. L'intersection d'une ligne et d'une colonne est appelée cellule, et c'est avec cette cellule que vous interagirez dans Excel.

Création d'un fichier Excel avec EPPlus Software AB

EPPlus peut être utilisé pour créer des fichiers Excel et effectuer des opérations telles que la création de tableaux croisés dynamiques, de zones de pivot, et même la mise en forme conditionnelle et la modification des polices. Sans plus tarder, voici le code source complet permettant de convertir un DataTable normal en fichier Excel XLSX et de l'envoyer à l'utilisateur pour téléchargement :

public ActionResult ConvertToXLSX()
{
    byte[] fileData = null;

    // Replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // Create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // Add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and columns counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample, we'll just use the DataTable column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r[dc].ToString());
                }

                // Alternate light-gray color for uneven rows (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            // Output the XLSX file
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}

public ActionResult ConvertToXLSX()
{
    byte[] fileData = null;

    // Replace the GetDataTable() method with your DBMS-fetching code.
    using (DataTable dt = GetDataTable())
    {
        // Create an empty spreadsheet
        using (var p = new ExcelPackage())
        {
            // Add a worksheet to the spreadsheet
            ExcelWorksheet ws = p.Workbook.Worksheets.Add(dt.TableName);

            // Initialize rows and columns counter: note that they are 1-based!
            var row = 1;
            var col = 1;

            // Create the column names on the first line.
            // In this sample, we'll just use the DataTable column names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows into the XLS file
            foreach (DataRow r in dt.Rows)
            {
                row++;
                col = 0;
                foreach (DataColumn dc in dt.Columns)
                {
                    col++;
                    ws.SetValue(row, col, r[dc].ToString());
                }

                // Alternate light-gray color for uneven rows (3, 5, 7, 9)...
                if (row % 2 != 0)
                {
                    ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray);
                }
            }

            // Output the XLSX file
            using (var ms = new MemoryStream())
            {
                p.SaveAs(ms);
                ms.Seek(0, SeekOrigin.Begin);
                fileData = ms.ToArray();
            }
        }
    }

    string fileName = "ConvertedFile.xlsx";
    string contentType = System.Web.MimeMapping.GetMimeMapping(fileName);
    Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
    return File(fileData, contentType);
}

Public Function ConvertToXLSX() As ActionResult
	Dim fileData() As Byte = Nothing

	' Replace the GetDataTable() method with your DBMS-fetching code.
	Using dt As DataTable = GetDataTable()
		' Create an empty spreadsheet
		Using p = New ExcelPackage()
			' Add a worksheet to the spreadsheet
			Dim ws As ExcelWorksheet = p.Workbook.Worksheets.Add(dt.TableName)

			' Initialize rows and columns counter: note that they are 1-based!
			Dim row = 1
			Dim col = 1

			' Create the column names on the first line.
			' In this sample, we'll just use the DataTable column names
			row = 1
			col = 0
			For Each dc As DataColumn In dt.Columns
				col += 1
				ws.SetValue(row, col, dc.ColumnName)
			Next dc

			' Insert the DataTable rows into the XLS file
			For Each r As DataRow In dt.Rows
				row += 1
				col = 0
				For Each dc As DataColumn In dt.Columns
					col += 1
					ws.SetValue(row, col, r(dc).ToString())
				Next dc

				' Alternate light-gray color for uneven rows (3, 5, 7, 9)...
				If row Mod 2 <> 0 Then
					ws.Row(row).Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid
					ws.Row(row).Style.Fill.BackgroundColor.SetColor(System.Drawing.Color.LightGray)
				End If
			Next r

			' Output the XLSX file
			Using ms = New MemoryStream()
				p.SaveAs(ms)
				ms.Seek(0, SeekOrigin.Begin)
				fileData = ms.ToArray()
			End Using
		End Using
	End Using

	Dim fileName As String = "ConvertedFile.xlsx"
	Dim contentType As String = System.Web.MimeMapping.GetMimeMapping(fileName)
	Response.AppendHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName))
	Return File(fileData, contentType)
End Function

Comme vous pouvez le constater, il s'agit d'une méthode ActionResult qui peut être utilisée sur n'importe quel contrôleur ASP.NET MVC ; Si vous n'utilisez pas ASP.NET MVC, il vous suffit de copier le contenu de la méthode et de le coller où vous en avez besoin (par exemple, ASP.NET classique, application console, Windows Forms, etc.).

Le code est explicite et contient suffisamment de commentaires pour vous aider à comprendre les différents processus de traitement. Mais d'abord, un bref récapitulatif de ce que nous faisons ici :

• En utilisant une méthode de fournisseur de données personnalisée, nous obtenons un objet DataTable .
• Nous créons un objet ExcelPackage , qui est le conteneur principal d'EPPlus pour le fichier XLSX.
• Nous ajoutons une ExcelWorksheet au ExcelPackage , qui servira de feuille de calcul dans laquelle les données seront saisies.
• Pour créer notre ligne d'en-tête, nous parcourons les colonnes de la DataTable et les ajoutons à la première ligne de notre feuille de calcul.
• Nous parcourons les lignes de la DataTable , en ajoutant chacune d'elles à notre feuille de calcul ligne par ligne (en commençant par la ligne 2) afin que chaque ligne DataTable corresponde à une ligne de la feuille de calcul.
• Nous créons un MemoryStream pour stocker les données binaires ExcelPackage une fois la conversion de DataTable en ExcelPackage terminée, puis nous les convertissons en un tableau d'octets.
• Nous créons la réponse HTML et envoyons le fichier XLSX à l'utilisateur avec une pièce jointe Content-Disposition, ce qui entraîne le téléchargement automatique du fichier par le navigateur.

IronXL l'emporte dans ce cas car le processus de création est très facile : une seule ligne de code suffit ; Cela permet de gagner du temps et facilite le débogage, tandis qu'EPPlus propose des lignes de code fastidieuses à parcourir et difficiles à déboguer.

Comment EPPlus Software AB écrit des fichiers Excel

EPPlus prend en charge le traitement des fichiers Excel. Il s'agit d'une bibliothèque .NET qui lit et écrit des fichiers Excel.

• Lecture des fichiers Excel

Pour ce faire, vous devez d'abord installer le package EPPlus : allez dans " Outils " -> " Gestionnaire de packages NuGet " -> " Gérer NuGet pour cette solution " -> " Installer EPPlus " -> " Installer EPPlus " -> " Installer EPPlus " -> " Installer EPPlus " -> " Installer EP " . Recherchez " EPPlus " dans l'onglet " Parcourir ", puis installez le package NuGet.

Vous pouvez utiliser le code ci-dessous dans votre application console " Program.cs " une fois le package installé.

using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            // Use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                // Get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
                int colCount = worksheet.Dimension.End.Column;  // Get Column Count
                int rowCount = worksheet.Dimension.End.Row;     // Get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        // Print data, based on row and columns position
                        Console.WriteLine("Row:" + row + " Column:" + col + " Value:" + worksheet.Cells[row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}

using OfficeOpenXml;
using System;
using System.IO;

namespace ReadExcelInCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Provide file path
            FileInfo existingFile = new FileInfo(@"D:\sample_XLSX.xlsx");
            // Use EPPlus
            using (ExcelPackage package = new ExcelPackage(existingFile))
            {
                // Get the first worksheet in the workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets[1];
                int colCount = worksheet.Dimension.End.Column;  // Get Column Count
                int rowCount = worksheet.Dimension.End.Row;     // Get row count
                for (int row = 1; row <= rowCount; row++)
                {
                    for (int col = 1; col <= colCount; col++)
                    {
                        // Print data, based on row and columns position
                        Console.WriteLine("Row:" + row + " Column:" + col + " Value:" + worksheet.Cells[row, col].Value?.ToString().Trim());
                    }
                }
            }
        }
    }
}

Imports OfficeOpenXml
Imports System
Imports System.IO

Namespace ReadExcelInCsharp
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			' Provide file path
			Dim existingFile As New FileInfo("D:\sample_XLSX.xlsx")
			' Use EPPlus
			Using package As New ExcelPackage(existingFile)
				' Get the first worksheet in the workbook
				Dim worksheet As ExcelWorksheet = package.Workbook.Worksheets(1)
				Dim colCount As Integer = worksheet.Dimension.End.Column ' Get Column Count
				Dim rowCount As Integer = worksheet.Dimension.End.Row ' Get row count
				For row As Integer = 1 To rowCount
					For col As Integer = 1 To colCount
						' Print data, based on row and columns position
						Console.WriteLine("Row:" & row & " Column:" & col & " Value:" & worksheet.Cells(row, col).Value?.ToString().Trim())
					Next col
				Next row
			End Using
		End Sub
	End Class
End Namespace

Voici un exemple de sortie d'une application console avec un fichier Excel (.xlsx) d'exemple avec lequel nous travaillons. Voici un fichier xlsx à lire en C# avec EPPlus.

Les méthodes suivantes pour charger des données provenant de plusieurs sources sont accessibles via la propriété " cells " (ExcelRange) :

• Lire un fichier texte CSV et charger les données dans une plage d'une feuille de calcul avec LoadFromText et LoadFromTextAsync .
• LoadFromDataReaderAsync et LoadFromDataReader — chargent les champs de données d'un DataReader dans une plage.
• LoadFromDataTable — charge les données d'une DataTable dans une plage. Il peut importer des données provenant de diverses sources, notamment XML (un exemple est fourni) et des bases de données.
• LoadFromCollection — charge de manière réflexive les données d'un IEnumerable dans une plage.
• LoadFromCollection avec attributs — charge de manière réflexive les données d'un IEnumerable dans une plage ou un tableau. Les styles, les formats numériques, les formules et autres propriétés sont spécifiés via des attributs.
• LoadFromDictionaries — charge des données à partir d'un IEnumerable d'objets ExpandoObject /dynamiques (via leur IDictionary<string, object> interface) dans une plage. Ceci est utile pour importer des données JSON, et un exemple est inclus.
• LoadFromArrays — charge des données à partir d'un IEnumerable d'objets [] dans une plage, chaque tableau d'objets correspondant à une ligne de la feuille de calcul.

Lors de l'utilisation de ces méthodes, vous pouvez éventuellement fournir un paramètre pour générer un tableau Excel. Les exemples 4 et 5 du projet exemple Sample-.NET Framework ou Sample-.NET Framework contiennent des exemples plus complets.

• Écriture de fichiers Excel

Voyons maintenant si nous pouvons exporter les données vers un nouveau fichier Excel.

Voici quelques exemples de données/objets que nous aimerions enregistrer dans un document Excel.

List<UserDetails> persons = new List<UserDetails>()
{
    new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
    new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
    new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
    new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
};

List<UserDetails> persons = new List<UserDetails>()
{
    new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
    new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
    new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
    new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
};

Dim persons As New List(Of UserDetails)() From {
	New UserDetails() With {
		.ID="9999",
		.Name="ABCD",
		.City ="City1",
		.Country="USA"
	},
	New UserDetails() With {
		.ID="8888",
		.Name="PQRS",
		.City ="City2",
		.Country="INDIA"
	},
	New UserDetails() With {
		.ID="7777",
		.Name="XYZZ",
		.City ="City3",
		.Country="CHINA"
	},
	New UserDetails() With {
		.ID="6666",
		.Name="LMNO",
		.City ="City4",
		.Country="UK"
	}
}

Pour créer un nouveau fichier Excel contenant les informations essentielles, nous devons utiliser la classe ExcelPackage . L'écriture des données dans un fichier et la création d'une nouvelle feuille de calcul Excel ne nécessitent que quelques lignes de code. Veuillez noter la ligne ci-dessous qui accomplit la magie du chargement DataTables dans une feuille Excel.

Pour simplifier les choses, je génère un nouveau fichier tableur dans le même dossier de projet (le fichier Excel sera créé dans le dossier " bin " du projet). Le code source se trouve ci-dessous :

private static void WriteToExcel(string path)
{
    // Let use below test data for writing it to excel
    List<UserDetails> persons = new List<UserDetails>()
    {
        new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
        new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
        new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
        new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
    };

    // Let's convert our object data to Datatable for a simplified logic.
    // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
    DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
    FileInfo filePath = new FileInfo(path);
    using (var excelPack = new ExcelPackage(filePath))
    {
        var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
        ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
        excelPack.Save();
    }
}

private static void WriteToExcel(string path)
{
    // Let use below test data for writing it to excel
    List<UserDetails> persons = new List<UserDetails>()
    {
        new UserDetails() {ID="9999", Name="ABCD", City ="City1", Country="USA"},
        new UserDetails() {ID="8888", Name="PQRS", City ="City2", Country="INDIA"},
        new UserDetails() {ID="7777", Name="XYZZ", City ="City3", Country="CHINA"},
        new UserDetails() {ID="6666", Name="LMNO", City ="City4", Country="UK"},
    };

    // Let's convert our object data to Datatable for a simplified logic.
    // Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
    DataTable table = (DataTable)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (typeof(DataTable)));
    FileInfo filePath = new FileInfo(path);
    using (var excelPack = new ExcelPackage(filePath))
    {
        var ws = excelPack.Workbook.Worksheets.Add("WriteTest");
        ws.Cells.LoadFromDataTable(table, true, OfficeOpenXml.Table.TableStyles.Light8);
        excelPack.Save();
    }
}

Private Shared Sub WriteToExcel(ByVal path As String)
	' Let use below test data for writing it to excel
	Dim persons As New List(Of UserDetails)() From {
		New UserDetails() With {
			.ID="9999",
			.Name="ABCD",
			.City ="City1",
			.Country="USA"
		},
		New UserDetails() With {
			.ID="8888",
			.Name="PQRS",
			.City ="City2",
			.Country="INDIA"
		},
		New UserDetails() With {
			.ID="7777",
			.Name="XYZZ",
			.City ="City3",
			.Country="CHINA"
		},
		New UserDetails() With {
			.ID="6666",
			.Name="LMNO",
			.City ="City4",
			.Country="UK"
		}
	}

	' Let's convert our object data to Datatable for a simplified logic.
	' Datatable is the easiest way to deal with complex datatypes for easy reading and formatting. 
	Dim table As DataTable = CType(JsonConvert.DeserializeObject(JsonConvert.SerializeObject(persons), (GetType(DataTable))), DataTable)
	Dim filePath As New FileInfo(path)
	Using excelPack = New ExcelPackage(filePath)
		Dim ws = excelPack.Workbook.Worksheets.Add("WriteTest")
		ws.Cells.LoadFromDataTable(table, True, OfficeOpenXml.Table.TableStyles.Light8)
		excelPack.Save()
	End Using
End Sub

Suite à l'appel API mentionné ci-dessus pour la validation des données, un nouveau fichier Excel sera créé avec la transformation d'objet personnalisée ci-dessus dans les colonnes et lignes Excel appropriées, pour afficher la valeur ci-dessous.

L'API prête à l'emploi ci-dessus peut être utilisée dans la console .NET Core, un projet de test ou une application ASP.NET Core, et sa logique peut être modifiée pour répondre à vos besoins.

Ces techniques sont accessibles via la propriété " cells " (ExcelRange) :

• ToText et ToTextAsync — créent une chaîne CSV à partir d'une plage.
• Écriture d'une plage dans un fichier CSV avec SaveToText et SaveToTextAsync . - Exportation de données d'une plage vers un système à l'aide de la méthode ToDataTable. DataTable
• GetValue — affiche une valeur avec l'option d'un type de données.
• Valeur — renvoie ou définit la valeur de la plage.

Les méthodes GetValue et SetValue peuvent également être utilisées directement sur l'objet feuille de calcul. (Cela donnera des résultats légèrement meilleurs que la lecture/écriture sur le stand de tir) :

• GetValue — récupère la valeur d'une seule cellule, avec la possibilité de spécifier un type de données.
• SetValue — modifie la valeur d'une seule cellule.

LINQ peut être utilisé pour interroger des données à partir d'une feuille de calcul car la propriété cell implémente l'interface IEnumerable .

Ouvrir et écrire au format Office Open XML XLSX avec IronXL

IronXL est une bibliothèque .NET qui permet aux développeurs C# de travailler rapidement et facilement avec Excel, les tableaux croisés dynamiques et autres fichiers de tableur.

L'interopérabilité Office n'est pas requise. Il n'y a aucune dépendance particulière ni besoin d'installer Microsoft Office sur Core ou Azure.

IronXL est une bibliothèque de tableur Excel réputée, écrite en C# et VB.NET, pour .NET Core et .NET Framework.

• Lecture des fichiers Excel
• Feuille de calcul à charger

Une feuille Excel est représentée par la classe WorkBook . Nous utilisons WorkBook pour ouvrir un fichier Excel en C# contenant même des tableaux croisés dynamiques. Chargez le fichier Excel et choisissez son emplacement (.xlsx).

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

/**
 Load WorkBook
 **/
var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");

'''
''' Load WorkBook
''' *
Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")

Les objets WorkSheet se trouvent dans de nombreux classeurs. Ce sont les feuilles de calcul du document Excel. Si la feuille contient des feuilles de calcul, utilisez le nom WorkBook pour les trouver avec GetWorkSheet .

var worksheet = workbook.GetWorkSheet("GDPByCountry");

var worksheet = workbook.GetWorkSheet("GDPByCountry");

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

• Créez votre propre cahier d'exercices.

Créez un nouveau WorkBook avec le type de feuille permettant de générer un nouveau classeur WorkBook en mémoire.

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

/**
 Create WorkBook
 **/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

'''
''' Create WorkBook
''' *
Dim workbook As New WorkBook(ExcelFileFormat.XLSX)

Pour les feuilles de calcul Microsoft Excel anciennes, utilisez ExcelFileFormat.XLS (95 et versions antérieures).

Créez une feuille de calcul si vous n'en avez pas déjà une.

Chaque classeur peut contenir de nombreuses feuilles de calcul. Une feuille de calcul est une feuille de données unique, tandis qu'un classeur est un ensemble de feuilles de calcul. Dans Excel, voici à quoi ressemble un classeur contenant deux feuilles de calcul.

Le WorkBook est le nom d'une nouvelle WorkSheet que vous pouvez créer.

var worksheet = workbook.CreateWorkSheet("Countries");

var worksheet = workbook.CreateWorkSheet("Countries");

Dim worksheet = workbook.CreateWorkSheet("Countries")

Transmettez le nom de la feuille de calcul à CreateWorkSheet .

Obtenez la gamme cellulaire

La classe " Range " représente une collection bidimensionnelle d'objets " Cellule ". Cela désigne une plage spécifique de cellules Excel. En utilisant l'indexeur de chaîne sur un objet WorkSheet, vous pouvez obtenir des plages.

var range = worksheet["D2:D101"];

var range = worksheet["D2:D101"];

Dim range = worksheet("D2:D101")

Le texte de l'argument peut être les coordonnées d'une cellule (par exemple, " A1 ") ou une plage de cellules de gauche à droite et de haut en bas (par exemple, " B2:E5 "). GetRange peut également être appelée depuis une feuille de calcul.

• Dans une plage, modifier les valeurs des cellules

Les valeurs des cellules à l'intérieur d'une plage peuvent être lues ou modifiées de différentes manières. Utilisez une boucle For si le nombre est connu. Vous pouvez également personnaliser le style des cellules à partir d'ici.

/**
 Edit Cell Values in Range
 **/
 // Iterate through the rows
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{y}:E{y}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string) cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

/**
 Edit Cell Values in Range
 **/
 // Iterate through the rows
for (var y = 2; y <= 101; y++)
{
    var result = new PersonValidationResult { Row = y };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{y}:E{y}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string) cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
''' Edit Cell Values in Range
''' *
 ' Iterate through the rows
For y = 2 To 101
	Dim result = New PersonValidationResult With {.Row = y}
	results.Add(result)

	' Get all cells for the person
	Dim cells = worksheet($"A{y}:E{y}").ToList()

	' Validate the phone number (1 = B)
	Dim phoneNumber = cells(1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	' Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells(3).Value))

	' Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells(4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next y

Valider les données dans les feuilles de calcul

Pour valider une feuille de données, utilisez IronXL. L'exemple DataValidation valide les numéros de téléphone avec libphonenumber-CSharp, et les adresses e-mail et les dates avec les API C# classiques.

/**
 Validate Spreadsheet Data
 **/
 // Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{i}:E{i}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

/**
 Validate Spreadsheet Data
 **/
 // Iterate through the rows
for (var i = 2; i <= 101; i++)
{
    var result = new PersonValidationResult { Row = i };
    results.Add(result);

    // Get all cells for the person
    var cells = worksheet[$"A{i}:E{i}"].ToList();

    // Validate the phone number (1 = B)
    var phoneNumber = cells[1].Value;
    result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, (string)phoneNumber);

    // Validate the email address (3 = D)
    result.EmailErrorMessage = ValidateEmailAddress((string)cells[3].Value);

    // Get the raw date in the format of Month Day [suffix], Year (4 = E)
    var rawDate = (string)cells[4].Value;
    result.DateErrorMessage = ValidateDate(rawDate);
}

'''
''' Validate Spreadsheet Data
''' *
 ' Iterate through the rows
For i = 2 To 101
	Dim result = New PersonValidationResult With {.Row = i}
	results.Add(result)

	' Get all cells for the person
	Dim cells = worksheet($"A{i}:E{i}").ToList()

	' Validate the phone number (1 = B)
	Dim phoneNumber = cells(1).Value
	result.PhoneNumberErrorMessage = ValidatePhoneNumber(phoneNumberUtil, CStr(phoneNumber))

	' Validate the email address (3 = D)
	result.EmailErrorMessage = ValidateEmailAddress(CStr(cells(3).Value))

	' Get the raw date in the format of Month Day [suffix], Year (4 = E)
	Dim rawDate = CStr(cells(4).Value)
	result.DateErrorMessage = ValidateDate(rawDate)
Next i

Le code ci-dessus parcourt les lignes de la feuille de calcul et récupère les cellules sous forme de liste. Chaque méthode de validation vérifie la valeur d'une cellule et renvoie une erreur si la valeur est incorrecte.

Ce code crée une nouvelle feuille, spécifie les en-têtes et génère les messages d'erreur afin de permettre la conservation d'un journal de données incorrect.

var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results[i];
    resultsSheet[$"A{i + 2}"].Value = result.Row;
    resultsSheet[$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet[$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet[$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");

var resultsSheet = workbook.CreateWorkSheet("Results");

resultsSheet["A1"].Value = "Row";
resultsSheet["B1"].Value = "Valid";
resultsSheet["C1"].Value = "Phone Error";
resultsSheet["D1"].Value = "Email Error";
resultsSheet["E1"].Value = "Date Error";

for (var i = 0; i < results.Count; i++)
{
    var result = results[i];
    resultsSheet[$"A{i + 2}"].Value = result.Row;
    resultsSheet[$"B{i + 2}"].Value = result.IsValid ? "Yes" : "No";
    resultsSheet[$"C{i + 2}"].Value = result.PhoneNumberErrorMessage;
    resultsSheet[$"D{i + 2}"].Value = result.EmailErrorMessage;
    resultsSheet[$"E{i + 2}"].Value = result.DateErrorMessage;
}

workbook.SaveAs(@"Spreadsheets\\PeopleValidated.xlsx");

Dim resultsSheet = workbook.CreateWorkSheet("Results")

resultsSheet("A1").Value = "Row"
resultsSheet("B1").Value = "Valid"
resultsSheet("C1").Value = "Phone Error"
resultsSheet("D1").Value = "Email Error"
resultsSheet("E1").Value = "Date Error"

For i = 0 To results.Count - 1
	Dim result = results(i)
	resultsSheet($"A{i + 2}").Value = result.Row
	resultsSheet($"B{i + 2}").Value = If(result.IsValid, "Yes", "No")
	resultsSheet($"C{i + 2}").Value = result.PhoneNumberErrorMessage
	resultsSheet($"D{i + 2}").Value = result.EmailErrorMessage
	resultsSheet($"E{i + 2}").Value = result.DateErrorMessage
Next i

workbook.SaveAs("Spreadsheets\\PeopleValidated.xlsx")

Utilisation d'Entity Framework pour exporter des données

Utilisez IronXL pour convertir une feuille de calcul Excel en base de données ou pour exporter des données vers une base de données. L'exemple ExcelToDB lit une feuille de calcul contenant le PIB par pays et l'exporte vers SQLite.

Il crée la base de données avec EntityFramework puis exporte les données ligne par ligne.

Les packages NuGet SQLite Entity Framework doivent être installés.

Vous pouvez utiliser Entity Framework pour construire un objet modèle capable d'exporter des données vers une base de données.

public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}

public class Country
{
    [Key]
    public Guid Key { get; set; }
    public string Name { get; set; }
    public decimal GDP { get; set; }
}

Public Class Country
	<Key>
	Public Property Key() As Guid
	Public Property Name() As String
	Public Property GDP() As Decimal
End Class

Pour utiliser une autre base de données, installez le package NuGet approprié et recherchez l'équivalent UseSqLite ( UseMySQL , UseSqlServer , etc.).

/**
 Export Data using Entity Framework
 **/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        // TODO: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        // Create the database if it doesn't already exist
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }
}

/**
 Export Data using Entity Framework
 **/
public class CountryContext : DbContext
{
    public DbSet<Country> Countries { get; set; }

    public CountryContext()
    {
        // TODO: Make async
        Database.EnsureCreated();
    }

    /// <summary>
    /// Configure context to use Sqlite
    /// </summary>
    /// <param name="optionsBuilder"></param>
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connection = new SqliteConnection($"Data Source=Country.db");
        connection.Open();

        var command = connection.CreateCommand();

        // Create the database if it doesn't already exist
        command.CommandText = $"PRAGMA foreign_keys = ON;";
        command.ExecuteNonQuery();

        optionsBuilder.UseSqlite(connection);

        base.OnConfiguring(optionsBuilder);
    }
}

'''
''' Export Data using Entity Framework
''' *
Public Class CountryContext
	Inherits DbContext

	Public Property Countries() As DbSet(Of Country)

	Public Sub New()
		' TODO: Make async
		Database.EnsureCreated()
	End Sub

	''' <summary>
	''' Configure context to use Sqlite
	''' </summary>
	''' <param name="optionsBuilder"></param>
	Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
		Dim connection = New SqliteConnection($"Data Source=Country.db")
		connection.Open()

		Dim command = connection.CreateCommand()

		' Create the database if it doesn't already exist
		command.CommandText = $"PRAGMA foreign_keys = ON;"
		command.ExecuteNonQuery()

		optionsBuilder.UseSqlite(connection)

		MyBase.OnConfiguring(optionsBuilder)
	End Sub
End Class

Produisez un CountryContext , puis parcourez la plage pour créer chaque entrée avant d'enregistrer les données dans la base de données avec SaveChangesAsync .

public async Task ProcessAsync()
{
    // Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    // Create the database connection
    using (var countryContext = new CountryContext())
    {
        // Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            // Get the range from A-B
            var range = worksheet[$"A{i}:B{i}"].ToList();

            // Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range[0].Value,
                GDP = (decimal)(double)range[1].Value
            };

            // Add the entity
            await countryContext.Countries.AddAsync(country);
        }

        // Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

public async Task ProcessAsync()
{
    // Get the first worksheet
    var workbook = WorkBook.Load(@"Spreadsheets\\GDP.xlsx");
    var worksheet = workbook.GetWorkSheet("GDPByCountry");

    // Create the database connection
    using (var countryContext = new CountryContext())
    {
        // Iterate through all the cells
        for (var i = 2; i <= 213; i++)
        {
            // Get the range from A-B
            var range = worksheet[$"A{i}:B{i}"].ToList();

            // Create a Country entity to be saved to the database
            var country = new Country
            {
                Name = (string)range[0].Value,
                GDP = (decimal)(double)range[1].Value
            };

            // Add the entity
            await countryContext.Countries.AddAsync(country);
        }

        // Commit changes to the database
        await countryContext.SaveChangesAsync();
    }
}

Public Async Function ProcessAsync() As Task
	' Get the first worksheet
	Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")
	Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

	' Create the database connection
	Using countryContext As New CountryContext()
		' Iterate through all the cells
		For i = 2 To 213
			' Get the range from A-B
			Dim range = worksheet($"A{i}:B{i}").ToList()

			' Create a Country entity to be saved to the database
			Dim country As New Country With {
				.Name = CStr(range(0).Value),
				.GDP = CDec(CDbl(range(1).Value))
			}

			' Add the entity
			Await countryContext.Countries.AddAsync(country)
		Next i

		' Commit changes to the database
		Await countryContext.SaveChangesAsync()
	End Using
End Function

Intégrer une formule dans une feuille de calcul

La propriété Formula permet de définir la formule d'une cellule.

// Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    // Get the C cell
    var cell = sheet[$"C{y}"].First();

    // Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

// Iterate through all rows with a value
for (var y = 2; y < i; y++)
{
    // Get the C cell
    var cell = sheet[$"C{y}"].First();

    // Set the formula for the Percentage of Total column
    cell.Formula = $"=B{y}/B{i}";
}

' Iterate through all rows with a value
Dim y = 2
Do While y < i
	' Get the C cell
	Dim cell = sheet($"C{y}").First()

	' Set the formula for the Percentage of Total column
	cell.Formula = $"=B{y}/B{i}"
	y += 1
Loop

Le code de la colonne C parcourt chaque état et calcule un total en pourcentage.

Les données d'une API peuvent être téléchargées dans une feuille de calcul.

RestClient.Net est utilisé dans l'appel suivant pour effectuer un appel REST. Il télécharge le JSON et le transforme en une " liste " de type RestCountry. Les données de l'API REST peuvent ensuite être facilement enregistrées dans un fichier Excel en parcourant chaque pays.

/**
 Data API to Spreadsheet
 **/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();

/**
 Data API to Spreadsheet
 **/
var client = new Client(new Uri("https://restcountries.eu/rest/v2/"));
List<RestCountry> countries = await client.GetAsync<List<RestCountry>>();

'''
''' Data API to Spreadsheet
''' *
Dim client As New Client(New Uri("https://restcountries.eu/rest/v2/"))
Dim countries As List(Of RestCountry) = Await client.GetAsync(Of List(Of RestCountry))()

Les données JSON renvoyées par l'API se présentent comme suit :

Le code suivant parcourt les pays et remplit la feuille de calcul avec le nom, la population, la région, le code numérique et les 3 langues les plus parlées.

for (var i = 2; i < countries.Count; i++)
{
    var country = countries[i];

    // Set the basic values
    worksheet[$"A{i}"].Value = country.name;
    worksheet[$"B{i}"].Value = country.population;
    worksheet[$"G{i}"].Value = country.region;
    worksheet[$"H{i}"].Value = country.numericCode;

    // Iterate through languages
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages[x];

        // Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        // Set the language name
        worksheet[$"{columnLetter}{i}"].Value = language.name;
    }
}

for (var i = 2; i < countries.Count; i++)
{
    var country = countries[i];

    // Set the basic values
    worksheet[$"A{i}"].Value = country.name;
    worksheet[$"B{i}"].Value = country.population;
    worksheet[$"G{i}"].Value = country.region;
    worksheet[$"H{i}"].Value = country.numericCode;

    // Iterate through languages
    for (var x = 0; x < 3; x++)
    {
        if (x > (country.languages.Count - 1)) break;

        var language = country.languages[x];

        // Get the letter for the column
        var columnLetter = GetColumnLetter(4 + x);

        // Set the language name
        worksheet[$"{columnLetter}{i}"].Value = language.name;
    }
}

For i = 2 To countries.Count - 1
	Dim country = countries(i)

	' Set the basic values
	worksheet($"A{i}").Value = country.name
	worksheet($"B{i}").Value = country.population
	worksheet($"G{i}").Value = country.region
	worksheet($"H{i}").Value = country.numericCode

	' Iterate through languages
	For x = 0 To 2
		If x > (country.languages.Count - 1) Then
			Exit For
		End If

		Dim language = country.languages(x)

		' Get the letter for the column
		Dim columnLetter = GetColumnLetter(4 + x)

		' Set the language name
		worksheet($"{columnLetter}{i}").Value = language.name
	Next x
Next i

Ouvrir des fichiers Excel avec IronXL

Après avoir ouvert le fichier Excel, ajoutez les premières lignes qui lisent la première cellule de la première feuille, puis imprimez.

static void Main(string[] args)
{
    var workbook = IronXL.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet["A1"].StringValue;
    Console.WriteLine(cell);
}

static void Main(string[] args)
{
    var workbook = IronXL.WorkBook.Load($@"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx");
    var sheet = workbook.WorkSheets.First();
    var cell = sheet["A1"].StringValue;
    Console.WriteLine(cell);
}

Shared Sub Main(ByVal args() As String)
	Dim workbook = IronXL.WorkBook.Load($"{Directory.GetCurrentDirectory()}\Files\HelloWorld.xlsx")
	Dim sheet = workbook.WorkSheets.First()
	Dim cell = sheet("A1").StringValue
	Console.WriteLine(cell)
End Sub

À l'aide d'IronXL, créez un nouveau fichier Excel.

/**
 Create Excel File
 **/
static void Main(string[] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet["A1"].Value = "Hello World";
    newWorkSheet["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Dashed;
}

/**
 Create Excel File
 **/
static void Main(string[] args)
{
    var newXLFile = WorkBook.Create(ExcelFileFormat.XLSX);
    newXLFile.Metadata.Title = "IronXL New File";
    var newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet");
    newWorkSheet["A1"].Value = "Hello World";
    newWorkSheet["A2"].Style.BottomBorder.SetColor("#ff6600");
    newWorkSheet["A2"].Style.BottomBorder.Type = IronXL.Styles.BorderType.Dashed;
}

'''
''' Create Excel File
''' *
Shared Sub Main(ByVal args() As String)
	Dim newXLFile = WorkBook.Create(ExcelFileFormat.XLSX)
	newXLFile.Metadata.Title = "IronXL New File"
	Dim newWorkSheet = newXLFile.CreateWorkSheet("1stWorkSheet")
	newWorkSheet("A1").Value = "Hello World"
	newWorkSheet("A2").Style.BottomBorder.SetColor("#ff6600")
	newWorkSheet("A2").Style.BottomBorder.Type = IronXL.Styles.BorderType.Dashed
End Sub

Ensuite, vous pouvez enregistrer les données au format CSV, JSON ou XML en utilisant leurs codes respectifs.

Par exemple, pour enregistrer au format XML .xml

Pour enregistrer au format XML, utilisez SaveAsXml comme suit :

newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");

newXLFile.SaveAsXml($@"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML");

newXLFile.SaveAsXml($"{Directory.GetCurrentDirectory()}\Files\HelloWorldXML.XML")

Le résultat ressemble à ceci :

<?xml version="1.0" standalone="yes"?>
<_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Hello World</Column1>
  </_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
  </_x0031_stWorkSheet>
</_x0031_stWorkSheet>

<?xml version="1.0" standalone="yes"?>
<_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Hello World</Column1>
  </_x0031_stWorkSheet>
  <_x0031_stWorkSheet>
    <Column1 xsi:type="xs:string" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" />
  </_x0031_stWorkSheet>
</_x0031_stWorkSheet>

La lecture des fichiers Excel est plus facile avec IronXL qu'avec EPPlus. IronXL dispose de codes plus courts qui englobent tout ce qui est nécessaire pour accéder à toutes les colonnes, lignes et cellules d'un classeur, tandis qu'avec EPPlus, vous aurez besoin d'une ligne de code spécifique pour lire les colonnes et les lignes.

IronXL est plus intelligent lorsqu'il s'agit de manipuler des documents Excel. Il vous permet de créer plusieurs feuilles de calcul simultanément et de lire des données provenant de plusieurs feuilles et classeurs, contrairement à EPPlus qui ne traite qu'une seule feuille à la fois. Avec IronXL, vous pouvez également alimenter une base de données avec les données de votre classeur Excel.

Licences et tarifs EPPlus et IronXL

Conclusion

En conclusion, IronXL est plus pratique qu'EPPlus car il offre la flexibilité nécessaire pour naviguer dans le tableau Excel selon vos besoins, avec des lignes de code plus courtes et davantage de possibilités d'exportation, notamment XML, HTML et JSON. IronXL vous permet également d'intégrer les données de votre classeur dans une base de données. De plus, il dispose d'un système intuitif qui recalcule les formules à chaque modification du document, et il offre un paramètre de plages intuitives avec une syntaxe WorkSheet["A1:B10"]. Les fonctions de la feuille incluent des formules compatibles avec Excel et recalculées à chaque modification de la feuille. Les formats de données des cellules comprennent divers types de texte, nombres, formules, dates, devises, pourcentages, notation scientifique et heures. Leurs formats personnalisés offrent différentes méthodes de tri, telles que les plages, les colonnes et les lignes. Son style de cellule comprend une variété de polices, de tailles, de motifs d'arrière-plan, de bordures et d'alignements.