Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Créer un tableau croisé dynamique dans Excel à l'aide de C# Interop
UTILISATION D'IRONXL

Comment créer des tableaux croisés dynamiques dans Excel avec C# sans interopérabilité

Jordi Bardia
Jordi Bardia
Mis à jour:

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.

Comment créer un tableau croisé dynamique dans Excel avec C# Interop vs IronXL: Image 1 - IronXL

Quelle est la différence entre Interop Excel et IronXL?

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.

Interop Excel vs IronXL : un aperçu
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

Comment créer un tableau croisé dynamique dans Excel avec C# Interop vs IronXL: Image 2 - Multiplateforme ?

Comment installer chaque bibliothèque ?

Configuration de l'interopérabilité Excel

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.Excel
Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.Excel
SHELL

Nontez 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.

Comment créer un tableau croisé dynamique dans Excel avec C# Interop ou IronXL: Image 3 - Installation d'Interop Excel

Configuration IronXL

Installez IronXL via NuGet sans configuration système supplémentaire :

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

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 IronXL pour connaître les options supplémentaires, notamment l'installation hors ligne et la configuration des références de projet.

Comment créer un tableau croisé dynamique dans Excel avec C# Interop vs IronXL: Image 4 - Installation

Commencez avec IronXL maintenant.
green arrow pointer

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

Le flux de travail du tableau croisé dynamique Interop suit une séquence stricte : créer un cache de tableau croisé dynamique à partir d'une plage source, puis construire un objet PivotTable sur une feuille de calcul séparée, 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);
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);
$vbLabelText   $csharpLabel

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.

Comment obtenir le même résultat avec IronXL?

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");
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");
$vbLabelText   $csharpLabel

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 .

Sortie

Comment créer un tableau croisé dynamique dans Excel avec C# Interop vs IronXL: Image 6 - Sortie IronXL

Comment créer un tableau croisé dynamique dans Excel avec C# Interop vs IronXL: Image 7 - Résumé des résultats

Quelles sont les principales différences en matière de déploiement et de maintenance ?

Exigences de déploiement

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 ajouter 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 sur site. La page des exigences système IronXL répertorie la matrice de compatibilité complète.

Gestion et Débogage des Erreurs

Les échecs d'interopérabilité se manifestent sous forme d'exceptions COM (COMException) difficiles à associer à des 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 lève des sous-classes standard System.Exception 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.

Mémoire et performances

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.

Comment choisir entre les deux approches ?

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é.

  • Le formatage exact du tableau croisé dynamique natif (segments, champs de dates groupés, éléments calculés) est requis dans le fichier de sortie.
  • Vous gérez une base de code d'interopérabilité existante et une réécriture complète n'est pas justifiée.

Choisissez IronXL lorsque :

L'application s'exécute sur un serveur, un conteneur ou une fonction cloud.

  • Un déploiement multiplateforme ou Linux est requis Vous souhaitez une logique d'agrégation de données testable par des tests unitaires, indépendante d'un processus Excel.
  • Vous devez traiter des fichiers Excel à grande échelle ou en parallèle

Pour la plupart des nouveaux projets .NET 10, IronXL est le choix par défaut. La bibliothèque IronXL permet également de lire des fichiers Excel en C# , de créer des graphiques , d'appliquer des styles de cellules , de travailler avec des formules et d'exporter des données Excel vers DataTable , réduisant ainsi le besoin de plusieurs bibliothèques dans votre pile technologique.

Comment créer un tableau croisé dynamique dans Excel avec C# Interop vs IronXL: Image 8 - Fonctionnalités

Quelles sont les fonctionnalités supplémentaires IronXL qui prennent en charge l'analyse des données ?

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 :

Tri et filtrage des données

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 de tri IronXL pour connaître les options de tri au niveau de la plage.

Application de la mise en forme conditionnelle

Mettez en évidence les valeurs aberrantes ou les seuils en appliquant des règles de mise en forme conditionnelle 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.

Lecture de fichiers Excel existants

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}");
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}");
$vbLabelText   $csharpLabel

Ce modèle fonctionne pour .xlsx, .xls, .csv et d'autres formats pris en charge par IronXL. Les détails concernant les formats pris en charge figurent dans la documentation relative au format de fichier IronXL .

Exporter au format CSV

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");
$vbLabelText   $csharpLabel

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.

Comment démarrer avec IronXL gratuitement ?

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";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
$vbLabelText   $csharpLabel

Vous pouvez également définir la clé via une variable d'environnement (IRONXL_LICENSEKEY) ou via 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 plus large pour des modèles couvrant ASP.NET Core, Azure Functions et Docker.

Comment créer un tableau croisé dynamique dans Excel avec C# Interop vs IronXL: Image 9 - Licences

Comment franchir la prochaine étape ?

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.

Questions Fréquemment Posées

Quel est l'avantage d'utiliser IronXL plutôt qu'Excel Interop pour créer des tableaux croisés dynamiques ?

IronXL offre un moyen plus moderne et plus efficace de créer des tableaux croisés dynamiques dans les fichiers Excel par rapport à l'interopération Excel traditionnelle. Il simplifie le processus et réduit la quantité de code standard nécessaire.

Puis-je créer un tableau croisé dynamique dans Excel en utilisant C# avec IronXL ?

Oui, IronXL fournit une méthode simple pour créer des tableaux croisés dynamiques dans Excel à l'aide de C#. Il permet aux développeurs de manipuler facilement les fichiers Excel sans avoir besoin de recourir à Excel Interop.

IronXL for .NET est-il compatible avec les applications .NET ?

IronXL est entièrement compatible avec les applications .NET, ce qui en fait un excellent choix pour les développeurs qui cherchent à intégrer les fonctionnalités d'Excel dans leurs projets C#.

IronXL nécessite-t-il l'installation d'Excel sur le système ?

Non, IronXL ne nécessite pas l'installation de Microsoft Excel sur le système. Il fonctionne de manière indépendante, ce qui constitue un avantage significatif par rapport à Excel Interop qui nécessite l'installation d'Excel.

Comment IronXL simplifie-t-il le processus de création de tableaux croisés dynamiques ?

IronXL simplifie le processus en fournissant une API conviviale qui réduit la nécessité d'un code passe-partout étendu, ce qui rend le processus de développement plus rapide et plus efficace.

Quelle est la configuration requise pour utiliser IronXL ?

IronXL for NET nécessite un environnement compatible avec le framework .NET, mais ne requiert pas l'installation de Microsoft Excel, ce qui simplifie le déploiement et réduit les dépendances.

IronXL peut-il gérer de grands fichiers Excel efficacement?

Oui, IronXL est conçu pour traiter efficacement les fichiers Excel volumineux, ce qui le rend adapté aux applications professionnelles qui nécessitent le traitement de quantités substantielles de données.

Y a-t-il une courbe d'apprentissage pour l'utilisation d'IronXL par rapport à Excel Interop ?

IronXL est conçu pour être intuitif et facile à apprendre, avec une documentation complète et des exemples, ce qui facilite son adoption par rapport à Excel Interop, plus complexe.

Quels types d'opérations Excel IronXL peut-il effectuer en plus de la création de tableaux croisés dynamiques ?

IronXL peut effectuer un large éventail d'opérations Excel, notamment la lecture et l'écriture de fichiers Excel, le formatage de cellules et l'application de formules, entre autres.

IronXL peut-il exporter des tableaux croisés dynamiques vers d'autres formats qu'Excel ?

Bien qu'IronXL soit principalement axé sur les opérations Excel, il prend également en charge l'exportation de données vers d'autres formats tels que CSV et PDF, en fonction des exigences de votre projet.

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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me