Comment créer un tableau croisé dynamique Excel en C# ?

Pourquoi cette approche est-elle considérée comme obsolète dans .NET ?

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;
// Row area and column area 
// 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); // fields by field
// 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;
// Row area and column area 
// 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); // fields by field
// 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);

Cet exemple Interop crée un tableau croisé dynamique Excel natif avec le produit comme lignes, la région comme colonnes et les ventes additionnées dans la zone de données. Bien que fonctionnelle, cette approche nécessite l'installation de Microsoft Office et une gestion attentive des objets COM. La documentation Microsoft explique pourquoi cette approche n'est pas moderne. Du point de vue DevOps , cette approche est particulièrement problématique car elle ne peut pas être conteneurisée efficacement : vous ne pouvez pas installer Microsoft Office dans un conteneur Docker Linux ni le déployer dans des environnements sans serveur .

Quels sont les problèmes posés par l'interopérabilité du C# ? L'approche Interop présente plusieurs défis importants qui la rendent inadaptée aux pratiques `DevOps` modernes et aux déploiements natifs du cloud. Malheureusement, Stack Overflow et d'autres sites web de programmation continuent de le recommander car ils sont restés figés dans le temps avec des discussions datant du début des années 2000. **Dépendances de déploiement :** Nécessite l'installation de Microsoft Office sur chaque machine exécutant le code source, y compris les serveurs de production. Cela ajoute des coûts de licence et une complexité de déploiement. **Gestion de la mémoire :** les objets COM doivent être libérés explicitement à l'aide de Marshal.ReleaseComObject(). Oublier ne serait-ce qu'un seul objet provoque le blocage des processus Excel en mémoire, comme [documenté de manière approfondie sur Stack Overflow](https://stackoverflow.com/questions/158706/how-do-i-properly-clean-up-excel-interop-objects). Considérez le cache pivot. **Limitations de la plateforme** : Cette solution fonctionne uniquement sous Windows avec Office installé. Cela peut être incroyablement lent et entraîner des fuites de mémoire. Aucune prise en charge de [Linux](https://ironsoftware.com/csharp/excel/get-started/linux/) , [macOS](https://ironsoftware.com/csharp/excel/get-started/macos/) , des conteneurs Docker ou des plateformes cloud comme [Azure Functions](https://ironsoftware.com/csharp/excel/get-started/azure/) . Cela limite considérablement les options de déploiement et empêche l'utilisation des plateformes modernes d'orchestration de conteneurs. **Problèmes de performance :** Le lancement d'instances d'application Excel est lent et gourmand en ressources, notamment pour le traitement côté serveur. **Compatibilité des versions :** Les différentes versions d'Office peuvent avoir des interfaces COM différentes, ce qui peut entraîner des problèmes de compatibilité dans différents environnements. ## Comment IronXL crée-t-il un tableau croisé dynamique de manière programmatique sans interopérabilité ? [IronXL](https://ironsoftware.com/csharp/excel/docs/) aborde la création de tableaux croisés dynamiques différemment, en utilisant du code géré sans dépendances COM. Bien qu'il ne crée pas de tableaux croisés dynamiques Excel natifs, il offre de puissantes capacités d'agrégation, idéales pour les déploiements conteneurisés et les architectures natives du cloud. [Les optimisations de performance](https://ironsoftware.com/csharp/excel/product-updates/milestones-performance/) de la bibliothèque incluent une augmentation de vitesse de 40 fois et une réduction de l'utilisation de la mémoire de 19,5 Go à moins de 1 Go, ce qui la rend idéale pour les environnements de conteneurs aux ressources limitées. ### Qu'est-ce qui rend cette approche moderne pour les fichiers XLSX ou XLS ? ```cs using IronXL; using System.Linq; using System.Data; // Keep this namespace using static System.Data.DataTableExtensions; // Use 'using static' for DataTableExtensions class Program { static void Main(string[] args) { // Load Excel file - no Office required WorkBook workbook = WorkBook.Load("SalesData.xlsx"); WorkSheet dataSheet = workbook.WorkSheets[0]; // Convert to DataTable for powerful manipulation var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers // Create pivot-style aggregation using LINQ var pivotData = dataTable.AsEnumerable() .GroupBy(row => new { Product = row["Product"].ToString(), Region = row["Region"].ToString() }) //range .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 pivot report worksheet WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport"); // Build cross-tabulation structure var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p); var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r); // Create headers pivotSheet["A1"].Value = "Product/Region"; int col = 2; foreach (var region in regions) { pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // string col++; } // Populate pivot data int row = 2; foreach (var product in products) { pivotSheet[$"A{row}"].Value = product; col = 2; foreach (var region in regions) { var sales = pivotData .Where(p => p.Product == product && p.Region == region) .Select(p => p.TotalSales) .FirstOrDefault(); pivotSheet[$"{(char)('A' + col - 1)}{row}"].Value = sales; col++; } row++; } // Add totals using Excel formulas pivotSheet[$"A{row}"].Value = "Total"; // grand totals for (int c = 2; c <= regions.Count() + 1; c++) { pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})"; } // Proceeding to apply formatting var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"]; dataRange.FormatString = "$#,##0.00"; workbook.SaveAs("PivotReport.xlsx"); } } ``` Voici comment créer des tableaux croisés dynamiques de manière compatible avec les conteneurs. Cette approche fonctionne parfaitement dans les conteneurs Docker, les pods Kubernetes et les fonctions sans serveur, sans aucune dépendance externe. L'application complète peut être empaquetée dans une image conteneur légère qui s'exécute partout où .NET est pris en charge. ### À quoi ressemble le résultat du tableau croisé dynamique ? ! [Comparaison des données de ventes Excel originales et du tableau croisé dynamique généré présentant les ventes de produits agrégées par région avec les totaux](/static-assets/excel/blog/create-excel-pivot-table-csharp/create-excel-pivot-table-csharp-1.webp) Le résultat démontre comment IronXL transforme les données de ventes brutes en un rapport croisé dynamique structuré sans nécessiter l'installation d'Excel, ce qui le rend idéal pour la production de rapports automatisés dans les pipelines CI/CD. ## Comment créer des résumés dynamiques avec les formules IronXL ? Pour les scénarios nécessitant des mises à jour dynamiques similaires à la fonctionnalité d'actualisation des tableaux croisés dynamiques, IronXL peut exploiter [les formules intégrées d'Excel](https://ironsoftware.com/csharp/excel/examples/excel-formulas-csharp/) . Cette approche est préférable : vos données sont traitées de manière beaucoup plus moderne et élégante. Le code est facile à comprendre et à configurer sans avoir besoin de contacter le support technique ni de lire les manuels. Cette approche est particulièrement précieuse dans les environnements conteneurisés où vous avez besoin [de calculs basés sur des formules](https://ironsoftware.com/csharp/excel/how-to/math-functions/) qui se mettent à jour automatiquement. ### Comment les résumés basés sur des formules se mettent-ils à jour automatiquement ? ```cs // Load the workbook WorkBook workbook = WorkBook.Load(inputPath); // Rename the first worksheet so formulas reference correctly WorkSheet dataSheet = workbook.WorkSheets[0]; dataSheet.Name = "DataSheet"; // Convert worksheet to DataTable DataTable dataTable = dataSheet.ToDataTable(true); // Create new summary worksheet WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary"); // Get unique product-region combinations var uniqueCombos = dataTable.AsEnumerable() .Select(row => new { Product = row["Product"].ToString(), Region = row["Region"].ToString() }) .Distinct() .OrderBy(x => x.Product) .ThenBy(x => x.Region); // Add header row summarySheet["A1"].Value = "Product"; summarySheet["B1"].Value = "Region"; summarySheet["C1"].Value = "Total Sales"; summarySheet["D1"].Value = "Count"; // Populate rows with formulas int rowIndex = 2; foreach (var combo in uniqueCombos) { summarySheet[$"A{rowIndex}"].Value = combo.Product; summarySheet[$"B{rowIndex}"].Value = combo.Region; // Adjust column references if your Sales column is C (not D) 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}\")"; rowIndex++; } // Optional: add total row summarySheet[$"A{rowIndex}"].Value = "Total"; summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})"; summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})"; // Save output file workbook.SaveAs(outputPath); //filename ``` Ces formules maintiennent des connexions actives aux données source, se mettant à jour automatiquement lorsque la feuille de données change - similaire au comportement de rafraîchissement des tableaux croisés mais sans les dépendances Interop. Cette approche est idéale pour les microservices conteneurisés qui doivent générer des rapports dynamiques sans dépendances externes. ### Quels résultats pouvez-vous attendre des résumés dynamiques ? Si nous appliquons ce code au fichier Excel d'exemple de l'exemple précédent, nous obtiendrons le résultat suivant : [Feuille de calcul Excel affichant les données de vente de produits avec des formules de synthèse dynamiques présentant les produits (ordinateur portable, téléphone, tablette) par région, avec totaux et nombres calculés.](/static-assets/excel/blog/create-excel-pivot-table-csharp/create-excel-pivot-table-csharp-2.webp) L'approche de synthèse dynamique fournit des calculs en temps réel qui se mettent à jour automatiquement lorsque les données sources changent, ce qui la rend idéale pour les pipelines de reporting automatisés dans les environnements conteneurisés. Cela élimine le besoin d'actualisations planifiées des tableaux croisés dynamiques et fonctionne de manière transparente dans les applications [.NET MAUI](https://ironsoftware.com/csharp/excel/get-started/read-create-excel-net-maui/) et [Blazor](https://ironsoftware.com/csharp/excel/get-started/blazor-read-excel-file-tutorial/) . ## Comment comparer Interopérabilité C# et IronXL pour les tableaux croisés dynamiques ?

Aspect	Interopérabilité C#	IronXL
Bureau requis	Oui - Installation complète	Non - Bibliothèque autonome
support de la plateforme	Windows uniquement	Windows, Linux, macOS, Docker
Gestion de la mémoire	Nettoyage manuel du serveur COM requis	Collecte automatique des déchets .NET
Déploiement	Complexe - Licence de bureau	Simple - Une seule DLL
Performance	Démarrage lent du processus Excel	Rapide - Calculs en mémoire
Compatible avec le cloud	Non - Limitations Azure	Oui - Prise en charge d'Azure Functions
Tableaux croisés dynamiques natifs	Oui	Non - Alternatives d'agrégation
Vitesse de développement	Lent - Complexité COM	API rapide et intuitive
Prise en charge des conteneurs	Non - Impossible de conteneuriser Office	Oui - Compatible Docker
bilans de santé	Difficile - Surveillance du processus COM	Facile - Surveillance .NET standard

Du point de vue `DevOps` , l'architecture d'IronXL offre des avantages significatifs pour les scénarios de déploiement modernes. La capacité de la bibliothèque à s'exécuter dans des conteneurs sans dépendances externes vous permet de créer des images Docker légères, rapides à déployer et évolutives efficacement. Les contrôles d'intégrité peuvent être mis en œuvre à l'aide de modèles .NET standard, et [les fonctionnalités de sécurité](https://ironsoftware.com/csharp/excel/troubleshooting/ironxl-security-cve/) de la bibliothèque incluent la certification `DigiCert` et l'absence d'interfaces COM, réduisant ainsi les vecteurs d'attaque. ## Quelle approche devriez-vous choisir ? ### Quand faut-il utiliser l'interopérabilité C# ? Choisissez **Interopérabilité C#** lorsque : * Les objets de tableau croisé dynamique Excel natifs sont absolument nécessaires * Je travaille exclusivement sous Windows avec Office installé partout * Déploiement uniquement sur les systèmes de bureau que vous administrez * Le code existant hérité dépend de l'Interop * Utilisation des anciennes versions du framework .NET Vous n'envisagez pas de conteneuriser ou de migrer vers le cloud. ### Quand IronXL offre-t-il de meilleurs résultats ? Choisissez **IronXL** lorsque : * Déploiement sur des serveurs ou des environnements cloud (Azure, AWS) * Création d'applications multiplateformes s'exécutant dans des conteneurs * Nécessite des performances améliorées grâce à [une vitesse multipliée par 40](https://ironsoftware.com/csharp/excel/product-updates/milestones-enhancing/) * Éviter les coûts de licence Office et la complexité de déploiement * Besoin d'un code plus simple avec [gestion automatique des clés de licence](https://ironsoftware.com/csharp/excel/get-started/license-keys/) * Compatible avec les systèmes Mac, iOS, Android et Linux * Expérience en développement .NET Core et .NET 5-10 * Configuration programmatique des champs de tableau croisé dynamique * Création de microservices [exportant vers différents formats](https://ironsoftware.com/csharp/excel/how-to/c-sharp-export-to-excel/) * Mise en œuvre de rapports automatisés dans les pipelines CI/CD * Création de points de terminaison de contrôle d'intégrité pour l'orchestration de conteneurs * [Conversion entre différents formats de tableur](https://ironsoftware.com/csharp/excel/how-to/convert-spreadsheet-file-types/) ## Qu'avons-nous appris sur la création de tableaux croisés dynamiques en C# ? Bien que C# Excel Interop puisse créer des tableaux croisés dynamiques natifs, ses restrictions de déploiement et sa complexité le rendent de plus en plus impraticable pour les applications modernes, notamment dans les environnements conteneurisés. [IronXL](https://ironsoftware.com/csharp/excel/get-started/c-sharp-excel-interop/) offre des alternatives performantes grâce à l'agrégation de données et aux synthèses basées sur des formules, éliminant ainsi les dépendances à Office tout en conservant les capacités analytiques. Pour les développeurs et les ingénieurs `DevOps` à la recherche d'alternatives au développement de tableaux croisés dynamiques sans interopérabilité, IronXL offre une solution supérieure qui évite les complications liées à COM, fonctionne sur toutes les plateformes et simplifie le déploiement. Le compromis de ne pas avoir d'objets de tableau croisé natifs est compensé par une plus grande flexibilité, de meilleures performances, et l'élimination des exigences de licence Office. Plus important encore pour les équipes `DevOps` , IronXL permet une véritable infrastructure en tant que code grâce à des déploiements conteneurisés, une mise à l'échelle automatisée et une intégration transparente avec les pipelines CI/CD modernes. L'ensemble complet de fonctionnalités de la bibliothèque comprend [la mise en forme conditionnelle](https://ironsoftware.com/csharp/excel/how-to/conditional-formatting/) , [le style des cellules](https://ironsoftware.com/csharp/excel/examples/excel-style-cells-borders-fonts/) , [la prise en charge des formules](https://ironsoftware.com/csharp/excel/how-to/edit-formulas/) et [la validation des données](https://ironsoftware.com/csharp/excel/troubleshooting/excel-limitation-data-validation-for-string-lists/) , ce qui en fait une solution complète pour l'automatisation d'Excel dans les applications .NET modernes. Que vous [travailliez avec des fichiers CSV](https://ironsoftware.com/csharp/excel/how-to/csharp-read-csv-file/) , [gériez des feuilles de calcul](https://ironsoftware.com/csharp/excel/how-to/manage-worksheet/) ou [mettiez en œuvre des transformations de données complexes](https://ironsoftware.com/csharp/excel/how-to/export-dataset-datatable/) , IronXL fournit une API cohérente et facile à déployer.

Commencez avec IronXL maintenant.

Commencer gratuitement

Prêt à moderniser votre automatisation Excel et à créer du code de tableau croisé dynamique en C# moderne ? IronXL peut être mis en œuvre dans vos applications C# en quelques secondes grâce au gestionnaire de paquets NuGet. [Essayez la version d'essai gratuite](trial-license) pour éliminer les dépendances d'interopérabilité dans vos applications de production et simplifier vos déploiements de conteneurs.