Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Créer un pivot Excel Blog
UTILISATION D'IRONXL

Comment créer des tableaux croisés dynamiques dans Excel à l'aide de C# sans les dépendances d'Office ?

Jordi Bardia
Jordi Bardia
Mis à jour:

La création de tableaux croisés dynamiques par programmation en C# nécessite traditionnellement Office Interop avec une gestion COM complexe, mais des bibliothèques modernes comme IronXL permettent la génération de tableaux croisés dynamiques multiplateformes sans installation d'Office, prenant en charge les conteneurs Docker et les déploiements cloud tout en éliminant les fuites de mémoire.

La génération de tableaux croisés dynamiques par programmation nécessite soit C# Interop avec ses dépendances Office, soit des bibliothèques modernes comme IronXL qui fonctionnent indépendamment. Ce tutoriel présente les deux approches, en soulignant pourquoi les développeurs choisissent de plus en plus la solution IronXL, adaptée aux conteneurs, plutôt que les méthodes traditionnelles.

Dans cet article, nous apprendrons comment modifier, créer, concevoir et calculer des tableaux croisés dynamiques avec analyse automatique et gestion des erreurs. Que vous déployiez sur AWS ou que vous exécutiez sur Azure , ce guide couvre l'approche moderne de l'automatisation d'Excel.

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

Pourquoi les tableaux croisés dynamiques sont-ils importants pour l'analyse des données ?

Le tableau croisé dynamique est l'un des outils les plus puissants d'Excel pour synthétiser de grands ensembles de données. Il offre un moyen simple d'afficher, de comprendre et d'analyser des données numériques. Les tableaux croisés dynamiques sont disponibles non seulement dans Excel, mais aussi dans Google Sheets, Apple Numbers et lors de l'exportation au format CSV. Ils transforment les données brutes en informations pertinentes en créant des résumés interactifs qui renvoient à vos données sous-jacentes.

Pour les développeurs travaillant avec des formules Excel en C# , les tableaux croisés dynamiques représentent des fonctionnalités d'agrégation essentielles. Contrairement aux fonctions mathématiques de base qui opèrent sur des cellules individuelles, les tableaux croisés dynamiques peuvent agréger les fonctions Excel sur des ensembles de données entiers.

Quand dois-je utiliser des tableaux croisés dynamiques plutôt que des rapports classiques ?

Découvrons comment créer des tableaux croisés dynamiques de manière incorrecte, puis apprenons la bonne méthode en C# :

Comment créer un tableau croisé dynamique dans les tableaux Excel à l'aide de l'interopérabilité C#?

Pourquoi l'interopérabilité est-elle encore utilisée malgré ses limitations ?

C# Excel Interop fournit un accès direct à la fonctionnalité de tableau croisé dynamique d'Excel par le biais de l'automatisation COM. Voici l'approche traditionnelle que de nombreux développeurs trouvent lorsqu'ils recherchent comment générer un tableau croisé dynamique en C# : (Dépréciée)

Comment créer des tableaux croisés dynamiques à l'ancienne en .NET

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

// Create Excel application instance - requires Office installation
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 - COM objects require explicit cleanup
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 - traditional row/column/data setup
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 - critical for preventing memory leaks
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();

// Release COM objects to prevent memory leaks - must release in reverse order
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 - requires Office installation
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 - COM objects require explicit cleanup
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 - traditional row/column/data setup
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 - critical for preventing memory leaks
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();

// Release COM objects to prevent memory leaks - must release in reverse order
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);
Imports Excel = Microsoft.Office.Interop.Excel
Imports System.Runtime.InteropServices

' Create Excel application instance - requires Office installation
Dim xlApp As New Excel.Application()
Dim xlWorkbook As Excel.Workbook = xlApp.Workbooks.Open("C:\Data\SalesData.xlsx")
Dim xlSheet As Excel.Worksheet = CType(xlWorkbook.Sheets(1), Excel.Worksheet)
Dim xlPivotSheet As Excel.Worksheet = CType(xlWorkbook.Sheets.Add(), Excel.Worksheet)

' Define data range for pivot table
Dim dataRange As Excel.Range = xlSheet.UsedRange

' Create pivot cache and pivot table - COM objects require explicit cleanup
Dim pivotCache As Excel.PivotCache = xlWorkbook.PivotCaches().Create(Excel.XlPivotTableSourceType.xlDatabase, dataRange, Type.Missing)
Dim pivotTable As Excel.PivotTable = pivotCache.CreatePivotTable(xlPivotSheet.Cells(3, 1), "SalesPivot", Type.Missing, Type.Missing)

' Configure pivot table fields - traditional row/column/data setup
Dim productField As Excel.PivotField = CType(pivotTable.PivotFields("Product"), Excel.PivotField)
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField
productField.Position = 1
Dim regionField As Excel.PivotField = CType(pivotTable.PivotFields("Region"), Excel.PivotField)
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField
regionField.Position = 1
Dim salesField As Excel.PivotField = CType(pivotTable.PivotFields("Sales"), Excel.PivotField)
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum)

' Save and cleanup - critical for preventing memory leaks
xlWorkbook.SaveAs("C:\Data\PivotReport.xlsx")
xlWorkbook.Close()
xlApp.Quit()

' Release COM objects to prevent memory leaks - must release in reverse order
Marshal.ReleaseComObject(pivotTable)
Marshal.ReleaseComObject(pivotCache)
Marshal.ReleaseComObject(xlPivotSheet)
Marshal.ReleaseComObject(xlSheet)
Marshal.ReleaseComObject(xlWorkbook)
Marshal.ReleaseComObject(xlApp)
$vbLabelText   $csharpLabel

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 de Microsoft elle-même déconseille désormais cette approche pour le développement moderne. Pour les déploiements conteneurisés, il est essentiel de pouvoir travailler avec Excel sans interopérabilité .

Que se passe-t-il si les objets COM ne sont pas libérés correctement ?

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

Pourquoi l'interopérabilité échoue-t-elle dans les environnements conteneurisés ?

L'approche Interop présente plusieurs défis importants pour les pratiques DevOps modernes et la configuration Docker :

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.

Détails des limitations de la plateforme : Cette solution obsolète ne fonctionne que sous Windows avec Office installé et peut être extrêmement lente, déroutante pour l'utilisateur et peut entraîner des fuites de mémoire. Aucun support pour Linux, macOS, les conteneurs Docker, ou des plateformes cloud comme Azure Functions.

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 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 natifs pour Excel, il offre de puissantes capacités d'agrégation.

Comment créer un tableau croisé dynamique XLSX ou XLS par programmation de manière moderne

using IronXL;
using System.Linq;
using System.Data; // Essential for DataTable manipulation
using static System.Data.DataTableExtensions; // Extension methods for LINQ queries

class Program
{
    static void Main(string[] args)
    {
        // Load Excel file - works on all platforms without Office
        WorkBook workbook = WorkBook.Load("SalesData.xlsx");
        WorkSheet dataSheet = workbook.WorkSheets[0];

        // Convert to DataTable for powerful manipulation - maintains data types
        var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers

        // Create pivot-style aggregation using LINQ - no COM objects needed
        var pivotData = dataTable.AsEnumerable()
            .GroupBy(row => new {
                Product = row["Product"].ToString(),
                Region = row["Region"].ToString()
            }) // Group by multiple dimensions
            .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 - no Excel process started
        WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

        // Build cross-tabulation structure programmatically
        var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
        var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);

        // Create headers with formatting options
        pivotSheet["A1"].Value = "Product/Region";
        int col = 2;
        foreach (var region in regions)
        {
            pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // Dynamic column addressing
            col++;
        }

        // Populate pivot data - memory efficient for large datasets
        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 - maintains live calculations
        pivotSheet[$"A{row}"].Value = "Total"; // Grand totals row
        for (int c = 2; c <= regions.Count() + 1; c++)
        {
            // Formula references ensure dynamic updates
            pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = 
                $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
        }

        // Apply professional formatting - currency format for sales data
        var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
        dataRange.FormatString = "$#,##0.00";

        // Save without Office dependencies - works in containers
        workbook.SaveAs("PivotReport.xlsx");
    }
}
using IronXL;
using System.Linq;
using System.Data; // Essential for DataTable manipulation
using static System.Data.DataTableExtensions; // Extension methods for LINQ queries

class Program
{
    static void Main(string[] args)
    {
        // Load Excel file - works on all platforms without Office
        WorkBook workbook = WorkBook.Load("SalesData.xlsx");
        WorkSheet dataSheet = workbook.WorkSheets[0];

        // Convert to DataTable for powerful manipulation - maintains data types
        var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers

        // Create pivot-style aggregation using LINQ - no COM objects needed
        var pivotData = dataTable.AsEnumerable()
            .GroupBy(row => new {
                Product = row["Product"].ToString(),
                Region = row["Region"].ToString()
            }) // Group by multiple dimensions
            .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 - no Excel process started
        WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

        // Build cross-tabulation structure programmatically
        var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
        var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);

        // Create headers with formatting options
        pivotSheet["A1"].Value = "Product/Region";
        int col = 2;
        foreach (var region in regions)
        {
            pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // Dynamic column addressing
            col++;
        }

        // Populate pivot data - memory efficient for large datasets
        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 - maintains live calculations
        pivotSheet[$"A{row}"].Value = "Total"; // Grand totals row
        for (int c = 2; c <= regions.Count() + 1; c++)
        {
            // Formula references ensure dynamic updates
            pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = 
                $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
        }

        // Apply professional formatting - currency format for sales data
        var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
        dataRange.FormatString = "$#,##0.00";

        // Save without Office dependencies - works in containers
        workbook.SaveAs("PivotReport.xlsx");
    }
}
Imports IronXL
Imports System.Linq
Imports System.Data ' Essential for DataTable manipulation
Imports System.Data.DataTableExtensions ' Extension methods for LINQ queries

Module Program
    Sub Main(args As String())
        ' Load Excel file - works on all platforms without Office
        Dim workbook As WorkBook = WorkBook.Load("SalesData.xlsx")
        Dim dataSheet As WorkSheet = workbook.WorkSheets(0)

        ' Convert to DataTable for powerful manipulation - maintains data types
        Dim dataTable = dataSheet.ToDataTable(True) ' True = use first row as column headers

        ' Create pivot-style aggregation using LINQ - no COM objects needed
        Dim pivotData = dataTable.AsEnumerable() _
            .GroupBy(Function(row) New With {
                Key .Product = row("Product").ToString(),
                Key .Region = row("Region").ToString()
            }) _
            .Select(Function(g) New With {
                .Product = g.Key.Product,
                .Region = g.Key.Region,
                .TotalSales = g.Sum(Function(row) Convert.ToDecimal(row("Sales"))),
                .AverageSale = g.Average(Function(row) Convert.ToDecimal(row("Sales"))),
                .Count = g.Count()
            })

        ' Create pivot report worksheet - no Excel process started
        Dim pivotSheet As WorkSheet = workbook.CreateWorkSheet("PivotReport")

        ' Build cross-tabulation structure programmatically
        Dim products = pivotData.Select(Function(p) p.Product).Distinct().OrderBy(Function(p) p)
        Dim regions = pivotData.Select(Function(p) p.Region).Distinct().OrderBy(Function(r) r)

        ' Create headers with formatting options
        pivotSheet("A1").Value = "Product/Region"
        Dim col As Integer = 2
        For Each region In regions
            pivotSheet($"{ChrW(Asc("A"c) + col - 1)}1").Value = region ' Dynamic column addressing
            col += 1
        Next

        ' Populate pivot data - memory efficient for large datasets
        Dim row As Integer = 2
        For Each product In products
            pivotSheet($"A{row}").Value = product
            col = 2
            For Each region In regions
                Dim sales = pivotData _
                    .Where(Function(p) p.Product = product AndAlso p.Region = region) _
                    .Select(Function(p) p.TotalSales) _
                    .FirstOrDefault()
                pivotSheet($"{ChrW(Asc("A"c) + col - 1)}{row}").Value = sales
                col += 1
            Next
            row += 1
        Next

        ' Add totals using Excel formulas - maintains live calculations
        pivotSheet($"A{row}").Value = "Total" ' Grand totals row
        For c As Integer = 2 To regions.Count() + 1
            ' Formula references ensure dynamic updates
            pivotSheet($"{ChrW(Asc("A"c) + c - 1)}{row}").Formula = 
                $"=SUM({ChrW(Asc("A"c) + c - 1)}2:{ChrW(Asc("A"c) + c - 1)}{row - 1})"
        Next

        ' Apply professional formatting - currency format for sales data
        Dim dataRange = pivotSheet($"B2:{ChrW(Asc("A"c) + regions.Count())}{row}")
        dataRange.FormatString = "$#,##0.00"

        ' Save without Office dependencies - works in containers
        workbook.SaveAs("PivotReport.xlsx")
    End Sub
End Module
$vbLabelText   $csharpLabel

Cette approche moderne crée des tableaux croisés dynamiques qui fonctionnent parfaitement dans les conteneurs Docker et prennent en charge différents formats Excel . Vous pouvez également exporter vers différents formats, notamment CSV , JSON et XML .

À quoi ressemble le résultat ?

Feuille de calcul Excel présentant à gauche les données de ventes initiales et à droite un tableau croisé dynamique récapitulant les ventes de produits par région.

Comment créer des résumés dynamiques avec les formules IronXL ?

Quand dois-je utiliser des formules plutôt que des agrégations statiques ?

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 . Cette approche est plus élégante et plus facile à maintenir, avec un code facile à comprendre sans manuels ni assistance. Il fonctionne bien avec la mise en forme conditionnelle pour la présentation visuelle des données.

Comment les résumés basés sur des formules maintiennent-ils les liens entre les données ?

// Load the workbook - container-friendly approach
WorkBook workbook = WorkBook.Load(inputPath);

// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet"; // Named reference for formulas

// Convert worksheet to DataTable for efficient processing
DataTable dataTable = dataSheet.ToDataTable(true);

// Create new summary worksheet - no COM objects
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region combinations using LINQ
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 with proper formatting
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with formulas - maintains live data connection
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

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

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

    rowIndex++;
}

// Optional: add total row with grand totals
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";

// Apply number formatting for professional appearance
var salesColumn = summarySheet[$"C2:C{rowIndex}"];
salesColumn.FormatString = "$#,##0.00";

// Save output file - works in any environment
workbook.SaveAs(outputPath);  // No Office required
// Load the workbook - container-friendly approach
WorkBook workbook = WorkBook.Load(inputPath);

// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet"; // Named reference for formulas

// Convert worksheet to DataTable for efficient processing
DataTable dataTable = dataSheet.ToDataTable(true);

// Create new summary worksheet - no COM objects
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region combinations using LINQ
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 with proper formatting
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with formulas - maintains live data connection
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

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

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

    rowIndex++;
}

// Optional: add total row with grand totals
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";

// Apply number formatting for professional appearance
var salesColumn = summarySheet[$"C2:C{rowIndex}"];
salesColumn.FormatString = "$#,##0.00";

// Save output file - works in any environment
workbook.SaveAs(outputPath);  // No Office required
Imports System.Data
Imports System.Linq

' Load the workbook - container-friendly approach
Dim workbook As WorkBook = WorkBook.Load(inputPath)

' Rename the first worksheet so formulas reference correctly
Dim dataSheet As WorkSheet = workbook.WorkSheets(0)
dataSheet.Name = "DataSheet" ' Named reference for formulas

' Convert worksheet to DataTable for efficient processing
Dim dataTable As DataTable = dataSheet.ToDataTable(True)

' Create new summary worksheet - no COM objects
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("DynamicSummary")

' Get unique product-region combinations using LINQ
Dim uniqueCombos = dataTable.AsEnumerable() _
    .Select(Function(row) New With {
        .Product = row("Product").ToString(),
        .Region = row("Region").ToString()
    }) _
    .Distinct() _
    .OrderBy(Function(x) x.Product) _
    .ThenBy(Function(x) x.Region)

' Add header row with proper formatting
summarySheet("A1").Value = "Product"
summarySheet("B1").Value = "Region"
summarySheet("C1").Value = "Total Sales"
summarySheet("D1").Value = "Count"

' Populate rows with formulas - maintains live data connection
Dim rowIndex As Integer = 2
For Each combo In uniqueCombos
    summarySheet($"A{rowIndex}").Value = combo.Product
    summarySheet($"B{rowIndex}").Value = combo.Region

    ' SUMIFS formula for conditional aggregation
    summarySheet($"C{rowIndex}").Formula =
        $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,""{combo.Product}"",DataSheet!B:B,""{combo.Region}"")"

    ' COUNTIFS for record counting
    summarySheet($"D{rowIndex}").Formula =
        $"=COUNTIFS(DataSheet!A:A,""{combo.Product}"",DataSheet!B:B,""{combo.Region}"")"

    rowIndex += 1
Next

' Optional: add total row with grand totals
summarySheet($"A{rowIndex}").Value = "Total"
summarySheet($"C{rowIndex}").Formula = $"=SUM(C2:C{rowIndex - 1})"
summarySheet($"D{rowIndex}").Formula = $"=SUM(D2:D{rowIndex - 1})"

' Apply number formatting for professional appearance
Dim salesColumn = summarySheet($"C2:C{rowIndex}")
salesColumn.FormatString = "$#,##0.00"

' Save output file - works in any environment
workbook.SaveAs(outputPath) ' No Office required
$vbLabelText   $csharpLabel

Ces formules maintiennent une connexion en direct aux données sources et se mettent à jour automatiquement lorsque la feuille de données est modifiée, de manière similaire à l'actualisation des tableaux croisés dynamiques, mais sans dépendances d'interopérabilité. Pour les scénarios complexes, vous pouvez créer des graphiques Excel ou utiliser des plages nommées pour une meilleure gestion des formules.

Quels avantages en termes de performance offrent les approches basées sur des formules ?

L'application de ce code à notre fichier Excel d'exemple produit le résultat suivant :

Feuille de calcul Excel présentant les données de vente de produits, avec des colonnes pour le produit, la région, le total des ventes et la quantité. Elle affiche divers appareils électroniques (ordinateurs portables, téléphones, tablettes) dans différentes régions, avec des valeurs de vente nulles.

Les approches basées sur des formules offrent des avantages significatifs en termes de performances : elles s'exécutent nativement dans le moteur de calcul d'Excel, prennent en charge les calculs en arrière-plan et s'intègrent parfaitement à la configuration d'impression d'Excel pour la création de rapports. Vous pouvez également appliquer une mise en forme et un style aux cellules pour améliorer la lisibilité.

Comment C# Interop se compare-t-il à IronXL pour les tableaux croisés dynamiques ?

Quels scénarios de déploiement privilégient chaque approche ?

Aspect C# Interop IronXL
Bureau requis Oui - Installation complète Non - Bibliothèque autonome
Prise en charge de la plate-forme Windows uniquement Windows, Linux, macOS, Docker
Gestion de la mémoire Nettoyage manuel de COM requis Collecte automatique des déchets .NET
Déploiement Complexe - Licences Office Simple - DLL unique
Performance Lent - Démarrage du processus Excel Rapide - Calculs en mémoire
Compatible avec le cloud Non - Limites d'Azure Oui - Prise en charge d'Azure Functions
Tableaux croisés dynamiques natifs Oui Non - Alternatives à l'agrégation
Vitesse de développement Lent - complexité de COM API rapide et intuitive
Support conteneur Non - Impossible d'exécuter dans Docker Oui - Prise en charge complète de Docker
Gestion des licences Licence Office par machine Clés de licence simples

Quelles sont les ressources nécessaires pour chaque solution ?

L'interopérabilité C# nécessite des ressources système importantes : une installation complète d'Office (2 à 4 Go d'espace disque), un système d'exploitation Windows, une quantité de RAM suffisante pour les processus Excel et des privilèges d'administrateur pour l'enregistrement COM. En revanche, IronXL ne nécessite que l'environnement d'exécution .NET et environ 50 Mo pour la bibliothèque, ce qui le rend idéal pour les environnements aux ressources limitées . Les limites de taille des fichiers d'IronXL sont bien documentées pour la planification des capacités.

Quelle approche devriez-vous choisir ?

Quand l'interopérabilité a-t-elle encore du sens ?

Choisissez C# Interop quand :

  • Les objets de tableau croisé dynamique natifs d'Excel sont absolument nécessaires
  • Je travaille exclusivement sous Windows avec Office installé.
  • Déploiement uniquement sur les systèmes de bureau que vous administrez
  • Le code existant dépend d'Interop
  • Utilisation des anciennes versions du framework .NET
  • Nécessite des fonctionnalités Excel spécifiques non disponibles ailleurs

Pour ces scénarios limités, assurez-vous d'une gestion appropriée des erreurs et des modèles de nettoyage COM.

Pourquoi les équipes DevOps préfèrent-elles IronXL ?

Choisissez IronXL lorsque :

  • Déploiement sur des serveurs ou des environnements cloud (Azure, AWS)
  • Création d'applications multiplateformes
  • Exiger de meilleures performances et une plus grande fiabilité
  • Éviter les coûts de licence d'Office
  • Besoin d'un code plus simple et plus facile à maintenir
  • Compatible avec les systèmes Mac, iOS, Android ou Linux
  • Expérience avec les technologies modernes .NET Core et .NET 5+
  • Souhaitant un contrôle programmatique complet sur la configuration du tableau croisé dynamique
  • Création d'applications Blazor
  • Création de microservices qui chargent des fichiers Excel à partir de bases de données SQL

IronXL offre également des fonctionnalités de sécurité étendues, notamment le chiffrement des classeurs et la protection des feuilles de calcul .

Quelle est la meilleure voie à suivre pour le développement moderne ?

Bien que C# Excel Interop puisse développer 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. L'ensemble de fonctionnalités d'IronXL offre des alternatives puissantes grâce à l'agrégation de données et aux résumés basés sur des formules, éliminant ainsi les dépendances à Office tout en conservant les capacités analytiques.

Pour les développeurs recherchant des solutions de création 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. Vous pouvez créer des feuilles de calcul , charger des fichiers existants et même travailler avec VB.NET si nécessaire.

Les pratiques DevOps modernes exigent des solutions compatibles avec les conteneurs. IronXL offre cela grâce à une documentation complète , de nombreux exemples et des mises à jour régulières qui suivent l'évolution des besoins de déploiement.

Commencez avec IronXL maintenant.
green arrow pointer

Prêt à moderniser votre automatisation Excel et à créer votre propre 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 l'essai gratuit ou Achetez une licence IronXL pour éliminer les dépendances Interop dans vos applications de production.

Questions Fréquemment Posées

Quel est l'avantage d'utiliser IronXL pour créer des tableaux croisés dynamiques dans Excel ?

IronXL permet de créer des tableaux croisés dynamiques dans Excel sans avoir recours aux dépendances d'Office, ce qui en fait une solution plus rationalisée et plus efficace par rapport aux méthodes d'interopération C# traditionnelles.

Comment IronXL gère-t-il la manipulation des données pour les tableaux croisés dynamiques ?

IronXL offre de puissantes capacités de manipulation de données, permettant la création de rapports de type pivot sans les complications associées à Excel Interop.

IronXL peut-il être utilisé indépendamment d'Excel Interop ?

Oui, IronXL fonctionne de manière indépendante, permettant aux développeurs de générer des tableaux croisés dynamiques sans dépendre d'Excel Interop et de ses dépendances associées.

Pourquoi les développeurs préfèrent-ils IronXL aux méthodes d'interopérabilité traditionnelles pour Excel ?

Les développeurs préfèrent IronXL car il simplifie le processus de création de tableaux croisés dynamiques en éliminant les dépendances Office, requises par les méthodes Interop traditionnelles.

L'utilisation d'IronXL nécessite-t-elle l'installation de Microsoft Office ?

Non, IronXL ne nécessite pas l'installation de Microsoft Office, car il fonctionne indépendamment d'Office, contrairement à C# Interop qui nécessite des dépendances Office.

IronXL est-il compatible avec la programmation C# moderne ?

Oui, IronXL est conçu pour s'intégrer de manière transparente à la programmation C# moderne, offrant une approche contemporaine pour traiter les tâches de manipulation de données Excel.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit