Créer un tableau croisé dynamique dans Excel avec C# est simple si vous choisissez la bonne bibliothèque : Interop Excel nécessite Office sur chaque machine, tandis IronXL fonctionne partout où .NET est exécuté. Ce guide présente les deux approches avec des exemples de code complets, couvrant la configuration, l'agrégation des données, la configuration des champs et les considérations de déploiement, afin de vous aider à choisir la solution la plus adaptée à votre projet.
Avant d'écrire une seule ligne de code, il est utile de comprendre le fonctionnement interne de chaque approche. Interop Excel utilise COM (Component Object Model) pour piloter Microsoft Excel directement depuis C#. Le processus .NET communique avec une instance Excel en cours d'exécution, ce qui implique qu'Excel doit être installé sur la machine. Chaque objet manipulé (classeurs, feuilles de calcul, plages, caches de tableaux croisés dynamiques) est un wrapper COM et doit être libéré explicitement pour éviter les fuites de mémoire.
IronXL emprunte une voie fondamentalement différente. Il lit et écrit directement le format de fichier Open XML , sans même avoir à lancer Excel. Le résultat est une bibliothèque .NET standard avec des modèles d'objets familiers, une mémoire gérée par le ramasse-miettes et aucune dépendance à l'installation ou à la licence d'Office. Cette architecture rend IronXL adapté aux charges de travail côté serveur , aux conteneurs Docker, aux hôtes Linux et à tout environnement .NET 6, .NET 8 ou .NET 10.
| Critères | Interop Excel | IronXL |
|---|---|---|
| Bureau requis | Oui | Non |
| Windows uniquement | Oui | Nonn -- multiplateforme |
| Gestion de la mémoire | Libération manuelle COM | Automatique (GC .NET ) |
| Déploiement du serveur | Difficile | Direct |
| Tableau pivot natif | API complète des tableaux croisés dynamiques Excel | Agrégation de données via LINQ |
| Licence requise | Licence de bureau | Licence IronXL uniquement |
Interop Excel est distribué sous forme de package NuGet . Exécutez l'une des commandes suivantes dans votre projet :
Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.ExcelNontez que le package seul ne suffit pas : la machine cible doit disposer d'une version compatible de Microsoft Excel installée et correctement licenciée. Cette dépendance exclut la plupart des scénarios de serveur, de conteneur et de cloud.
Installez IronXL via NuGet sans configuration système supplémentaire :
Après l'installation, vous pouvez commencer immédiatement à lire et à écrire des fichiers Excel sur n'importe quelle plateforme prenant en charge .NET. Aucune licence Office, aucun enregistrement COM, aucune configuration serveur. Consultez le guide d'installation d'IronXL pour découvrir d'autres options, notamment l'installation hors ligne et la configuration de la référence de projet.
Le flux de travail du tableau croisé dynamique Interop suit une séquence stricte : créer un cache de tableau croisé à partir d'une plage source, puis construire un objet PivotTable sur une feuille de calcul distincte, puis configurer les orientations des champs. L'exemple ci-dessous utilise des instructions C# de haut niveau compatibles avec .NET 10 :
using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
// Launch Excel and set up workbooks
var excelApp = new Excel.Application();
excelApp.Visible = false;
var workbook = excelApp.Workbooks.Add();
var dataSheet = (Excel.Worksheet)workbook.Worksheets[1];
dataSheet.Name = "SalesData";
var pivotSheet = (Excel.Worksheet)workbook.Worksheets.Add();
pivotSheet.Name = "Pivot";
// Populate header row
dataSheet.Cells[1, 1] = "Product";
dataSheet.Cells[1, 2] = "Region";
dataSheet.Cells[1, 3] = "Sales";
// Add sample data rows
object[,] rows = {
{ "Laptop", "Nonrth", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "Nonrth", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "Nonrth", 400 },
{ "Monitor", "South", 500 },
{ "Keyboard", "East", 300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
dataSheet.Cells[i + 2, 1] = rows[i, 0];
dataSheet.Cells[i + 2, 2] = rows[i, 1];
dataSheet.Cells[i + 2, 3] = rows[i, 2];
}
// Build pivot cache from source range
Excel.Range dataRange = dataSheet.Range["A1:C10"];
Excel.PivotCache pivotCache = workbook.PivotCaches().Create(
Excel.XlPivotTableSourceType.xlDatabase, dataRange);
// Create the PivotTable on the pivot sheet
Excel.PivotTables pivotTables = (Excel.PivotTables)pivotSheet.PivotTables();
Excel.PivotTable pivotTable = pivotTables.Add(
pivotCache, pivotSheet.Range["A3"], "SalesPivot");
// Assign field orientations
((Excel.PivotField)pivotTable.PivotFields("Product")).Orientation =
Excel.XlPivotFieldOrientation.xlRowField;
((Excel.PivotField)pivotTable.PivotFields("Region")).Orientation =
Excel.XlPivotFieldOrientation.xlColumnField;
((Excel.PivotField)pivotTable.PivotFields("Sales")).Orientation =
Excel.XlPivotFieldOrientation.xlDataField;
// Enable grand totals
pivotTable.RowGrand = true;
pivotTable.ColumnGrand = true;
// Save and close
workbook.SaveAs(@"C:\output\pivot_interop.xlsx");
workbook.Close(false);
excelApp.Quit();
// Release every COM object -- skipping any of these causes Excel to stay in memory
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotTables);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(dataRange);
Marshal.ReleaseComObject(pivotSheet);
Marshal.ReleaseComObject(dataSheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);Imports Excel = Microsoft.Office.Interop.Excel
Imports System.Runtime.InteropServices
' Launch Excel and set up workbooks
Dim excelApp As New Excel.Application()
excelApp.Visible = False
Dim workbook As Excel.Workbook = excelApp.Workbooks.Add()
Dim dataSheet As Excel.Worksheet = CType(workbook.Worksheets(1), Excel.Worksheet)
dataSheet.Name = "SalesData"
Dim pivotSheet As Excel.Worksheet = CType(workbook.Worksheets.Add(), Excel.Worksheet)
pivotSheet.Name = "Pivot"
' Populate header row
dataSheet.Cells(1, 1) = "Product"
dataSheet.Cells(1, 2) = "Region"
dataSheet.Cells(1, 3) = "Sales"
' Add sample data rows
Dim rows As Object(,) = {
{"Laptop", "Nonrth", 1200},
{"Laptop", "South", 1500},
{"Phone", "Nonrth", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "Nonrth", 400},
{"Monitor", "South", 500},
{"Keyboard", "East", 300}
}
For i As Integer = 0 To rows.GetLength(0) - 1
dataSheet.Cells(i + 2, 1) = rows(i, 0)
dataSheet.Cells(i + 2, 2) = rows(i, 1)
dataSheet.Cells(i + 2, 3) = rows(i, 2)
Next
' Build pivot cache from source range
Dim dataRange As Excel.Range = dataSheet.Range("A1:C10")
Dim pivotCache As Excel.PivotCache = workbook.PivotCaches().Create(Excel.XlPivotTableSourceType.xlDatabase, dataRange)
' Create the PivotTable on the pivot sheet
Dim pivotTables As Excel.PivotTables = CType(pivotSheet.PivotTables(), Excel.PivotTables)
Dim pivotTable As Excel.PivotTable = pivotTables.Add(pivotCache, pivotSheet.Range("A3"), "SalesPivot")
' Assign field orientations
CType(pivotTable.PivotFields("Product"), Excel.PivotField).Orientation = Excel.XlPivotFieldOrientation.xlRowField
CType(pivotTable.PivotFields("Region"), Excel.PivotField).Orientation = Excel.XlPivotFieldOrientation.xlColumnField
CType(pivotTable.PivotFields("Sales"), Excel.PivotField).Orientation = Excel.XlPivotFieldOrientation.xlDataField
' Enable grand totals
pivotTable.RowGrand = True
pivotTable.ColumnGrand = True
' Save and close
workbook.SaveAs("C:\output\pivot_interop.xlsx")
workbook.Close(False)
excelApp.Quit()
' Release every COM object -- skipping any of these causes Excel to stay in memory
Marshal.ReleaseComObject(pivotTable)
Marshal.ReleaseComObject(pivotTables)
Marshal.ReleaseComObject(pivotCache)
Marshal.ReleaseComObject(dataRange)
Marshal.ReleaseComObject(pivotSheet)
Marshal.ReleaseComObject(dataSheet)
Marshal.ReleaseComObject(workbook)
Marshal.ReleaseComObject(excelApp)Chaque wrapper COM nécessite un appel Marshal.ReleaseComObject correspondant. L'absence d'une seule référence entraîne la persistance du processus Excel en arrière-plan, consommant de la mémoire et des descripteurs de fichiers jusqu'à la fin du processus hôte. Cette charge de travail liée au nettoyage est proportionnelle à la complexité des opérations effectuées sur votre feuille de calcul.
IronXL n'expose pas d'API de tableau croisé dynamique native de la même manière qu'Interop ; le format de tableau croisé dynamique Open XML comporte des centaines d'attributs XML, et la plupart des exigences métier sont satisfaites de manière plus fiable avec une agrégation LINQ explicite écrite en C# pur. Le résultat est une feuille de synthèse propre qui se recalcule correctement à l'ouverture du fichier, sans dépendre d'Excel pour actualiser un cache de tableau croisé dynamique.
using IronXL;
using System.Data;
// Create workbook and populate source data
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet dataSheet = workbook.CreateWorkSheet("SalesData");
dataSheet["A1"].Value = "Product";
dataSheet["B1"].Value = "Region";
dataSheet["C1"].Value = "Sales";
object[,] rows = {
{ "Laptop", "Nonrth", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "Nonrth", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "Nonrth", 400 },
{ "Monitor", "South", 500 },
{ "Keyboard", "East", 300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
dataSheet[$"A{i + 2}"].Value = rows[i, 0];
dataSheet[$"B{i + 2}"].Value = rows[i, 1];
dataSheet[$"C{i + 2}"].Value = rows[i, 2];
}
// Aggregate data with LINQ -- equivalent to a pivot table row/column/value layout
DataTable table = dataSheet["A1:C10"].ToDataTable(true);
var summary = table.AsEnumerable()
.GroupBy(row => row.Field<string>("Product"))
.Select((group, idx) => new
{
Product = group.Key,
TotalSales = group.Sum(r => Convert.ToDecimal(r["Sales"])),
RegionCount = group.Select(r => r.Field<string>("Region")).Distinct().Count(),
RowIndex = idx + 2
})
.OrderByDescending(x => x.TotalSales);
// Write the summary sheet
WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Total Sales";
summarySheet["C1"].Value = "Regions";
foreach (var item in summary)
{
summarySheet[$"A{item.RowIndex}"].Value = item.Product;
summarySheet[$"B{item.RowIndex}"].Value = (double)item.TotalSales;
summarySheet[$"C{item.RowIndex}"].Value = item.RegionCount;
}
// Apply currency format to the sales column
summarySheet["B:B"].FormatString = "$#,##0.00";
// Bold the header row
summarySheet["A1:C1"].Style.Font.Bold = true;
// Save -- no COM cleanup needed
workbook.SaveAs(@"C:\output\analysis_ironxl.xlsx");Imports IronXL
Imports System.Data
Imports System.Linq
' Create workbook and populate source data
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim dataSheet As WorkSheet = workbook.CreateWorkSheet("SalesData")
dataSheet("A1").Value = "Product"
dataSheet("B1").Value = "Region"
dataSheet("C1").Value = "Sales"
Dim rows As Object(,) = {
{"Laptop", "Nonrth", 1200},
{"Laptop", "South", 1500},
{"Phone", "Nonrth", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "Nonrth", 400},
{"Monitor", "South", 500},
{"Keyboard", "East", 300}
}
For i As Integer = 0 To rows.GetLength(0) - 1
dataSheet($"A{i + 2}").Value = rows(i, 0)
dataSheet($"B{i + 2}").Value = rows(i, 1)
dataSheet($"C{i + 2}").Value = rows(i, 2)
Next
' Aggregate data with LINQ -- equivalent to a pivot table row/column/value layout
Dim table As DataTable = dataSheet("A1:C10").ToDataTable(True)
Dim summary = table.AsEnumerable() _
.GroupBy(Function(row) row.Field(Of String)("Product")) _
.Select(Function(group, idx) New With {
.Product = group.Key,
.TotalSales = group.Sum(Function(r) Convert.ToDecimal(r("Sales"))),
.RegionCount = group.Select(Function(r) r.Field(Of String)("Region")).Distinct().Count(),
.RowIndex = idx + 2
}) _
.OrderByDescending(Function(x) x.TotalSales)
' Write the summary sheet
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("Summary")
summarySheet("A1").Value = "Product"
summarySheet("B1").Value = "Total Sales"
summarySheet("C1").Value = "Regions"
For Each item In summary
summarySheet($"A{item.RowIndex}").Value = item.Product
summarySheet($"B{item.RowIndex}").Value = CDbl(item.TotalSales)
summarySheet($"C{item.RowIndex}").Value = item.RegionCount
Next
' Apply currency format to the sales column
summarySheet("B:B").FormatString = "$#,##0.00"
' Bold the header row
summarySheet("A1:C1").Style.Font.Bold = True
' Save -- no COM cleanup needed
workbook.SaveAs("C:\output\analysis_ironxl.xlsx")Il n'y a aucun objet COM à libérer, aucun processus Excel à terminer et aucune licence Office à gérer. Le même code se compile et s'exécute sous Linux, macOS et Windows sans modification. Pour plus de détails sur l'API d'agrégation, consultez la documentation IronXL WorkSheet .
Le déploiement d'une application basée sur l'interopérabilité implique de vérifier que l'environnement cible exécute Windows, dispose de la version correcte d'Office installée et que les autorisations d'automatisation COM sont configurées sur le serveur. Les environnements hébergés dans le cloud et les charges de travail conteneurisées ne peuvent généralement pas répondre à ces exigences sans l'ajout d'une infrastructure de bureau Windows virtualisée, ce qui augmente considérablement les coûts et la complexité opérationnelle.
IronXL ne présente pas de telles contraintes. Ajoutez le package NuGet , définissez votre framework cible sur .NET 6 ou version ultérieure, et l'application se déploie sur n'importe quel hôte, y compris les conteneurs Linux, Azure App Service sur Linux, AWS Lambda et les serveurs Windows locaux. La page des configurations système requises d'IronXL répertorie la matrice de compatibilité complète.
Les échecs Interop se manifestent sous forme d'exceptions COM (COMException) qui sont difficiles à traduire en messages visibles par l'utilisateur. Les incompatibilités de versions entre la version d'Office installée et l'assembly Interop constituent un autre mode de défaillance. Le débogage de ces problèmes nécessite généralement de reproduire la version exacte d'Office sur une machine de développement.
IronXL génère des sous-classes System.Exception standard avec des messages descriptifs. Vous pouvez encapsuler les opérations sur les fichiers dans un bloc try-catch et fournir un retour d'information pertinent sans avoir à comprendre les codes d'erreur COM. Le guide de dépannage IronXL couvre les exceptions courantes et leurs solutions.
Les objets COM contiennent de la mémoire non gérée. Si votre code traite de nombreuses feuilles de calcul ou s'exécute en boucle, le fait de ne pas libérer correctement chaque référence entraîne une augmentation de la mémoire au fil du temps – un problème difficile à détecter jusqu'à ce qu'il provoque un incident de production. Interop est également intrinsèquement monothread car il gère une seule fenêtre Excel.
IronXL utilise des objets gérés, pris en charge par le ramasse-miettes .NET . La mémoire est automatiquement libérée lorsque les objets sortent de leur portée. Le traitement parallèle de plusieurs classeurs est simple car il n'y a pas d'état COM partagé à protéger par des verrous.
L'outil approprié dépend de deux contraintes : l'emplacement d'exécution du code et la nécessité d'un fichier XML natif pour les tableaux croisés dynamiques.
Choisissez Interop Excel lorsque :
La charge de travail s'exécute uniquement sur les ordinateurs de bureau Windows sur lesquels Office est déjà installé.
Choisissez IronXL lorsque :
L'application s'exécute sur un serveur, un conteneur ou une fonction cloud.
Pour la plupart des nouveaux projets .NET 10, IronXL est le choix par défaut. La bibliothèque IronXL couvre également la lecture de fichiers Excel en C#, la création de graphiques, l'application de styles de cellule, le travail avec des formules et l'exportation de données Excel vers DataTable -- réduisant le besoin de plusieurs bibliothèques dans votre pile.
Au-delà de l'agrégation de base, IronXL offre plusieurs fonctionnalités qui prennent en charge des flux de travail d'analyse de données plus riches :
Vous pouvez trier une plage de valeurs par ordre croissant ou décroissant avant de rédiger un tableau récapitulatif. Cela garantit que les données de sortie sont toujours présentées dans un ordre cohérent, ce qui rend le traitement en aval plus prévisible. Consultez la documentation IronXL sur le tri pour les options de tri au niveau de la plage.
Soulignez les valeurs aberrantes ou seuils en appliquant des règles de formatage conditionnel par programmation. Par exemple, vous pouvez colorer en rouge les cellules du tableau récapitulatif lorsque les ventes sont inférieures à un objectif, ce qui permet d'obtenir une vue d'ensemble sans que les utilisateurs finaux aient à configurer les règles manuellement.
Si les données sources proviennent d'une feuille de calcul existante plutôt que d'une base de données, vous pouvez les charger directement avec WorkBook.Load :
using IronXL;
WorkBook existing = WorkBook.Load(@"C:\data\sales_report.xlsx");
WorkSheet sheet = existing.WorkSheets[0];
// Read column C starting at row 2
var salesValues = sheet["C2:C100"]
.Where(cell => cell.Value != null && cell.Value.ToString() != string.Empty)
.Select(cell => cell.DecimalValue)
.ToList();
decimal total = salesValues.Sum();
Console.WriteLine($"Total sales from file: {total:C}");Imports IronXL
Dim existing As WorkBook = WorkBook.Load("C:\data\sales_report.xlsx")
Dim sheet As WorkSheet = existing.WorkSheets(0)
' Read column C starting at row 2
Dim salesValues = sheet("C2:C100") _
.Where(Function(cell) cell.Value IsNot Nothing AndAlso cell.Value.ToString() <> String.Empty) _
.Select(Function(cell) cell.DecimalValue) _
.ToList()
Dim total As Decimal = salesValues.Sum()
Console.WriteLine($"Total sales from file: {total:C}")Ce modèle fonctionne pour .xlsx, .xls, .csv, et d'autres formats pris en charge par IronXL. Les détails sur les formats pris en charge figurent dans la documentation sur les formats de fichiers IronXL.
Après avoir généré une feuille de calcul récapitulative, vous pouvez l'exporter au format CSV pour les systèmes en aval qui n'acceptent pas Excel :
workbook.SaveAsCsv(@"C:\output\summary.csv");workbook.SaveAsCsv("C:\output\summary.csv")Ceci est particulièrement utile dans les pipelines ETL où le consommateur final est un outil d'importation de base de données ou un chargeur d'entrepôt de données.
IronXL est disponible sous une licence d'essai gratuite qui vous permet d'évaluer l'ensemble des fonctionnalités sans vous engager sur un abonnement. La version d'essai appose un filigrane sur les fichiers de sortie, que vous supprimez lorsque vous appliquez une clé de licence de production.
Pour activer une clé de licence par code, définissez-la avant toute opération IronXL :
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"Vous pouvez également définir la clé via une variable d'environnement (IRONXL_LICENSEKEY) ou par appsettings.json dans les projets ASP.NET Core. La page de licences IronXL décrit tous les niveaux disponibles, y compris les options pour les équipes et les organisations.
Pour les déploiements en production, consultez la documentation de déploiement IronXL et la bibliothèque de tutoriels IronXL pour des modèles couvrant ASP.NET Core, Azure Functions, et Docker.
Les tableaux croisés dynamiques Excel en C# ne nécessitent pas forcément une dépendance à Office ni une complexité liée à COM. Avec IronXL, vous écrivez du code .NET simple qui s'exécute sur n'importe quelle plateforme, gère automatiquement la mémoire et s'intègre naturellement aux frameworks de tests unitaires et aux pipelines CI/CD.
Téléchargez la version d'essai gratuite IronXL et exécutez les exemples de ce guide avec vos propres données. Si vous avez des questions, le forum de la communauté IronXL et le portail d'assistance sont disponibles pour les utilisateurs en version d'essai et les utilisateurs disposant d'une licence. Une fois que vous êtes prêt à déployer votre solution, consultez les options de licence pour trouver le plan qui correspond à la taille de votre équipe et à votre volume d'utilisation.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronXL fait partie de IRONSUITE
10 API .NET pour vos documents
L'API Excel dont vous avez besoin, sans tracas Interop Office.
