IronXL et EPPlussont tous deux des bibliothèques Excel .NET qui lisent et créent des fichiers .xls et .xlsx sans nécessiter Microsoft Office ou Interop. Cette comparaison couvre leurs APIs, formats pris en charge et licences — avec des exemples de code pour les opérations les plus couramment utilisées dans les applications .NET.

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. EPPlusne 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. EPPlusest 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 EPPlusdepuis 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 .NET que vous pouvez ajouter à votre projet.

Qu'est-ce qu'IronXL ?

IronXL est une API Excel pour C# et VB qui permet de lire, modifier et créer des fichiers de tableur Excel en .NET sans installer Microsoft Office ni utiliser Excel Interop. La bibliothèque prend en charge nativement les formats XLS, XLSX, CSV et autres formats de tableur.

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 Package Manager, 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.

Avant de nous plonger dans les exemples de code, voici un aperçu comparatif d'EPPlus et IronXL sur les points clés abordés dans cet article :

Pour tester les opérations d'IronXL Excel par rapport à EPPlusdans votre propre projet, un essai gratuit de 30 jours est disponible.

Création d'un fichier Excel avec IronXL

Créer un nouveau classeur Excel avec IronXL ne nécessite qu'une seule ligne de code :

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

' 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 de fichier Excel) et XLSX (la version actuelle et plus récente de fichier Excel), en tirant parti de toute sa gamme de fonctionnalités 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")

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

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 et styles des cellules et faire pratiquement tout ce qu'Excel peut faire. 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 EPPlusSoftware 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 pour convertir un DataTable normal en un fichier Excel XLSX et 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

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 voir, 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 construisons un objet ExcelPackage, qui est le conteneur principal d'EPPlus pour le fichier XLSX.
• Nous ajoutons un ExcelWorksheet au ExcelPackage, qui sera la feuille de calcul où les données seront saisies.
• Pour créer notre ligne d'en-tête, nous itérons les colonnes DataTable, en les ajoutant à la première ligne de notre feuille de calcul.
• Nous itérons à travers les lignes DataTable, en ajoutant chacune à notre feuille de calcul ligne par ligne (en commençant par la ligne 2) de sorte que chaque ligne DataTable corresponde à une ligne de feuille de calcul.
• Nous construisons un MemoryStream pour stocker les données binaires ExcelPackage lorsque la conversion DataTable en ExcelPackage est terminée, puis nous la convertissons en un tableau de bytes.
• 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.

L'approche d'IronXL pour la création de classeurs nécessite une seule ligne de code par rapport à la configuration en plusieurs étapes d'EPPlus impliquant ExcelPackage, ExcelWorksheet et l'itération manuelle des cellules. Pour les équipes qui privilégient le prototypage rapide et un débogage simplifié, cette différence dans le code standard peut s'avérer importante tout au long du cycle de vie d'un projet.

Comment EPPlusSoftware AB écrit des fichiers Excel

EPPlus prend en charge le traitement des fichiers Excel. C'est 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

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 sur une feuille de calcul avec LoadFromText et LoadFromTextAsync. IronXL propose également ses propres opérations d'exportation et d'importation CSV .
• LoadFromDataReaderAsync et LoadFromDataReader — charge les champs de données d'un DataReader dans une plage.
• LoadFromTableau de données — charge les données d'un 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é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, les formats numériques, les formules et autres propriétés sont spécifiés via des attributs.
• LoadFromDictionaries — charge les données d'un IEnumerable d'objets ExpandoObject/dynamique (via leur interface IDictionary<string, object>) dans une plage. Ceci est utile pour importer des données JSON, et un exemple est inclus.
• LoadFromArrays — charge les données 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 échantillons 4 et 5 du projet échantillon Sample-.NET Framework ou Sample-.NET Framework contiennent des exemples plus étendus.

• É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"
	}
}

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 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 effectue la magie de charger 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

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.
• Écrire 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. Tableau de données**
• 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 — obtient la valeur d'une seule cellule, avec l'option 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 parce que la propriété cellule 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, for .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 lire 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")

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

Dim worksheet = workbook.GetWorkSheet("GDPByCountry")

• Créez votre propre cahier d'exercices.

Construisez un nouveau WorkBook avec le type de feuille pour générer un nouveau 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)

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

Pour les feuilles de calcul Excel Microsoft vintage, utilisez ExcelFileFormat.XLS (95 et 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'un nouveau WorkSheet que vous pouvez construire.

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

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

Dim worksheet = workbook.CreateWorkSheet("Countries")

Dim worksheet = workbook.CreateWorkSheet("Countries")

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

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 aussi être appelé depuis une feuille.

• 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

'''
''' 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 de validation de données valide les numéros de téléphone avec libphonenumber-C# et les adresses email et les dates avec des API C# conventionnelles.

/**
 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

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

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'échantillon ExcelToDB lit une feuille de calcul contenant le PIB par nation 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

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

Pour utiliser une base de données différente, 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

'''
''' 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 de sauvegarder 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

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 peut être utilisée pour 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

' 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))()

'''
''' 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

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

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

'''
''' 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

Après cela, vous pouvez enregistrer au format CSV, JSON ou XML en utilisant leurs codes respectifs, comme indiqué dans les exemples de code IronXL .

Par exemple, pour sauvegarder en XML .xml

Pour sauvegarder en 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")

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>

IronXL offre une API plus concise pour la lecture des fichiers Excel : l'accès aux colonnes, aux lignes et aux cellules d'un classeur nécessite généralement moins de lignes de code. EPPlus, en revanche, expose une API au niveau des cellules plus granulaire qui nécessite une gestion explicite des colonnes et des lignes, ce qui offre un contrôle précis mais ajoute de la verbosité.

IronXL offre une plus grande flexibilité lors de la manipulation de documents Excel. Il permet de créer des feuilles supplémentaires à tout moment, de lire des données provenant de plusieurs feuilles de calcul et classeurs dans un seul flux de travail et d'exporter les données du classeur directement vers une base de données. EPPlusaxe son API sur la manipulation de feuilles de calcul individuelles — une approche simple pour les tâches sur une seule feuille, mais qui crée des étapes d'intégration supplémentaires pour les équipes ayant besoin d'opérations inter-classeurs.

Comment EPPluset IronXL se comparent-ils en matière de licences et de prix ?

Modèle et prix de la licence 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

Ces licences sont disponibles sous forme perpétuelle ou par abonnement, avec des durées allant d'un mois à deux ans.

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

EPPlus requiert une licence par développeur. Les licences sont délivrées à une seule personne et ne peuvent être partagées. De manière générale, toute personne qui produit ou a besoin de déboguer du code utilisant directement EPPlusdevrait posséder une licence commerciale.

Si vous fournissez EPPlusen tant que service en interne (par exemple, en exposant ses fonctionnalités via une API), votre entreprise doit souscrire 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 disposer d'une licence valide tant que vous utilisez EPPluspour le développement. À la fin de la période de licence, celle-ci 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 souscrire un nouveau à tout moment. Les abonnements sont uniquement disponibles à l'achat sur internet.

EPPlus peut être utilisé dans un contexte commercial. La licence est valable pour un développeur par entreprise, avec un nombre illimité de sites de déploiement. Le nombre de licences disponibles à l'achat chaque année peut être augmenté ou diminué, 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: Commence à 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 sites de déploiement et une facturation Stripe. Le nombre de licences disponibles chaque mois peut être augmenté ou diminué, et la licence peut être suspendue ou annulée à la fin de chaque mois.

Tarification : À partir de $29 par mois.

Licence perpétuelle

Une licence perpétuelle vous permet de bénéficier des mises à jour vers les nouvelles versions et d'une assistance pendant une période déterminée. Vous pouvez ensuite continuer à développer des logiciels en utilisant les versions publiées durant 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 pendant la période de support/mises à niveau.

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

Tarification: Commence à partir de $599 par an.

Colis

Des options de licence perpétuelle avec une période initiale de mises à jour et de support sont disponibles. Vous pouvez ensuite continuer à développer des logiciels en utilisant les versions publiées pendant cette période sans avoir besoin de renouveler votre licence.

Tarification: Commence à partir de $4,295 par an.

Licence non commerciale pour Polyform

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

Modèle et prix de la licence IronXL

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

Assistance et mises à jour produit gratuites : chaque licence inclut un an de mises à jour produit gratuites et d'assistance de l'équipe à l'origine du produit. Il est possible d'acheter des extensions à tout moment. Les extensions peuvent être consulté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 concernant les licences IronXL for .NET.

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

Lite - Permet à un seul développeur de logiciels au sein d'une organisation d'utiliser le logiciel Iron à un seul endroit. Le logiciel Iron peut être utilisé dans une seule application web, application intranet ou programme logiciel de bureau. Les licences sont non transférables et ne peuvent être partagées en dehors d'une organisation ou d'une relation client/agence. Ce type de licence, comme tous les autres, exclut expressément tous les droits non expressément accordés par le Contrat, notamment la redistribution OEM et l'utilisation du logiciel Iron en mode SaaS sans souscription à une assurance complémentaire.

Tarification : À partir de $999.

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

Tarification : À partir de $2,399.

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

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

Tarification : À partir de $4,799.

Au-delà du coût de la licence, le coût total du projet comprend les heures de développement consacrées à l'écriture de la logique d'exportation supplémentaire pour des formats tels que JSON et XML, à la création de pipelines d'intégration de bases de données manuels et à la gestion de l'orchestration multi-classeurs que la bibliothèque ne gère pas nativement. Pour les équipes évaluant les coûts sur un cycle de vie de projet pluriannuel, ces coûts d'intégration et de maintenance éclipsent fréquemment la différence entre les modèles de licence.

Quelle bibliothèque devriez-vous choisir ?

EPPlus fournit une API robuste et éprouvée pour travailler avec les feuilles de calcul Office Open XML, et son contrôle précis au niveau des cellules convient aux projets nécessitant une manipulation précise des feuilles de calcul. Pour les équipes dont les besoins s'étendent à l'exportation multiformat (XML, HTML, JSON), aux opérations entre classeurs et à l'intégration de bases de données, IronXL ajoute ces fonctionnalités comme opérations de premier ordre. IronXL recalcule également les formules chaque fois que le document est modifié et fournit une syntaxe de plage intuitive avec WorkSheet[“A1:B10”]. Les formats de données des cellules comprennent le texte, les nombres, les formules, les dates, les devises, les pourcentages, la notation scientifique et l'heure, tandis que le style des cellules couvre les polices, les tailles, les motifs d'arrière-plan, les bordures et les alignements. Le tri est disponible par plages, colonnes et lignes. Le choix entre les deux dépend en fin de compte des besoins de votre projet : la gestion ciblée de l'Open XML par EPPlusou la gamme de fonctionnalités plus étendue d'IronXL. Pour voir comment IronXLs'adapte à votre flux de travail, téléchargez une version d'essai gratuite de 30 jours et testez les exemples de cet article dans votre propre environnement.