Comment créer des tableaux croisés dynamiques dans Excel avec C# en utilisant IronXL

Qu'est-ce qu'un tableau croisé dynamique Excel ?

Un tableau croisé dynamique est l'un des outils d'analyse les plus puissants des logiciels de tableur. Il permet de synthétiser de grands ensembles de données en regroupant les lignes, en agrégeant les valeurs et en projetant les résultats dans un tableau croisé dynamique, le tout sans que vous ayez à écrire une seule formule manuellement. La documentation officielle de Microsoft sur les tableaux croisés dynamiques fournit une présentation détaillée de cette fonctionnalité au sein même d'Excel.

Les tableaux croisés dynamiques sont présents dans Microsoft Excel, Google Sheets, Apple Numbers et la plupart des autres logiciels de tableur. Le principe de base reste toujours le même : vous définissez les champs de lignes, les champs de colonnes et les champs de valeurs, et l'outil génère pour vous une matrice récapitulative. Lorsque les données sous-jacentes changent, il suffit d'actualiser le tableau croisé dynamique pour que le résumé se mette à jour automatiquement.

En C# côté serveur, vous avez deux grandes options :

• Interopérabilité C# : automatise un processus Excel en cours d'exécution via COM pour créer un véritable objet de tableau croisé dynamique natif dans un fichier XLSX
• IronXL avec agrégation LINQ : charge le classeur en mémoire, calcule le même résumé en code .NET managé et écrit le résultat dans une nouvelle feuille de calcul.

Les deux options produisent un résultat utile. Mais une seule d'entre elles fonctionne de manière fiable dans les environnements de déploiement modernes.

Comment créer un tableau croisé dynamique en utilisant Interopérabilité C# ?

L'interopérabilité C# Excel vous offre un accès direct aux fonctionnalités natives des tableaux croisés dynamiques d'Excel via l'automatisation COM. Vous créez un objet Excel.Application, ouvrez un classeur, définissez un cache de pivot pointant vers une plage de données, puis configurez les champs de ligne, les champs de colonne et les champs de données.

using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;

// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();

// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;

// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase,
    dataRange,
    Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
    xlPivotSheet.Cells[3, 1],
    "SalesPivot",
    Type.Missing,
    Type.Missing);

// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;

Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;

Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);

// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();

// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);

using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;

// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();

// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;

// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase,
    dataRange,
    Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
    xlPivotSheet.Cells[3, 1],
    "SalesPivot",
    Type.Missing,
    Type.Missing);

// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;

Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;

Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);

// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();

// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Quels sont les problèmes posés par l'interopérabilité du C# ?

L'approche interop présente plusieurs défis importants qui s'aggravent rapidement lors d'un déploiement concret. Stack Overflow et d'autres ressources de programmation continuent de le recommander car de nombreux sujets de discussion ont été écrits au début des années 2000 et ont depuis été verrouillés – les conseils sont donc figés dans le temps.

Dépendances de déploiement : chaque machine exécutant votre code doit disposer d'une copie sous licence de Microsoft Office, y compris les serveurs de production et les agents de compilation CI/CD. Cela engendre des coûts de licence et une complexité de déploiement supplémentaires, totalement évitables grâce aux alternatives modernes.

Charge de gestion de la mémoire -- les objets COM doivent être libérés explicitement à l'aide de Marshal.ReleaseComObject(). L'absence d'un seul objet suffit à bloquer indéfiniment les processus Excel en mémoire, comme cela est largement documenté sur Stack Overflow . Dans un service de longue durée ou une application web ASP.NET , cela devient une fuite de ressources critique.

Restrictions de plateforme : l'interopérabilité fonctionne uniquement sous Windows avec Office installé. Vous ne pouvez pas l'exécuter sous Linux, macOS, dans des conteneurs Docker, ni sur des plateformes sans serveur comme Azure Functions ou AWS Lambda. Cela vous empêche totalement d'utiliser les architectures cloud-native modernes.

Goulots d'étranglement en termes de performances : le lancement d'une instance d'Excel est lent et gourmand en ressources. Pour le traitement par lots côté serveur, où il peut être nécessaire de générer des dizaines, voire des centaines de rapports, ce temps de démarrage représente une contrainte majeure en termes de débit.

Fragilité liée à la compatibilité des versions : différentes versions d'Office exposent des interfaces COM légèrement différentes. Le code qui fonctionne avec Office 2019 peut se comporter différemment avec Office 2016 ou Microsoft 365, et il n'existe aucun moyen de figer la version dans un déploiement. La documentation Microsoft relative aux assemblys Office Interop mentionne ces contraintes de versionnage comme une limitation connue.

Incompatibilité CI/CD – la plupart des environnements d'intégration continue n'ont pas Office installé. Tester votre code de génération de tableau croisé dynamique nécessite soit de simuler l'intégralité de la couche COM, soit de maintenir un agent Windows spécial avec une installation Office sous licence.

Pour toute nouvelle application .NET ciblant .NET 6 ou une version ultérieure (y compris .NET 10), ces contraintes rendent l'interopérabilité peu pratique.

Comment IronXL crée-t-il des tableaux croisés dynamiques sans interopérabilité ?

IronXL aborde la création de tableaux croisés dynamiques différemment. Plutôt que de contrôler un processus Excel externe via COM, IronXL lit votre classeur dans la mémoire .NET gérée, vous donnant un accès direct aux valeurs des cellules, aux formules et à la structure de la feuille de calcul. Vous créez ensuite des agrégations de type pivot à l'aide de requêtes LINQ standard et vous réécrivez les résultats dans une nouvelle feuille de calcul.

Comment créer un tableau récapitulatif croisé avec IronXL et LINQ

L'exemple suivant charge un classeur de données de ventes, calcule un tableau croisé dynamique produit-région et écrit le résumé dans une nouvelle feuille de calcul, le tout sans aucune dépendance à Office :

using IronXL;
using System.Linq;
using System.Data;

// Load Excel file -- no Office installation required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];

// Convert to DataTable for flexible LINQ manipulation
var dataTable = dataSheet.ToDataTable(true); // true = first row as column headers

// Build pivot-style aggregation using LINQ grouping
var pivotData = dataTable.AsEnumerable()
    .GroupBy(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Select(g => new {
        Product = g.Key.Product,
        Region = g.Key.Region,
        TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
        AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
        Count = g.Count()
    });

// Create the pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

// Get distinct row and column values
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p).ToList();
var regions  = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r).ToList();

// Write column headers
pivotSheet["A1"].Value = "Product / Region";
for (int c = 0; c < regions.Count; c++)
{
    pivotSheet[$"{(char)('B' + c)}1"].Value = regions[c];
}

// Populate data rows
for (int r = 0; r < products.Count; r++)
{
    pivotSheet[$"A{r + 2}"].Value = products[r];
    for (int c = 0; c < regions.Count; c++)
    {
        var sales = pivotData
            .Where(p => p.Product == products[r] && p.Region == regions[c])
            .Select(p => p.TotalSales)
            .FirstOrDefault();
        pivotSheet[$"{(char)('B' + c)}{r + 2}"].Value = sales;
    }
}

// Add a totals row using Excel SUM formulas
int totalRow = products.Count + 2;
pivotSheet[$"A{totalRow}"].Value = "Total";
for (int c = 0; c < regions.Count; c++)
{
    char col = (char)('B' + c);
    pivotSheet[$"{col}{totalRow}"].Formula = $"=SUM({col}2:{col}{totalRow - 1})";
}

// Apply currency formatting to the data range
var dataRange = pivotSheet[$"B2:{(char)('B' + regions.Count - 1)}{totalRow}"];
dataRange.FormatString = "$#,##0.00";

workbook.SaveAs("PivotReport.xlsx");

using IronXL;
using System.Linq;
using System.Data;

// Load Excel file -- no Office installation required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];

// Convert to DataTable for flexible LINQ manipulation
var dataTable = dataSheet.ToDataTable(true); // true = first row as column headers

// Build pivot-style aggregation using LINQ grouping
var pivotData = dataTable.AsEnumerable()
    .GroupBy(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Select(g => new {
        Product = g.Key.Product,
        Region = g.Key.Region,
        TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
        AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
        Count = g.Count()
    });

// Create the pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

// Get distinct row and column values
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p).ToList();
var regions  = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r).ToList();

// Write column headers
pivotSheet["A1"].Value = "Product / Region";
for (int c = 0; c < regions.Count; c++)
{
    pivotSheet[$"{(char)('B' + c)}1"].Value = regions[c];
}

// Populate data rows
for (int r = 0; r < products.Count; r++)
{
    pivotSheet[$"A{r + 2}"].Value = products[r];
    for (int c = 0; c < regions.Count; c++)
    {
        var sales = pivotData
            .Where(p => p.Product == products[r] && p.Region == regions[c])
            .Select(p => p.TotalSales)
            .FirstOrDefault();
        pivotSheet[$"{(char)('B' + c)}{r + 2}"].Value = sales;
    }
}

// Add a totals row using Excel SUM formulas
int totalRow = products.Count + 2;
pivotSheet[$"A{totalRow}"].Value = "Total";
for (int c = 0; c < regions.Count; c++)
{
    char col = (char)('B' + c);
    pivotSheet[$"{col}{totalRow}"].Formula = $"=SUM({col}2:{col}{totalRow - 1})";
}

// Apply currency formatting to the data range
var dataRange = pivotSheet[$"B2:{(char)('B' + regions.Count - 1)}{totalRow}"];
dataRange.FormatString = "$#,##0.00";

workbook.SaveAs("PivotReport.xlsx");

$vbLabelText   $csharpLabel

Cela produit le même résumé croisé que celui obtenu avec un tableau croisé dynamique Excel natif. Vous disposez d'un contrôle programmatique complet sur chaque cellule, formule et chaîne de format, sans aucun objet COM à nettoyer.

Comment créer un tableau croisé dynamique dans Excel avec Interopérabilité C# et IronXL: Image 1 - Le fichier Excel original comparé au tableau croisé dynamique créé (affichage des cellules).

Commencez avec IronXL maintenant.

Commencer gratuitement

Comment créer des résumés dynamiques à l'aide des formules Excel ?

Pour les scénarios où vous souhaitez que la feuille de synthèse reste dynamique — se recalculant automatiquement à chaque modification des données sources —, IronXL vous permet d'écrire directement des chaînes de formules Excel dans les cellules. Cela vous offre un comportement similaire à l'actualisation automatique d'un tableau croisé dynamique, sans aucune dépendance à Interop.

Les fonctions clés ici sont SUMIFS et COUNTIFS. SUMIFS calcule la somme d'une plage en fonction de plusieurs critères de colonnes ; COUNTIFS compte les lignes correspondantes. Les deux acceptent des références à des feuilles de calcul nommées, vous pouvez donc faire pointer votre feuille de synthèse directement vers la feuille de données source par son nom.

using IronXL;
using System.Data;

string inputPath  = "SalesData.xlsx";
string outputPath = "DynamicSummary.xlsx";

WorkBook workbook  = WorkBook.Load(inputPath);
WorkSheet dataSheet = workbook.WorkSheets[0];

// Name the data sheet so formula references are stable
dataSheet.Name = "DataSheet";

// Convert to DataTable to enumerate unique product/region combinations
DataTable dataTable = dataSheet.ToDataTable(true);

WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region pairs
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region  = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region)
    .ToList();

// Header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with live SUMIFS / COUNTIFS formulas
for (int i = 0; i < uniqueCombos.Count; i++)
{
    int rowIndex = i + 2;
    var combo = uniqueCombos[i];

    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

    summarySheet[$"C{rowIndex}"].Formula =
        $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";

    summarySheet[$"D{rowIndex}"].Formula =
        $"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
}

// Grand total row
int totalRow = uniqueCombos.Count + 2;
summarySheet[$"A{totalRow}"].Value = "Total";
summarySheet[$"C{totalRow}"].Formula = $"=SUM(C2:C{totalRow - 1})";
summarySheet[$"D{totalRow}"].Formula = $"=SUM(D2:D{totalRow - 1})";

workbook.SaveAs(outputPath);

using IronXL;
using System.Data;

string inputPath  = "SalesData.xlsx";
string outputPath = "DynamicSummary.xlsx";

WorkBook workbook  = WorkBook.Load(inputPath);
WorkSheet dataSheet = workbook.WorkSheets[0];

// Name the data sheet so formula references are stable
dataSheet.Name = "DataSheet";

// Convert to DataTable to enumerate unique product/region combinations
DataTable dataTable = dataSheet.ToDataTable(true);

WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region pairs
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region  = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region)
    .ToList();

// Header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with live SUMIFS / COUNTIFS formulas
for (int i = 0; i < uniqueCombos.Count; i++)
{
    int rowIndex = i + 2;
    var combo = uniqueCombos[i];

    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

    summarySheet[$"C{rowIndex}"].Formula =
        $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";

    summarySheet[$"D{rowIndex}"].Formula =
        $"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
}

// Grand total row
int totalRow = uniqueCombos.Count + 2;
summarySheet[$"A{totalRow}"].Value = "Total";
summarySheet[$"C{totalRow}"].Formula = $"=SUM(C2:C{totalRow - 1})";
summarySheet[$"D{totalRow}"].Formula = $"=SUM(D2:D{totalRow - 1})";

workbook.SaveAs(outputPath);

Comment les deux approches se comparent-elles ?

Avant de choisir une approche, il est utile de comparer les avantages et les inconvénients. Le tableau ci-dessous récapitule les dimensions les plus importantes pour le développement .NET en production :

Le seul cas où Interop présente un avantage évident est celui où vous avez spécifiquement besoin de l'objet tableau croisé dynamique Excel natif intégré dans le fichier XLSX – par exemple, si les utilisateurs en aval doivent interagir avec lui à l'aide de l'interface utilisateur intégrée du tableau croisé dynamique d'Excel (exploration, filtrage, modification interactive des fonctions d'agrégation). Dans tous les autres cas, l'approche d'IronXL est plus rapide à écrire, plus facile à déployer et beaucoup plus portable.

Quelle approche devriez-vous choisir ?

Le choix approprié dépend de votre environnement de déploiement et des besoins de vos utilisateurs.

Choisissez Interopérabilité C# uniquement lorsque :

Vos utilisateurs ont besoin d'objets de tableau croisé dynamique Excel natifs qu'ils peuvent manipuler de manière interactive dans l'interface utilisateur d'Excel. Vous ciblez un environnement de bureau Windows fermé où Office est garanti installé sur chaque machine.

• Vous maintenez du code .NET Framework hérité qui dépend déjà d'Interop et une réécriture n'est actuellement pas justifiée.

Choisissez IronXL lorsque :

• Vous déployez sur un serveur, un conteneur ou tout environnement cloud (Azure, AWS, GCP).
• Vous avez besoin d'une prise en charge multiplateforme pour les builds Linux, macOS ou basés sur Docker.
• Vous souhaitez un code propre et maintenable sans gestion du cycle de vie COM
• Vous ciblez .NET 5, 6, 7, 8, 9 ou 10 Vous souhaitez éviter les frais de licence Microsoft Office sur l'infrastructure serveur. Vous avez besoin d'un traitement par lots rapide de nombreux classeurs sans avoir à démarrer un processus Excel pour chaque fichier.

Pour la grande majorité des applications .NET modernes, IronXL est le choix idéal. Son système de génération de rapports par agrégation répond à tous les besoins réels, et vous offre une portabilité totale.

Vous pouvez explorer d'autres fonctionnalités, notamment la mise en forme des cellules, l'évaluation des formules, la validation des données et la génération de graphiques, dans la documentation IronXL et la bibliothèque d'exemples IronXL .

Comment démarrer avec IronXL dès aujourd'hui ?

La bibliothèque IronXL est disponible sur NuGet et son ajout à n'importe quel projet .NET prend moins d'une minute :

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Une fois installé, vous pouvez charger un classeur existant ou en créer un nouveau, lire et écrire des valeurs de cellules, appliquer des formules, définir des chaînes de format et enregistrer au format XLSX, le tout grâce à une API claire et bien documentée. Aucun logiciel COM, aucune dépendance à Office et aucune configuration serveur spéciale ne sont requis.

Pour obtenir la documentation complète de l'API, consultez le guide de démarrage IronXL , le guide de migration C# Excel Interop et les exemples de code IronXL . Vous pouvez également comparer IronXL à d'autres bibliothèques Excel dans les articles de comparaison IronXL .

Une licence d'essai gratuite vous permet de tester toutes les fonctionnalités dans votre propre projet avant de vous engager. Lorsque vous serez prêt pour le déploiement en production, une licence commerciale IronXL supprimera le filigrane d'essai et inclura une assistance prioritaire. Commencez par l'essai gratuit et constatez à quel point l'automatisation Excel multiplateforme peut être simplifiée.