Comparaison entre IronXL et Epplus

Dans cet article, nous examinons les similitudes et les différences entre les logiciels IronXL et EPPlus.

Pour la plupart des organisations, Microsoft Excel s'est avéré être un outil extrêmement utile. Les fichiers Excel, comme les bases de données, contiennent des données dans des cellules, ce qui facilite tout simplement la gestion des données à stocker.

Les formats de fichiers .xls et .xlsx sont également utilisés par Excel. Le langage C# peut rendre difficile la gestion des fichiers Excel. Toutefois, les logiciels IronXL et EPPlus facilitent la gestion de ces processus.

L'utilisation de ce logiciel ne nécessite pas l'utilisation de Microsoft Office.

Veuillez noter que vous pouvez lire et créer des fichiers Excel en C# sans devoir installer Microsoft Office. Aujourd'hui, nous allons examiner différentes options faciles à mettre en œuvre.

Qu'est-ce que le logiciel EPPlus ?

EPPlus est une bibliothèque .NET Framework/.NET Core basée sur NuGet pour la manipulation des feuilles de calcul Office Open XML. La version 5 prend en charge le Framework .NET 3.5 et .NET Core 2.0. EPPlus ne dépend d'aucune autre bibliothèque, telle que Microsoft Excel.

EPPlus dispose d'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 paquetage à partir de NuGet.

La bibliothèque a été créée à l'intention des programmeurs. L'objectif a toujours été qu'un développeur familier d'Excel ou d'une autre bibliothèque de feuilles de calcul puisse apprendre rapidement l'API. Ou encore, comme l'a dit quelqu'un, "IntelliSense your way to victory" ("IntelliSense pour la victoire")!"

Installation d'EPPlus

Pour installer EPPlus à partir de Visual Studio, allez dans View > Other Windows > Package Manager Console et tapez la commande suivante :

PM> Installer le paquet EPPlus

Si vous préférez utiliser l'interface de programmation .NET, exécutez la commande suivante à partir d'une invite de commande élevée ou d'une invite PowerShell :

PM> dotnet add package EPPlus

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

Qu'est-ce qu'IronXL ?

IronXL est une API Excel C# et VB simple qui vous permet de lire, d'éditer et de créer des fichiers de feuilles de calcul Excel en .NET à la vitesse de l'éclair. Il n'est pas nécessaire d'installer Microsoft Office ou même Excel Interop. Cette bibliothèque peut également être utilisée pour travailler avec des fichiers Excel.

.NET Core, .NET Framework, Xamarin, Mobile, Linux, macOS et Azure sont tous pris en charge par IronXL.

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

Ajout d'IronXL à l'aide d'un paquet NuGet

Nous pouvons ajouter l'offre IronXL à votre compte de trois manières différentes, afin que vous puissiez choisir celle qui vous convient le mieux.

• Utilisation de la console du gestionnaire de paquets pour installer IronXL

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

  Pour accéder à la console du gestionnaire de paquets, cliquez sur Outils => NuGet Package Manager => Console du gestionnaire de paquets.

  

  Vous accédez alors à la console du gestionnaire de paquets. Ensuite, dans le terminal du Gestionnaire de paquets, tapez la commande suivante :

PM > Installer le paquet IronXL.Excel

• Utilisation du gestionnaire de paquets NuGet pour installer IronXL

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

  Pour accéder au gestionnaire de paquets NuGet, cliquez sur Outils > NuGet Package Manager => Sélectionnez Gérer les paquets 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 aller sur votre formulaire et commencer à le développer.

Création d'un fichier Excel avec IronXL

Créer un nouveau classeur Excel avec IronXL ne pourrait pas être plus facile! Il ne s'agit que d'une seule ligne de code! Oui, c'est vrai :

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

IronXL peut créer des fichiers en XLS(la version antérieure du fichier Excel) et XLSX(la version actuelle et la plus récente du fichier Excel) formats.

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

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

  var sheet = workbook.CreateWorkSheet("Budget 2020");

  La feuille de calcul est représentée par "Sheet" dans l'extrait de code ci-dessus, et vous pouvez l'utiliser pour définir les valeurs des cellules et faire pratiquement tout ce qu'Excel peut faire. Vous pouvez également coder 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 classeur et une feuille de calcul au cas où vous ne seriez pas sûr.

  Les feuilles de travail sont contenues dans un classeur. Cela signifie que vous pouvez placer autant de feuilles de travail que vous le souhaitez à l'intérieur d'un classeur. Je vous expliquerai comment procéder dans un prochain article. Une feuille de calcul se compose de lignes et de colonnes. L'intersection d'une ligne et d'une colonne est appelée cellule, et c'est avec elle 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 croisement dynamique, et même le formatage conditionnel et la modification des polices. Sans plus attendre, voici le code source complet permettant de convertir un tableau de données normal en un fichier Excel XLSX et de l'envoyer à l'utilisateur pour qu'il le télécharge :

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 cols 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 colum names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows to 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 cols 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 colum names
            row = 1;
            col = 0;
            foreach (DataColumn dc in dt.Columns)
            {
                col++;
                ws.SetValue(row, col, dc.ColumnName);
            }

            // Insert the DataTable rows to 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 cols 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 colum 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 to 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, copiez simplement le contenu de la méthode et collez-le là où vous en avez besoin(aSP.NET classique, application console, Windows Forms, etc).

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

• En utilisant une méthode personnalisée du fournisseur de données, nous obtenons un objet DataTable.
• Nous construisons un objet ExcelPackage, qui est le conteneur principal d'EPPlus pour le fichier XLSX.
• Nous ajoutons une feuille de calcul Excel au paquet Excel, qui sera la feuille de calcul dans laquelle les données seront saisies.
• Pour créer notre ligne d'en-tête, nous itérons les colonnes du tableau de données, en les ajoutant à la première ligne de notre feuille de calcul.
• Nous parcourons les lignes du tableau de données, en ajoutant chacune d'entre elles à notre feuille de calcul, ligne par ligne(en commençant par le rang 2) de sorte que chaque ligne du tableau de données corresponde à une ligne de la feuille de calcul.
• Nous créons un MemoryStream pour stocker les données binaires du paquet Excel lorsque la conversion de DataTable en paquet Excel est terminée, puis nous les convertissons en tableau d'octets.

• Nous créons la réponse HTML et envoyons le fichier XLSX à l'utilisateur avec une pièce jointe Content-Disposition, de sorte que le navigateur télécharge automatiquement le fichier.

  IronXL l'emporte dans ce cas parce que le processus de création est très facile - il suffit d'une ligne de code et le tour est joué ; cela permet de gagner du temps et de faciliter le débogage, alors qu'EPPlus propose des lignes de code ennuyeuses à parcourir et difficiles à déboguer.

Comment EPPlus Software AB écrit les fichiers Excel

EPPlus permet de travailler avec des fichiers Excel. Il s'agit d'une bibliothèque .NET qui lit et écrit des fichiers Excel.

• Lecture de fichiers Excel

  Pour ce faire, vous devez d'abord installer le paquet EPPlus : allez dans "Tools"-> "NuGet package manager"-> "Manage NuGet for this solution" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> "Install EPPlus" -> Install EP Recherchez "EPPlus" dans l'onglet "Browse", puis installez le paquet NuGet.

  

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

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 exemple de fichier Excel(.xlsx) avec lesquels nous travaillons. Voici un fichier xlsx à lire en C# à l'aide d'EPPlus.

La propriété "cells" permet d'accéder aux méthodes suivantes pour charger des données à partir de sources multiples(Plage Excel):

• 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 table de données dans une plage. Il peut importer des données à partir d'une variété de sources, y compris XML(un exemple est fourni) et des bases de données.
• LoadFromCollection - charge de manière réfléchie les données d'un IEnumerable dans une plage.
• LoadFromCollection with attributes - charge de manière réfléchie les données d'un IEnumerable dans une plage ou un tableau. Les styles, formats de nombres, formules et autres propriétés sont spécifiés par le biais d'attributs.
• LoadFromDictionaries - charge des données à partir d'un IEnumerable d'objets ExpandoObject/dynamiques(par le biais de leur interface IDictionarystring, object>) dans une fourchette. Cette fonction 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.

  Lorsque vous utilisez ces méthodes, vous pouvez éventuellement donner un paramètre pour générer un tableau Excel. Les échantillons 4 et 5 du projet Sample-.NET Framework ou Sample-.NET Framework contiennent des exemples plus complets.

• **Rédaction de fichiers Excel

  Voyons ensuite si nous pouvons exporter des données vers un nouveau fichier Excel.

  Voici quelques exemples de données/objets que nous aimerions enregistrer sous forme de 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 avec les informations essentielles, nous devons utiliser la classe ExcelPackage. L'écriture de données dans un fichier et la production d'une nouvelle feuille de calcul Excel ne nécessitent que quelques lignes de code. Veuillez noter la ligne ci-dessous qui réalise la magie du chargement des tableaux de données dans une feuille Excel.

Pour simplifier les choses, je génère un nouveau fichier de feuille de calcul dans le même dossier de projet(le fichier Excel sera produit 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

À la suite de l'appel API susmentionné pour la validation des données, un nouveau fichier Excel sera créé avec la transformation de l'objet personnalisé ci-dessus dans les colonnes et les lignes Excel appropriées, afin d'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 la logique peut être modifiée en fonction de vos besoins.

Ces techniques sont accessibles à l'aide de la propriété "cells"(Plage Excel):

• ToText et ToTextAsync - crée 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.Data. Tableau de données
• GetValueT> - 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. (Les résultats seront légèrement meilleurs que ceux obtenus en lisant/écrivant sur l'aire de jeu):

• GetValueT> - obtient 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 les données d'une feuille de calcul car la propriété cell implémente l'interface IEnumerable.

Ouvrez et écrivez le format XLSX d'Office Open XML 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 d'autres fichiers de feuilles de calcul.

Office Interop n'est pas nécessaire. Il n'y a pas de dépendance particulière ni de nécessité d'installer Microsoft Office sur Core ou Azure.

IronXL est une bibliothèque de feuilles de calcul xl renommée en C# et VB.NET pour .NET core et .NET framework.

• Lecture de 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. Charger le fichier Excel et choisir son emplacement(.xlsx).

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

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

'''
'''Load WorkBook
'''anchor-load-a-workbook
'''*
Dim workbook = WorkBook.Load("Spreadsheets\\GDP.xlsx")

Les objets Feuille de travail se retrouvent dans de nombreux WorkBooks. Il s'agit des feuilles de calcul du document Excel. Si la feuille contient des feuilles de travail, utilisez le nom WorkBook pour les trouver. Feuille de travail.

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

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

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

• Faites votre propre cahier d'exercices.

  Construire un nouveau livre de travail avec le type de feuille pour générer un nouveau livre de travail en mémoire.

/**
Create WorkBook
anchor-create-a-workbook
**/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

/**
Create WorkBook
anchor-create-a-workbook
**/
var workbook = new WorkBook(ExcelFileFormat.XLSX);

'''
'''Create WorkBook
'''anchor-create-a-workbook
'''*
Dim workbook As New WorkBook(ExcelFileFormat.XLSX)

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

**Faites une fiche de travail si vous n'en avez pas déjà une

Chaque "WorkBook" peut contenir de nombreuses fiches de travail Une "WorkSheet" est une feuille de données unique, tandis qu'un "WorkBook" est une collection de WorkSheets. Dans Excel, voici à quoi ressemble un classeur avec deux feuilles de calcul.

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

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

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

Dim worksheet = workbook.CreateWorkSheet("Countries")

Transmettre le nom de la feuille de calcul à CreateWorkSheet.

Obtenir la portée cellulaire

Une collection bidimensionnelle d'objets "Cellule" est représentée par la classe "Plage". Il désigne une plage spécifique de cellules Excel. En utilisant l'indexeur de chaînes de caractères sur un objet Feuille de travail, vous pouvez obtenir des plages.

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

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

Dim range = worksheet ("D2:D101")

L'argument texte peut être les coordonnées d'une cellule(par exemple, "A1") ou une série de cellules de gauche à droite, de haut en bas(par exemple "B2:E5"). GetRange peut également être appelé à partir d'une feuille de travail.

• Dans une plage, modifier les valeurs des cellules

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

/**
Edit Cell Values in Range
anchor-edit-cell-values-within-a-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
anchor-edit-cell-values-within-a-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
'''anchor-edit-cell-values-within-a-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 électroniques et les dates avec les API C# conventionnelles.

/**
Validate Spreadsheet Data
anchor-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
anchor-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
'''anchor-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 en boucle les lignes de la feuille de calcul, en saisissant les cellules sous forme de liste. Chaque méthode validée 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 produit les résultats du message d'erreur de manière à ce qu'un journal de données incorrect puisse être conservé.

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

Utiliser 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 et exporte ensuite les données ligne par ligne.

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

Vous pouvez utiliser EntityFramework pour construire un objet modèle qui peut 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 paquet NuGet approprié et recherchez l'équivalent UseSqLite().

/**
Export Data using Entity Framework
anchor-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
anchor-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
'''anchor-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

Produire un CountryContext, puis itérer dans la plage pour créer chaque entrée avant d'enregistrer les données dans la base de données avec SaveAsync.

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

Incorporer une formule dans une feuille de calcul

La propriété Formule 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 pourcentage total.

**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 JSON et le transforme en une "liste" de type RestCountry Les données de l'API REST peuvent ensuite être facilement sauvegardées dans un fichier Excel en parcourant chaque pays.

/**
Data API to Spreadsheet
anchor-download-data-from-an-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
anchor-download-data-from-an-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
'''anchor-download-data-from-an-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 provenant de l'API ressemblent à ceci :

Le code suivant parcourt les pays en boucle et remplit la feuille de calcul avec le nom, la population, la région, le code numérique et les trois principales langues.

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 lancé le fichier Excel, ajoutez les premières lignes qui lisent la 1ère cellule de la 1ère feuille, et 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
anchor-create-a-new-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
anchor-create-a-new-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
'''anchor-create-a-new-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 au format CSV, JSON ou XML à l'aide de 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 est le suivant :

<?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, alors 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 plus de feuilles à tout moment, ainsi que de lire des données provenant de plusieurs feuilles de calcul et de plusieurs classeurs, alors qu'EPPlus ne traite qu'une feuille de calcul à la fois. Avec IronXL, vous pouvez également remplir une base de données avec les données de votre classeur Excel.

Licences et prix d'EPPlus et d'IronXL

Modèle de licence et prix d'EPPlus

EPPlus peut être utilisé sous deux modèles de licence, soit un modèle de licence non commerciale, soit un modèle de licence commerciale de Polyform.

**Licences commerciales

Ils sont disponibles sous forme de contrats à durée indéterminée ou d'abonnements, pour des durées allant d'un mois à deux ans.

Pour toutes les catégories de licences, le support via le centre de support et les mises à jour via NuGet sont inclus pendant la durée de la licence.

EPPlus nécessite une licence par développeur. Les licences sont délivrées à une seule personne et ne peuvent être partagées. En règle générale, toute personne qui produit ou doit déboguer un code qui utilise directement EPPlus devrait avoir une licence commerciale.

Si vous fournissez EPPlus en tant que service interne(par exemple, en exposant ses capacités via une API)votre entreprise doit acheter un abonnement qui couvre le nombre d'utilisateurs internes(développeurs) qui utiliseront le service.

Abonnements

Vous pouvez toujours utiliser la dernière version avec un abonnement, mais vous devez avoir une licence valide tant que vous utilisez EPPlus pour le développement. À la fin de la période de licence, la licence est automatiquement facturée et renouvelée une fois le paiement effectué. Vous pouvez résilier votre abonnement à la fin de la période de licence et en commencer un nouveau quand vous le souhaitez. Les abonnements ne peuvent être achetés que sur l'internet.

EPPlus peut être utilisé dans un cadre commercial. La licence est valable pour un développeur par entreprise, avec un nombre illimité de lieux de déploiement. Le nombre de licences disponibles à l'achat chaque année peut être augmenté ou réduit, et la licence peut être suspendue ou annulée à la fin de chaque année.

Une période d'essai de 32 jours est disponible en option.

Tarification: À partir de 299 $ par an.

Vous pouvez payer au fur et à mesure

Prix par développeur au sein d'une même organisation, avec un nombre illimité de lieux de déploiement et une facturation Stripe. Le nombre de licences disponibles chaque mois peut être augmenté ou réduit, et la licence peut être suspendue ou annulée à la fin de chaque mois.

Tarification: A partir de 29 $ par mois.

**Licence perpétuelle

Une licence perpétuelle vous permet de mettre à jour les nouvelles versions et de bénéficier d'une assistance pendant une période déterminée. Vous pouvez ensuite continuer à développer des logiciels en utilisant les versions publiées pendant cette période sans avoir à renouveler votre licence.

Au sein d'une même entreprise, prix par développeur avec un nombre illimité de sites de déploiement. Utilisation indéfinie de toutes les versions d'EPPlus publiées dans le cadre de la période d'assistance/mise à jour.

Une période d'essai de 32 jours est disponible en option.

Tarification: À partir de 599 $ par an.

Packages

Des options de licence perpétuelle avec une durée initiale de mises à jour et d'assistance sont disponibles. Vous pouvez alors continuer à développer des logiciels en utilisant les versions publiées au cours de cette période sans avoir à renouveler votre licence.

Tarification: À partir de 4295 $ par an.

Licence non commerciale pour Polyform

EPPlus est soumis à la licence Polyform Noncommercial à partir de la version 5, ce qui indique que le code est libre et peut être utilisé à des fins non commerciales. Vous trouverez plus de détails sur leur site web.

Modèle de licence et prix d'IronXL

Licence perpétuelle: chaque licence est achetée une fois et ne nécessite pas de renouvellement.

Support gratuit et mises à jour du produit : chaque licence est accompagnée d'un an de mises à jour gratuites du produit et de support de la part de l'équipe à l'origine du produit. Il est possible d'acheter des extensions à tout moment. Les extensions peuvent être visualisées.

Licences immédiates : les clés de licence enregistrées sont envoyées dès réception du paiement.

Veuillez contacter nos spécialistes des licences Iron Software si vous avez des questions sur les licences IronXL for .NET.

Toutes les licences sont perpétuelles et s'appliquent au développement, à la mise en place et à la production.

Lite - Permet à un seul développeur de logiciels au sein d'une organisation d'utiliser le Iron Software en un seul endroit. Iron Software peut être utilisé dans une seule application web, une application intranet ou un logiciel de bureau. Les licences ne sont pas transférables et ne peuvent être partagées en dehors d'une organisation ou d'une relation agence/client. Ce type de licence, comme tous les autres types de licence, exclut expressément tous les droits qui ne sont pas expressément accordés dans le cadre de l'accord, y compris la redistribution OEM et l'utilisation du Iron Software en tant que SaaS sans achat d'une couverture supplémentaire.

Tarification: À partir de 489 $ par an.

Licence professionnelle - Permet à un nombre prédéterminé de développeurs de logiciels d'une organisation d'utiliser le logiciel Iron Software en un seul lieu, jusqu'à un maximum de dix. Le Iron Software peut être utilisé dans autant de sites web, d'applications intranet ou de logiciels de bureau que vous le souhaitez. Les licences ne sont pas transférables et ne peuvent être partagées en dehors d'une organisation ou d'une relation agence/client. Ce type de licence, comme tous les autres types de licence, exclut expressément tous les droits qui ne sont pas expressément accordés dans le cadre de l'accord, y compris la redistribution OEM et l'utilisation du logiciel Iron Software en tant que SaaS sans achat d'une couverture supplémentaire.

Tarification: A partir de 976 $ par an.

License Unlimited - Permet à un nombre illimité de développeurs de logiciels au sein d'une organisation d'utiliser Iron Software dans un nombre illimité de sites. Le Iron Software peut être utilisé dans autant de sites web, d'applications intranet ou de logiciels de bureau que vous le souhaitez. Les licences ne sont pas transférables et ne peuvent être partagées en dehors d'une organisation ou d'une relation agence/client. Ce type de licence, comme tous les autres types de licence, exclut expressément tous les droits qui ne sont pas expressément accordés dans le cadre de l'accord, y compris la redistribution OEM et l'utilisation du logiciel Iron Software en tant que SaaS sans achat d'une couverture supplémentaire.

Royalty-Free Redistribution - Vous permet de distribuer le Iron Software dans le cadre d'un certain nombre de produits commerciaux différents(sans avoir à payer de redevances) en fonction du nombre de projets couverts par la licence de base. Permet le déploiement d'Iron Software dans le cadre de services logiciels SaaS, en fonction du nombre de projets couverts par la licence de base.

Tarification: À partir de 2939 $ par an.

Conclusion

En conclusion, IronXL est plus pratique qu'EPPlus car il vous donne la flexibilité de naviguer dans le tableau Excel comme vous le souhaitez, avec des lignes de codes plus courtes et plus 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. En outre, il dispose d'un système intuitif qui recalcule les formules à chaque fois que le document est édité, et il fournit un paramètre de plages intuitives avec une feuille de travail["A1:B10] syntaxe. Les fonctions de la feuille comprennent des formules qui fonctionnent avec Excel et sont recalculées chaque fois qu'une feuille est éditée. Les formats de données des cellules comprennent plusieurs textes, nombres, formules, dates, devises, pourcentages, notation scientifique et heure. Leurs formats personnalisés ont différentes méthodes de tri telles que les plages, les colonnes et les lignes. Le style des cellules comprend une variété de polices, de tailles, de motifs d'arrière-plan, de bordures et d'alignements.