Dans cet article, vous apprendrez à créer des fichiers Excel XLS/XLSX par programme en C# sans installer MS Office.
De nos jours, les feuilles de calcul sont devenues un élément essentiel de la conservation, de l’organisation et de l’analyse des données. Les tableurs, tels que MS Excel, sont capables d’effectuer des calculs et de trier, de générer des graphiques ou des tableaux, de créer des budgets et d’effectuer de nombreuses autres tâches de comptabilité ou d’analyse de données. Étant donné que les solutions automatisées sont de plus en plus utilisées ces jours-ci, la tendance à créer et à manipuler des documents Excel (XLS/XLSX) a émergé et s’est développée à un rythme effréné. Ce cas d’utilisation a soulevé le besoin d’avoir une solution d’automatisation Excel.
Conformément au scénario mentionné ci-dessus, cet article complet vise à vous montrer quelques fonctionnalités de base pour l’automatisation d’Excel dans les applications C# .NET.
- API d’automatisation C# Excel
- Créez dynamiquement des fichiers Excel XLS ou XLSX à l’aide de C#
- Écrire des données dans le fichier Excel existant à l’aide de C#
- Créer des tableaux ou des graphiques dans un fichier Excel à l’aide de C#
- Créer un tableau dans un fichier Excel à l’aide de C#
API C# pour créer des fichiers Excel
Afin de travailler avec des documents Excel, nous utiliserons Aspose.Cells for .NET qui est une API puissante pour créer, lire et manipuler des feuilles de calcul, y compris des fichiers XLS et XLSX. Vous pouvez soit télécharger ou installer l’API en utilisant l’une des méthodes suivantes :
Utilisation du gestionnaire de packages NuGet
Utilisation de la console du gestionnaire de packages
PM> Install-Package Aspose.Cells
Créer un Excel XLS ou XLSX en C#
Un fichier Excel est également connu sous le nom de classeur qui est composé d’une ou plusieurs feuilles de calcul contenant les lignes et les colonnes pour contenir les données. Ainsi, un classeur agit comme le conteneur des feuilles de calcul dans un fichier Excel. Ainsi, pour créer un fichier Excel, vous devez d’abord créer un classeur, puis les feuilles de calcul de ce classeur. Voici les étapes pour créer un fichier Excel en utilisant Aspose.Cells for .NET.
- Créez une instance de la classe Workbook.
- Accédez à la première feuille de calcul (créée par défaut) du classeur.
- Accédez à la ou aux cellules souhaitées de la feuille de calcul et mettez la valeur dans la ou les cellules.
- Enregistrez le classeur en tant que fichier XLS ou XLSX.
L’exemple de code suivant montre comment créer un fichier Excel XLSX à l’aide de C#.
// Instanciez un objet Workbook qui représente un fichier Excel.
Workbook wb = new Workbook();
// Lorsque vous créez un nouveau classeur, une "Feuille1" par défaut est ajoutée au classeur.
Worksheet sheet = wb.Worksheets[0];
// Accédez à la cellule "A1" dans la feuille.
Cell cell = sheet.Cells["A1"];
// Entrez le "Hello World!" texte dans la cellule "A1".
cell.PutValue("Hello World!");
// Enregistrez le fichier Excel en tant que fichier .xlsx.
wb.Save("Excel.xlsx", SaveFormat.Xlsx);
Production
Écrire des données dans un fichier Excel XLSX en C#
Si vous souhaitez modifier et écrire des données dans un fichier Excel existant, vous pouvez également le faire de la même manière. Chargez simplement le document de feuille de calcul Excel source à l’aide de l’objet Workbook et accédez aux feuilles de calcul et aux cellules souhaitées. Voici les étapes pour modifier un fichier Excel existant.
- Ouvrir le fichier Excel dans un objet FileStream.
- Créez une instance de Workbook et initialisez-la avec l’objet FileStream.
- Accédez aux feuilles de calcul et aux cellules en utilisant respectivement les classes Worksheet et Cell.
- Enregistrez le classeur en tant que fichier Excel .xlsx.
L’exemple de code suivant montre comment modifier et écrire des données dans un fichier Excel XLSX existant en C#.
// Instanciez un objet Workbook qui représente un fichier Excel.
Workbook wb = new Workbook("Excel.xlsx");
// Accédez à "Feuille1" à partir du classeur.
Worksheet sheet = wb.Worksheets[0];
// Accédez à la cellule "A1" dans la feuille.
Cell cell = sheet.Cells["A1"];
// Entrez le "Hello World!" texte dans la cellule "A1".
cell.PutValue("The cell's value is updated.");
// Enregistrez le fichier Excel au format .xlsx.
wb.Save("Excel_updated.xlsx", SaveFormat.Xlsx);
Créer des tableaux ou des graphiques dans un fichier Excel XLSX à l’aide de C#
Les feuilles de calcul Excel offrent un bon moyen d’analyser ou de présenter visuellement les données à l’aide de graphiques et de tableaux. Aspose.Cells for .NET fournit un ensemble complet de classes pour créer et manipuler une variété de graphiques dans des feuilles de calcul Excel où chaque classe est utilisée pour effectuer certaines tâches spécifiques.
Pour créer les graphiques dans un fichier Excel, vous devrez suivre les étapes suivantes :
- Ajoutez des données (à utiliser comme source de données) à la feuille de calcul en accédant à ses cellules.
- Ajoutez un nouvel objet graphique à la feuille de calcul à l’aide de la collection Worksheet.Charts en transmettant le type de graphique à l’aide de l’énumération ChartType.
- Obtenez le graphique nouvellement créé à partir de la collection dans un objet Chart.
- Spécifiez la plage de cellules pour fournir la source de données à l’objet graphique.
- Enregistrez le classeur en tant que fichier Excel .xlsx.
L’exemple de code suivant montre comment créer un graphique dans un fichier Excel XLSX en C#.
// Instanciez un objet Workbook qui représente un fichier Excel.
Workbook wb = new Workbook();
// Ajoutez une nouvelle feuille de calcul à l'objet Excel.
int sheetIndex = wb.Worksheets.Add();
// Obtenir la référence de la feuille de calcul nouvellement ajoutée en passant son index de feuille.
Worksheet worksheet = wb.Worksheets[sheetIndex];
// Ajoutez des valeurs factices aux cellules.
worksheet.Cells["A1"].PutValue(50);
worksheet.Cells["A2"].PutValue(100);
worksheet.Cells["A3"].PutValue(150);
worksheet.Cells["B1"].PutValue(4);
worksheet.Cells["B2"].PutValue(20);
worksheet.Cells["B3"].PutValue(50);
// Ajoutez un graphique à la feuille de calcul.
int chartIndex = worksheet.Charts.Add(Charts.ChartType.Pyramid, 5, 0, 15, 5);
// Accédez à l'instance du graphique nouvellement ajouté.
Charts.Chart chart = worksheet.Charts[chartIndex];
// Ajoutez SeriesCollection (source de données du graphique) au graphique allant de la cellule "A1" à "B3".
chart.NSeries.Add("A1:B3", true);
// Enregistrez le fichier Excel.
wb.Save("Excel_Chart.xlsx", SaveFormat.Xlsx);
Production
En savoir plus sur la création de graphiques dans des feuilles de calcul Excel à l’aide de C#.
Créer un tableau dans un fichier Excel XLSX en C#
Vous pouvez également créer un tableau à partir de la plage de cellules d’une feuille de calcul Excel et ajouter une ligne pour le total (somme, nombre, etc.) dans le tableau. Voici les étapes pour créer un tableau dans un fichier Excel (XLSX) à l’aide d’Aspose.Cells for .NET :
- Chargez un classeur Excel ou créez-en un nouveau à l’aide de la classe Workbook.
- Ajoutez des données aux cellules de la feuille de calcul.
- Ajoutez un nouveau ListObject à la feuille de calcul.
- Définissez la propriété ListObject.ShowTotals sur true.
- Calculez le total et enregistrez le classeur en tant que fichier Excel .xlsx.
L’exemple de code suivant montre comment créer une table dans une feuille de calcul Excel en C#.
// Instanciez un objet Workbook qui représente un fichier Excel.
Workbook wb = new Workbook();
// Obtenez la première feuille de calcul.
Worksheet sheet = wb.Worksheets[0];
// Obtention de la collection de cellules de Worksheet
Cells cells = sheet.Cells;
// Définir la valeur des cellules
Aspose.Cells.Cell cell = cells["A1"];
cell.PutValue("Employee");
cell = cells["B1"];
cell.PutValue("Quarter");
cell = cells["C1"];
cell.PutValue("Product");
cell = cells["D1"];
cell.PutValue("Continent");
cell = cells["E1"];
cell.PutValue("Country");
cell = cells["F1"];
cell.PutValue("Sale");
cell = cells["A2"];
cell.PutValue("David");
cell = cells["A3"];
cell.PutValue("David");
cell = cells["A4"];
cell.PutValue("David");
cell = cells["A5"];
cell.PutValue("David");
cell = cells["A6"];
cell.PutValue("James");
cell = cells["B2"];
cell.PutValue(1);
cell = cells["B3"];
cell.PutValue(2);
cell = cells["B4"];
cell.PutValue(3);
cell = cells["B5"];
cell.PutValue(4);
cell = cells["B6"];
cell.PutValue(1);
cell = cells["C2"];
cell.PutValue("Maxilaku");
cell = cells["C3"];
cell.PutValue("Maxilaku");
cell = cells["C4"];
cell.PutValue("Chai");
cell = cells["C5"];
cell.PutValue("Maxilaku");
cell = cells["C6"];
cell.PutValue("Chang");
cell = cells["D2"];
cell.PutValue("Asia");
cell = cells["D3"];
cell.PutValue("Asia");
cell = cells["D4"];
cell.PutValue("Asia");
cell = cells["D5"];
cell.PutValue("Asia");
cell = cells["D6"];
cell.PutValue("Europe");
cell = cells["E2"];
cell.PutValue("China");
cell = cells["E3"];
cell.PutValue("India");
cell = cells["E4"];
cell.PutValue("Korea");
cell = cells["E5"];
cell.PutValue("India");
cell = cells["E6"];
cell.PutValue("France");
cell = cells["F2"];
cell.PutValue(2000);
cell = cells["F3"];
cell.PutValue(500);
cell = cells["F4"];
cell.PutValue(1200);
cell = cells["F5"];
cell.PutValue(1500);
cell = cells["F6"];
cell.PutValue(500);
// Ajout d'un nouvel objet de liste à la feuille de calcul
Tables.ListObject listObject = sheet.ListObjects[sheet.ListObjects.Add("A1", "F6", true)];
// Ajout du style par défaut au tableau
listObject.TableStyleType = Tables.TableStyleType.TableStyleMedium10;
// Afficher le total
listObject.ShowTotals = true;
// Définir le type de calcul du champ Trimestre
listObject.ListColumns[1].TotalsCalculation = Tables.TotalsCalculation.Count;
// Enregistrez le fichier Excel.
wb.Save("Excel_Table.xlsx", SaveFormat.Xlsx);
Production
En savoir plus sur l’utilisation de tableaux dans des feuilles de calcul Excel à l’aide de C#.
Conclusion
Dans cet article, vous avez appris à créer des fichiers Excel à partir de rien à l’aide de C#. De plus, vous avez vu comment insérer des données dans des feuilles, générer des graphiques et insérer des tableaux dans des fichiers Excel. Vous pouvez consulter la documentation de Aspose.Cells for .NET pour apprendre les fonctionnalités avancées de manipulation des fichiers Excel en C#.