Documentation – Insérer un tableau croisé dynamique

Net: Formatage du tableau croisé dynamique

Mon, 01 Jan 0001 00:00:00 +0000

Apparence du tableau croisé dynamique

Comment créer un tableau croisé dynamique explique comment créer un tableau croisé dynamique simple. Cet article décrit comment personnaliser l’apparence d’un tableau croisé dynamique en définissant diverses propriétés :

Options de formatage du tableau croisé dynamique
Options de formatage des champs de tableau croisé dynamique
Options de formatage des champs de données

Configurer les options de formatage du tableau croisé dynamique

La classe PivotTable contrôle le tableau croisé dynamique global et peut être formatée de plusieurs manières.

Définition du type AutoFormat

Microsoft Excel propose un certain nombre de formats prédéfinis pour les rapports. Aspose.Cells prend également en charge ces options de formatage. Pour y accéder :

Définissez PivotTable.IsAutoFormat sur true.
Attribuer une option de mise en forme de l’énumération PivotTableAutoFormatType.

Paramétrage des options de formatage

L’exemple de code ci-dessous montre comment formater le tableau croisé dynamique pour afficher les totaux généraux pour les lignes et les colonnes, et comment définir l’ordre des champs du rapport. Il montre également comment définir une chaîne personnalisée pour les valeurs nulles.

Aspect et sensation du formatage manuel

Pour formater manuellement l’apparence du rapport de tableau croisé dynamique, au lieu d’utiliser des formats de rapport prédéfinis, utilisez les méthodes PivotTable.Format() et PivotTable.FormatAll(). Créez un objet de style pour votre formatage souhaité, par exemple :

Options de formatage de champ de tableau croisé dynamique

La classe PivotField représente un champ dans une table de données et peut être formatée de plusieurs manières. L’exemple de code ci-dessous montre comment :

Accéder aux champs de lignes.
Définir les sous-totaux.
Définir l’autotri.
Définir l’auto-affichage.

Formatage des champs de ligne/colonne/page

Formatage des champs de données

L’exemple de code ci-dessous montre comment définir les formats d’affichage et de nombres pour les champs de données.

Effacement des Champs de Tableau Croisé Dynamique

La classe PivotFieldCollection possède une méthode nommée Clear() qui vous permet d’effacer les champs de table de données. Utilisez-la lorsque vous voulez effacer tous les champs de table de données dans les zones, par exemple, les pages, les colonnes, les lignes ou les données. L’exemple de code ci-dessous montre comment effacer tous les champs de table de données dans une zone de données.

Net: Créer des tableaux croisés dynamiques et des graphiques croisés dynamiques

Mon, 01 Jan 0001 00:00:00 +0000

Un tableau croisé dynamique est un résumé interactif des enregistrements. Par exemple, vous pouvez avoir des centaines d’entrées de facture dans une liste dans une feuille de calcul. Un tableau croisé dynamique peut totaliser les factures par client, produit ou date. Avec Microsoft Excel, il est possible de réarranger rapidement les informations dans le tableau croisé dynamique en faisant glisser les boutons vers une nouvelle position.

Un graphique croisé dynamique est une représentation graphique interactive des données dans un tableau croisé dynamique. Les graphiques croisés dynamiques ont été introduits dans Excel 2000. L’utilisation d’un graphique croisé dynamique rend encore plus facile la compréhension des données puisque le tableau croisé dynamique crée automatiquement des sous-totaux et des totaux.

Aspose.Cells prend en charge les tableaux croisés dynamiques et les graphiques croisés dynamiques.

Ajout de tables pivot et de graphiques

Aspose.Cells fournit un ensemble spécial de classes utilisées pour créer des tables pivot. Ces classes sont utilisées pour créer et définir les objets PivotTable, qui agissent comme des blocs de construction de base d’un objet PivotTable :

PivotField, un champ dans un rapport de tableau croisé dynamique.
PivotFields, une collection de tous les objets PivotField dans un tableau croisé dynamique.
PivotTable, un rapport de tableau croisé dynamique sur une feuille de calcul.
PivotTables, une collection de tous les objets PivotTable sur la feuille de calcul.

Préparation à l’utilisation d’Aspose.Cells

Téléchargez et installez Aspose.Cells :
1. Téléchargez Aspose.Cells.
2. Installez-le sur votre ordinateur de développement. Tous les composants Aspose, une fois installés, fonctionnent en mode d’évaluation. Le mode d’évaluation n’a pas de limite de temps et n’injecte que des filigranes dans les documents produits. Pour travailler avec le composant à pleine capacité, vous devez disposer d’une licence valide.
Créer un projet :
1. Démarrer Visual Studio.Net.
2. Créez une nouvelle application console.
Ajouter des références: Ajoutez une référence au composant Aspose.Cells dans votre projet, par exemple …\Program Files\Aspose\Aspose.Cells\Bin\Net1.0\Aspose.Cells.dll

Ajouter un tableau croisé dynamique

Pour créer un tableau croisé dynamique en utilisant Aspose.Cells:

Ajoutez des données à une feuille de calcul à l’aide de la méthode PutValue/setValue d’un objet Cell. Vous pouvez également utiliser un fichier modèle déjà rempli de données. Ces données seront utilisées comme source de données du tableau croisé dynamique.
Ajoutez une table pivotante à la feuille de calcul en appelant la méthode add de la collection PivotTables (encapsulée dans l’objet Feuille de calcul).
Accédez au nouvel objet PivotTable depuis la collection PivotTables en passant son index. # Utilisez l’un des objets table pivotante encapsulés dans l’objet PivotTable pour gérer la table.

Des exemples de code sont donnés ci-dessous.

Ajout d’un graphique croisé dynamique

Pour créer un graphique croisé dynamique en utilisant Aspose.Cells :

Ajoutez un graphique.
Définissez la PivotSource du graphique pour qu’elle fasse référence à une table pivotante existante dans la feuille de calcul.
Définissez d’autres attributs.

Net: Tableau croisé dynamique et données sources

Mon, 01 Jan 0001 00:00:00 +0000

Données source du tableau croisé dynamique

Il arrive parfois que vous souhaitiez créer des rapports Microsoft Excel avec des tableaux croisés dynamiques prenant des données de différentes sources de données (telles qu’une base de données) qui ne sont pas connues au moment de la conception. Cet article propose une approche pour modifier dynamiquement la source de données d’un tableau croisé dynamique.

Modification des données source d’un tableau croisé dynamique

Création d’un nouveau modèle de concepteur.
1. Créez un nouveau fichier de modèle de concepteur comme sur la capture d’écran ci-dessous.
2. Ensuite, définissez une plage nommée, DataSource, qui fait référence à cette plage de cellules.
  
  Création d’un modèle de concepteur et définition d’une plage nommée, DataSource

Création d’un tableau croisé dynamique basé sur cette plage nommée.
1. Dans Microsoft Excel, choisissez Données, puis Tableau croisé dynamique et Rapport de tableau croisé dynamique.
2. Créez un tableau croisé dynamique basé sur la plage nommée créée à l’étape précédente.
  
  Création d’un tableau croisé dynamique basé sur la plage nommée, DataSource

Faites glisser le champ correspondant pour le placer dans les colonnes et les lignes du tableau croisé dynamique, puis créez le tableau croisé dynamique résultant comme sur la capture d’écran ci-dessous.

Création d’un tableau croisé dynamique basé sur un champ correspondant

Cliquez avec le bouton droit sur le tableau croisé dynamique et sélectionnez Options de tableau.
1. Cochez Actualiser à l’ouverture dans les paramètres Options de données.
  
  Configuration des options de tableau croisé dynamique

Maintenant, vous pouvez enregistrer ce fichier en tant que fichier de modèle de concepteur.

Remplir de nouvelles données et changer les données source d’un tableau croisé dynamique.
1. Une fois que le modèle de concepteur est créé, utilisez le code suivant pour changer les données source du tableau croisé dynamique.

L’exécution du code d’exemple ci-dessous modifie les données source du tableau croisé dynamique.

Net: Ajouter un champ calculé dans le tableau croisé dynamique

Mon, 01 Jan 0001 00:00:00 +0000

Scénarios d’utilisation possibles

Lorsque vous créez un tableau croisé dynamique basé sur des données connues, vous constatez que les données qui s’y trouvent ne correspondent pas à ce que vous souhaitez. Les données que vous souhaitez sont la combinaison de ces données d’origine. Par exemple, vous devez ajouter, soustraire, multiplier et diviser les données d’origine avant de les vouloir. À ce moment-là, vous devez construire un champ calculé et définir la formule correspondante pour le calcul. Ensuite, effectuez des statistiques et d’autres opérations sur le champ calculé.

Ajouter un champ calculé dans un tableau croisé dynamique dans Excel

Insérer un champ calculé dans un tableau croisé dynamique dans Excel, suivez ces étapes :

Sélectionnez le tableau croisé dynamique auquel vous souhaitez ajouter un champ calculé.
Accédez à l’onglet Analyse du tableau croisé dynamique dans le ruban.
Cliquez sur “Champs, éléments et ensembles” puis sélectionnez “Champ calculé” dans le menu déroulant.
Dans le champ “Nom”, entrez un nom pour le champ calculé.
Dans le champ “Formule”, entrez la formule du calcul que vous souhaitez effectuer en utilisant les noms de champ appropriés du tableau croisé dynamique et les opérateurs mathématiques.
Cliquez sur “OK” pour créer le champ calculé.
Le nouveau champ calculé apparaîtra dans la liste des champs du tableau croisé dynamique sous la section “Valeurs”.
Faites glisser le champ calculé dans la section Valeurs du tableau croisé dynamique pour afficher les valeurs calculées.

Ajouter un champ calculé dans un tableau croisé dynamique en utilisant C#

Ajouter un champ calculé au fichier Excel en utilisant Aspose.Cells. Veuillez voir le code d’exemple suivant. Après avoir exécuté le code d’exemple, un tableau croisé dynamique avec un champ calculé est ajouté à la feuille de calcul.

Définissez les données d’origine et créez un tableau croisé dynamique.
Créez le champ calculé en fonction du PivotField existant dans le tableau croisé dynamique.
Ajoutez le champ calculé à la zone de données.
Enfin, enregistrez le classeur au format XLSX de sortie.

Code d’exemple

Net: Actualisation des tableaux croisés dynamiques dans Aspose.Cells for .NET

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells fournit une API d’actualisation en couches qui vous permet de recharger les données des tableaux croisés dynamiques à quatre niveaux différents — du classeur entier jusqu’à un seul tableau croisé dynamique. À partir de Aspose.Cells for .NET v26.7, la méthode héritée PivotTable.RefreshData() est marquée comme obsolète et doit être remplacée par les API plus efficaces, prenant en compte le cache, décrites dans cet article.

Introduction

L’actualisation d’un tableau croisé dynamique est rarement une opération unique. En arrière-plan, Aspose.Cells maintient une chaîne de données en couches qui relie vos données source d’origine aux valeurs rendues que vous voyez dans la feuille de calcul. Comprendre cette chaîne est la clé pour choisir la bonne API d’actualisation pour chaque situation.

La chaîne de données à quatre couches est :

Source de données — les plages de cellules de la feuille de calcul d’origine, la requête de base de données ou la plage de consolidation où se trouvent les valeurs brutes.
PivotCache — l’instantané en mémoire des données source. Chaque tableau croisé dynamique est construit au-dessus d’un PivotCache ; c’est là que toutes les données sont collectées et agrégées.
PivotTable — l’objet de vue qui définit les champs de ligne, de colonne, de valeur et de filtre. Un PivotTable lit uniquement à partir de son PivotCache, jamais directement à partir de la source de données.
Cells — les Cells de la feuille de calcul dans lesquels le PivotTable rend ses valeurs calculées et ses styles.

Un concept particulièrement important est le cache partagé. Lorsque plusieurs tableaux croisés dynamiques d’un classeur référencent la même plage source, ils partagent une seule instance de PivotCache. Un seul PivotCache peut être référencé par de nombreux tableaux croisés dynamiques, et l’actualisation de ce cache actualise chaque PivotTable dépendant en une seule fois.

PivotCache.SourceType (énumération PivotTableSourceType) indique d’où proviennent les données du cache. Depuis la version 26.7, PivotCache.Refresh() ne prend en charge que les types de source Sheet et Consolidation — c’est-à-dire les données qui se trouvent dans des plages de feuilles de calcul. Les sources externes (bases de données, connexions externes, etc.) ne sont pas encore actualisables via l’API du cache.

En raison de cette chaîne, il existe deux chemins d’actualisation fondamentaux dans Aspose.Cells :

PivotCache.Refresh() — recharge la source → cache ET recalcule tous les PivotTable dépendants en une seule opération.
PivotTable.CalculateData() — recalcule l’affichage d’un seul PivotTable à partir des données déjà mises en cache, sans aller-retour vers la source de données.

Tous les scénarios de cet article utilisent des données source issues de cellules de feuille de calcul, donc le type de source est Sheet et les opérations d’actualisation se comportent comme décrit.

Directives Using requises

Tous les exemples C# de cet article commencent par les trois directives using suivantes car les types de tableaux croisés dynamiques se trouvent dans le namespace Aspose.Cells.Pivot :

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Actualiser tous les tableaux croisés dynamiques du classeur

Lorsque vous devez vous assurer que chaque cache de tableau croisé dynamique et chaque tableau croisé dynamique du classeur reflètent les dernières données source, l’API la plus simple et la plus complète est Workbook.RefreshAll(). Un seul appel parcourt tout le classeur — actualisant chaque PivotCache à partir de sa source puis recalculant chaque PivotTable dépendant. C’est l’approche recommandée pour les actualisations générales de documents complets où la performance n’est pas un souci.

L’exemple suivant construit un classeur avec une plage source Fruit/Année/Montant, crée un tableau croisé dynamique, modifie certaines valeurs source, puis utilise RefreshAll() pour tout mettre à jour en un seul appel.

using Aspose.Cells;

Workbook workbook = new Workbook("input.xlsx");
workbook.RefreshAll();
workbook.Save("output.xlsx");

Actualiser tous les tableaux croisés dynamiques d’une seule feuille de calcul

Parfois, vous n’avez besoin d’actualiser que les tableaux croisés dynamiques qui se trouvent sur une feuille de calcul spécifique — par exemple, lorsque les tableaux croisés dynamiques d’autres feuilles de calcul sont connus pour être sans rapport et ne doivent pas être touchés. Pour ce cas, Aspose.Cells fournit Worksheet.RefreshPivotTables(), qui est limité à une seule instance de Worksheet.

C’est plus sélectif que Workbook.RefreshAll() : seuls les tableaux croisés dynamiques de la feuille de calcul ciblée sont actualisés, en laissant intacts les tableaux croisés dynamiques des autres feuilles.

L’exemple suivant remplit les mêmes données source Fruit/Année/Montant, ajoute un tableau croisé dynamique sur la première feuille de calcul, modifie certaines valeurs source, puis actualise uniquement les tableaux croisés dynamiques de cette feuille de calcul.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// Créer un nouveau classeur
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Écrire la ligne d'en-tête dans les cellules A1:C1
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Écrire les lignes de données dans les cellules A2:C9 (8 lignes de données sur les fruits pour 2020 et 2021)
worksheet.Cells["A2"].PutValue("grape");
worksheet.Cells["B2"].PutValue(2020);
worksheet.Cells["C2"].PutValue(50);

worksheet.Cells["A3"].PutValue("blueberry");
worksheet.Cells["B3"].PutValue(2020);
worksheet.Cells["C3"].PutValue(60);

worksheet.Cells["A4"].PutValue("kiwi");
worksheet.Cells["B4"].PutValue(2020);
worksheet.Cells["C4"].PutValue(70);

worksheet.Cells["A5"].PutValue("cherry");
worksheet.Cells["B5"].PutValue(2020);
worksheet.Cells["C5"].PutValue(80);

worksheet.Cells["A6"].PutValue("grape");
worksheet.Cells["B6"].PutValue(2021);
worksheet.Cells["C6"].PutValue(90);

worksheet.Cells["A7"].PutValue("blueberry");
worksheet.Cells["B7"].PutValue(2021);
worksheet.Cells["C7"].PutValue(100);

worksheet.Cells["A8"].PutValue("kiwi");
worksheet.Cells["B8"].PutValue(2021);
worksheet.Cells["C8"].PutValue(110);

worksheet.Cells["A9"].PutValue("cherry");
worksheet.Cells["B9"].PutValue(2021);
worksheet.Cells["C9"].PutValue(120);

// Ajouter un tableau croisé dynamique : plage source "A1:C9", cellule de destination "E3", nom "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Assigner les champs du tableau croisé dynamique : Fruit aux Lignes, Year aux Colonnes, Amount aux Données
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modifier plusieurs valeurs de Amount dans les données sources pour simuler des changements
worksheet.Cells["C2"].PutValue(55);
worksheet.Cells["C5"].PutValue(85);
worksheet.Cells["C9"].PutValue(125);

// Actualiser tous les tableaux croisés dynamiques / caches de tableaux croisés dynamiques dans le classeur
workbook.RefreshAll();

// Enregistrer le classeur
workbook.Save("output.xlsx");

Actualiser un seul tableau croisé dynamique

Lorsque vous souhaitez un contrôle fin sur un seul tableau croisé dynamique, l’API basée sur le cache vous offre deux options. Le choix entre les deux dépend de ce qui a réellement changé : les données source sous-jacentes, ou simplement les paramètres d’affichage/de disposition du tableau croisé dynamique lui-même.

Les données source ont changé — Utilisez `PivotCache.Refresh()`

Si les données source sous-jacentes ont changé, le bon point d’entrée est pivotTable.PivotCache.Refresh(). Cet appel relit les données source dans le cache, puis recalcule chaque PivotTable qui dépend de ce cache.

Parce que les tableaux croisés dynamiques partagent une seule instance de PivotCache, l’appel de PivotCache.Refresh() recalcule tous les tableaux croisés dynamiques construits sur ce même cache — pas seulement celui que vous référencez. Si deux tableaux croisés dynamiques partagent la même plage source, l’actualisation d’un cache actualise les deux.

L’exemple suivant crée deux tableaux croisés dynamiques sur la même plage source pour démontrer ce comportement de cache partagé, modifie certaines valeurs source, puis actualise via une seule référence au cache.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

worksheet.Cells["A2"].PutValue("grape");
worksheet.Cells["B2"].PutValue(2020);
worksheet.Cells["C2"].PutValue(100);

worksheet.Cells["A3"].PutValue("blueberry");
worksheet.Cells["B3"].PutValue(2021);
worksheet.Cells["C3"].PutValue(150);

worksheet.Cells["A4"].PutValue("kiwi");
worksheet.Cells["B4"].PutValue(2020);
worksheet.Cells["C4"].PutValue(200);

worksheet.Cells["A5"].PutValue("cherry");
worksheet.Cells["B5"].PutValue(2021);
worksheet.Cells["C5"].PutValue(120);

worksheet.Cells["A6"].PutValue("grape");
worksheet.Cells["B6"].PutValue(2021);
worksheet.Cells["C6"].PutValue(180);

worksheet.Cells["A7"].PutValue("blueberry");
worksheet.Cells["B7"].PutValue(2020);
worksheet.Cells["C7"].PutValue(130);

worksheet.Cells["A8"].PutValue("kiwi");
worksheet.Cells["B8"].PutValue(2021);
worksheet.Cells["C8"].PutValue(220);

worksheet.Cells["A9"].PutValue("cherry");
worksheet.Cells["B9"].PutValue(2020);
worksheet.Cells["C9"].PutValue(140);

int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

worksheet.Cells["C2"].PutValue(300);
worksheet.Cells["C5"].PutValue(250);
worksheet.Cells["C9"].PutValue(400);

worksheet.RefreshPivotTables();

workbook.Save("output.xlsx");

Seule l’affichage/la disposition a changé — Utilisez `CalculateData()`

Si les données source n’ont pas changé mais que seuls les paramètres d’affichage ou de disposition du tableau croisé dynamique ont été modifiés (par exemple, un champ a été déplacé vers une autre zone, ou un paramètre d’actualisation à l’ouverture a été activé), il n’est pas nécessaire de faire un aller-retour vers la source de données. Le cache contient déjà les bonnes données ; seul le PivotTable rendu a besoin d’être recalculé. Dans ce cas, pivotTable.CalculateData() est le bon choix.

Cela évite la récupération source inutile et est nettement plus rapide lorsque de nombreux tableaux croisés dynamiques partagent le même cache.

L’exemple suivant modifie une propriété non source du tableau croisé dynamique, puis appelle CalculateData() pour le restituer à partir du cache existant.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// Créer un nouveau classeur et accéder à la première feuille de calcul
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Écrire la ligne d'en-tête : Fruit / Année / Montant
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Écrire environ 9 lignes de données (raisin / myrtille / kiwi / cerise sur 2020-2021)
worksheet.Cells["A2"].PutValue("Grape");
worksheet.Cells["B2"].PutValue(2020);
worksheet.Cells["C2"].PutValue(100);

worksheet.Cells["A3"].PutValue("Blueberry");
worksheet.Cells["B3"].PutValue(2020);
worksheet.Cells["C3"].PutValue(200);

worksheet.Cells["A4"].PutValue("Kiwi");
worksheet.Cells["B4"].PutValue(2020);
worksheet.Cells["C4"].PutValue(300);

worksheet.Cells["A5"].PutValue("Cherry");
worksheet.Cells["B5"].PutValue(2020);
worksheet.Cells["C5"].PutValue(400);

worksheet.Cells["A6"].PutValue("Grape");
worksheet.Cells["B6"].PutValue(2021);
worksheet.Cells["C6"].PutValue(500);

worksheet.Cells["A7"].PutValue("Blueberry");
worksheet.Cells["B7"].PutValue(2021);
worksheet.Cells["C7"].PutValue(600);

worksheet.Cells["A8"].PutValue("Kiwi");
worksheet.Cells["B8"].PutValue(2021);
worksheet.Cells["C8"].PutValue(700);

worksheet.Cells["A9"].PutValue("Cherry");
worksheet.Cells["B9"].PutValue(2021);
worksheet.Cells["C9"].PutValue(800);

// Ajouter le premier tableau croisé dynamique "Pivot1" ancré à la cellule E3, plage source A1:C9
int pivotIndex1 = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable1 = worksheet.PivotTables[pivotIndex1];

// Assigner les champs pour Pivot1
pivotTable1.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable1.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable1.AddFieldToArea(PivotFieldType.Data, "Amount");

// Ajouter un SECOND tableau croisé dynamique "Pivot2" ancré à E15 en utilisant la MÊME plage source A1:C9
// Pivot1 et Pivot2 partagent un seul PivotCache car la plage source est identique.
int pivotIndex2 = worksheet.PivotTables.Add("A1:C9", "E15", "Pivot2");
PivotTable pivotTable2 = worksheet.PivotTables[pivotIndex2];

// Assigner les mêmes champs pour Pivot2
pivotTable2.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable2.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable2.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modifier plusieurs valeurs de cellules Montant dans les données source pour simuler un changement de données
worksheet.Cells["C2"].PutValue(150);
worksheet.Cells["C4"].PutValue(350);
worksheet.Cells["C7"].PutValue(650);

// Actualiser le PivotCache partagé.
// Comme Pivot1 et Pivot2 partagent le même PivotCache, cet appel unique
// actualise LES DEUX tableaux croisés dynamiques (données + style) à partir de la source mise à jour.
pivotTable1.PivotCache.Refresh();

// Enregistrer le classeur
workbook.Save("output.xlsx");

Obtenir tous les tableaux croisés dynamiques partageant le même PivotCache

Un classeur contient souvent de nombreux tableaux croisés dynamiques qui reposent tous sur un cache partagé. Pour les énumérer — par exemple, avant d’effectuer une actualisation par lot, ou pour diagnostiquer l’impact d’un cache partagé — utilisez PivotCache.GetPivotTables(). Cette méthode renvoie la collection de chaque PivotTable qui dépend du cache donné.

C’est aussi le moyen le plus direct de confirmer que deux tableaux croisés dynamiques partagent effectivement la même instance de PivotCache : vous pouvez comparer les références du cache, ou simplement parcourir la collection renvoyée par GetPivotTables() et observer quels tableaux croisés dynamiques y apparaissent.

L’exemple suivant crée deux tableaux croisés dynamiques sur la même plage source, vérifie qu’ils partagent la même instance de cache, puis énumère les tableaux croisés dynamiques du cache.

using Aspose.Cells;
using Aspose.Cells.Pivot;

var workbook = new Workbook();
var worksheet = workbook.Worksheets[0];

// Écrire la ligne d'en-tête Fruit / Year / Amount
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Écrire 8 lignes de données (lignes 2-9, correspondant à la plage source A1:C9)
worksheet.Cells["A2"].PutValue("Grape");
worksheet.Cells["B2"].PutValue(2020);
worksheet.Cells["C2"].PutValue(100);

worksheet.Cells["A3"].PutValue("Blueberry");
worksheet.Cells["B3"].PutValue(2020);
worksheet.Cells["C3"].PutValue(200);

worksheet.Cells["A4"].PutValue("Kiwi");
worksheet.Cells["B4"].PutValue(2020);
worksheet.Cells["C4"].PutValue(300);

worksheet.Cells["A5"].PutValue("Cherry");
worksheet.Cells["B5"].PutValue(2020);
worksheet.Cells["C5"].PutValue(400);

worksheet.Cells["A6"].PutValue("Grape");
worksheet.Cells["B6"].PutValue(2021);
worksheet.Cells["C6"].PutValue(150);

worksheet.Cells["A7"].PutValue("Blueberry");
worksheet.Cells["B7"].PutValue(2021);
worksheet.Cells["C7"].PutValue(250);

worksheet.Cells["A8"].PutValue("Kiwi");
worksheet.Cells["B8"].PutValue(2021);
worksheet.Cells["C8"].PutValue(350);

worksheet.Cells["A9"].PutValue("Cherry");
worksheet.Cells["B9"].PutValue(2021);
worksheet.Cells["C9"].PutValue(450);

// Ajouter un tableau croisé dynamique nommé "Pivot1" placé à la cellule de destination E3, à partir de A1:C9
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.PivotTables[pivotIndex];

// Assigner les champs : Fruit à Ligne, Year à Colonne, Amount à Données
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modifier une propriété d'affichage/de mise en page — il s'agit d'une modification purement présentationnelle,
// elle ne nécessite PAS de relire les données source via PivotCache.Refresh().
pivotTable.RefreshDataOnOpeningFile = false;

// CalculateData() restitue l'affichage de CE tableau croisé dynamique (données + style) à partir des
// données déjà détenues dans le PivotCache. Comme les données source n'ont pas changé,
// aucun aller-retour vers la source n'est effectué — seules les valeurs mises en cache sont recalculées
// dans les cellules de la feuille de calcul.
pivotTable.CalculateData();

// Enregistrer le classeur sur le disque
workbook.Save("output.xlsx");

Migration depuis l’obsolète `PivotTable.RefreshData()`

Avant Aspose.Cells for .NET v26.7, la façon standard d’actualiser un tableau croisé dynamique était d’appeler PivotTable.RefreshData() sur chaque tableau croisé dynamique individuellement. Depuis la version 26.7, cette méthode est marquée comme obsolète et doit être remplacée par les API prenant en compte le cache décrites ci-dessus.

Il y a deux raisons pour lesquelles l’approche RefreshData() par tableau est problématique dans les classeurs du monde réel :

Elle récupère à nouveau les données depuis la source à chaque appel, même lorsque la source n’a pas changé.
Chaque appel actualise l’intégralité du cache partagé. Lorsque de nombreux tableaux croisés dynamiques partagent un cache, l’appel répété de RefreshData() par tableau croisé dynamique provoque la récupération à plusieurs reprises du même cache, ce qui est très lent.

Les remplacements recommandés sont :

Actualiser TOUS les tableaux croisés dynamiques du classeur → utilisez workbook.RefreshAll();
Actualiser CERTAINS d’entre eux → utilisez pivotTable.PivotCache.Refresh(); pour un cache. Comme le cache est partagé, cet unique appel met à jour chaque tableau croisé dynamique construit au-dessus de ce cache. Les autres tableaux croisés dynamiques qui reposent sur un cache déjà actualisé peuvent être ignorés en toute sécurité.
Seule l’affichage/la disposition du tableau croisé a changé → utilisez pivotTable.CalculateData(); pour restituer à partir du cache existant sans aucun aller-retour vers la source.

L’exemple suivant démontre le nouveau modèle efficace pour les classeurs comportant plusieurs tableaux croisés dynamiques partageant un seul cache.

Quelle API d’actualisation dois-je utiliser ?

Le tableau ci-dessous résume les API d’actualisation disponibles et quand choisir chacune d’elles.

Objectif	API recommandée	Notes
Actualiser tout dans le classeur	`Workbook.RefreshAll()`	Un seul appel ; couvre tous les caches et tableaux.
Actualiser uniquement les tableaux croisés dynamiques d’une seule feuille	`Worksheet.RefreshPivotTables()`	Limité à une seule feuille de calcul.
Données source modifiées pour un cache	`pivotTable.PivotCache.Refresh()`	Actualise TOUS les tableaux croisés dynamiques de ce cache partagé.
Seuls les paramètres d’affichage/de disposition ont changé	`pivotTable.CalculateData()`	Évite un aller-retour inutile vers la source.
Lister tous les tableaux croisés dynamiques d’un cache partagé	`pivotCache.GetPivotTables()`	À utiliser pour énumérer avant une actualisation en masse.

En pratique, privilégiez les API basées sur le cache par rapport à l’obsolète RefreshData() par tableau. Elles tiennent compte des caches partagés, évitent les récupérations redondantes de la source, et vous permettent de choisir la portée la plus petite qui satisfait votre besoin d’actualisation.

Net: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells pour .NET

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells prend en charge l’application à la fois des anciens autoformats de tableau croisé dynamique (destinés aux fichiers .xls) et des styles modernes nommés ou personnalisés de tableau croisé dynamique (destinés aux fichiers .xlsx, .xlsm et .xlsb). L’API à appeler dépend du format de fichier dans lequel le classeur est enregistré, et non du format à partir duquel il a été chargé.

Introduction

Aspose.Cells expose deux API de style parallèles pour les tableaux croisés dynamiques. Le choix entre elles dépend du format de fichier dans lequel vous enregistrez le classeur, et non du format à partir duquel vous le lisez. Un classeur chargé à partir d’un fichier .xls peut être réenregistré au format .xlsx, et dans ce cas, c’est l’API de style moderne qui s’applique plutôt que l’ancienne.

Pour la sortie au format .xls hérité, utilisez la propriété PivotTable.AutoFormatType conjointement avec l’énumération Aspose.Cells.Pivot.PivotTableAutoFormatType. Cette API correspond au sélecteur d’autoformat qu’Excel classique proposait pour les tableaux croisés dynamiques.

Pour la sortie aux formats modernes .xlsx, .xlsm et .xlsb, deux variantes d’API de style sont disponibles :

PivotTable.PivotTableStyleType sélectionne l’un des styles nommés intégrés (thèmes clairs et sombres, y compris les styles ajoutés dans Excel 2017). Ces préréglages sont en lecture seule.
PivotTable.PivotTableStyleName sélectionne un style personnalisé que vous définissez vous-même via Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Les styles personnalisés sont requis dès que vous souhaitez modifier les couleurs, les bordures ou les polices au-delà de ce que proposent les préréglages.

De plus, PivotTable.FormatAll(Style) est un raccourci qui applique un seul objet Style à chaque cellule du tableau croisé dynamique, en supplantant tout ce qui a été défini via l’une ou l’autre des API de nom de style ci-dessus. Cela est utile lorsqu’une apparence uniforme est requise, indépendamment du thème sous-jacent.

Application d’un autoformat prédéfini XLS hérité

PivotTable.AutoFormatType accepte une valeur issue de l’énumération Aspose.Cells.Pivot.PivotTableAutoFormatType. Les valeurs disponibles sont Report1 à Report10, Classic et Table1 à Table10.

AutoFormatType n’est pris en compte que lorsque le classeur est enregistré au format .xls. Lorsque le même classeur est enregistré au format .xlsx, .xlsm ou .xlsb, Excel ignore cette propriété et se rabat sur les paramètres PivotTableStyleType et PivotTableStyleName.

L’exemple suivant charge un nouveau classeur, renseigne les données d’exemple Fruit/Année/Montant, ajoute un tableau croisé dynamique, applique PivotTableAutoFormatType.Report5 et enregistre le résultat au format .xls.

Pourquoi pas de champs de colonne ? Les autoformats de la série Report (Report1 à Report10, Table1 à Table10) ont été conçus dans Excel classique pour des tableaux croisés dynamiques à une dimension avec uniquement des champs de ligne et des valeurs — ils n’ont pas de style intégré pour les en-têtes de champs de colonne. Si votre tableau croisé dynamique nécessite des champs de colonne, utilisez plutôt les préréglages modernes PivotTableStyleType du Scénario 2 ci-dessous, qui sont conçus pour la disposition bidimensionnelle qu’utilise Excel moderne.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// Scénario 1 : Appliquer un format automatique prédéfini XLS hérité
// API utilisée : PivotTable.AutoFormatType
// Format de fichier cible : .xls (hérit)
// Pour des exemples complets et des fichiers de données, veuillez consulter https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Créer un nouveau classeur
Workbook workbook = new Workbook();

// Obtenir la première feuille de calcul
Worksheet sheet = workbook.Worksheets[0];

// Remplir les données sources avec une ligne d'en-tête (Fruit, Année, Montant)
// et 9 lignes de données couvrant raisin, myrtille, kiwi, cerise pour 2020 et 2021
sheet.Cells[0, 0].PutValue("Fruit");
sheet.Cells[0, 1].PutValue("Year");
sheet.Cells[0, 2].PutValue("Amount");

sheet.Cells[1, 0].PutValue("grape");
sheet.Cells[1, 1].PutValue(2020);
sheet.Cells[1, 2].PutValue(50);

sheet.Cells[2, 0].PutValue("blueberry");
sheet.Cells[2, 1].PutValue(2020);
sheet.Cells[2, 2].PutValue(30);

sheet.Cells[3, 0].PutValue("kiwi");
sheet.Cells[3, 1].PutValue(2020);
sheet.Cells[3, 2].PutValue(25);

sheet.Cells[4, 0].PutValue("cherry");
sheet.Cells[4, 1].PutValue(2020);
sheet.Cells[4, 2].PutValue(40);

sheet.Cells[5, 0].PutValue("grape");
sheet.Cells[5, 1].PutValue(2021);
sheet.Cells[5, 2].PutValue(60);

sheet.Cells[6, 0].PutValue("blueberry");
sheet.Cells[6, 1].PutValue(2021);
sheet.Cells[6, 2].PutValue(35);

sheet.Cells[7, 0].PutValue("kiwi");
sheet.Cells[7, 1].PutValue(2021);
sheet.Cells[7, 2].PutValue(28);

sheet.Cells[8, 0].PutValue("cherry");
sheet.Cells[8, 1].PutValue(2021);
sheet.Cells[8, 2].PutValue(45);

sheet.Cells[9, 0].PutValue("grape");
sheet.Cells[9, 1].PutValue(2020);
sheet.Cells[9, 2].PutValue(45);

// Ajouter un tableau croisé dynamique à la cellule de destination E3, nommé "Pivot1", en utilisant la plage source A1:C10
int pivotIndex = sheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Assigner les champs : Fruit -> Lignes, Année -> Colonnes, Montant -> Données
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Appliquer le format automatique prédéfini XLS hérité "Report5"
// Remarque : Cette propriété n'est significative que lors de l'enregistrement en .xls.
// Lors de l'enregistrement en .xlsx/.xlsm/.xlsb, Excel ignore AutoFormatType
// et utilise ce que spécifie PivotTableStyleType / PivotTableStyleName.
pivotTable.AutoFormatType = PivotTableAutoFormatType.Report5;

// Enregistrer le classeur au format .xls hérité
workbook.Save("output.xls");

Application d’un style prédéfini nommé moderne de tableau croisé dynamique

PivotTable.PivotTableStyleType accepte une valeur issue de l’énumération Aspose.Cells.PivotTableStyleType. L’énumération couvre les thèmes clairs PivotTableStyleLight1 à PivotTableStyleLight28 et les thèmes sombres PivotTableStyleDark1 à PivotTableStyleDark28. Les styles ajoutés dans Excel 2017 (la deuxième vague de thèmes clairs et sombres) sont accessibles via la même énumération.

C’est l’API recommandée pour tout format de fichier moderne. Contrairement à l’autoformat hérité, le style sélectionné ici est rendu fidèlement par Excel et survit aux aller-retours via d’autres outils Office.

L’exemple suivant utilise les mêmes données Fruit/Année/Montant, crée un tableau croisé dynamique identique, applique PivotTableStyleDark1 et enregistre le classeur au format .xlsx.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// Scénario 2 : Appliquer un style prédéfini nommé moderne d'Excel 2007+ en utilisant PivotTableStyleType.
// Format de fichier cible : .xlsx. L'énumération PivotTableStyleType se trouve dans l'espace de noms Aspose.Cells
// (pas dans Aspose.Cells.Pivot) — c'est pourquoi nous n'avons pas besoin d'un using supplémentaire pour cela.
// Référence GitHub : https://github.com/aspose-cells/Aspose.Cells-for-.NET/blob/master/Examples/CSharp/PivotTables/ApplyStyleToPivotTable2.cs

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Ligne d'en-tête : Fruit / Année / Montant
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// 9 lignes de données de Fruit / Année / Montant
worksheet.Cells["A2"].PutValue("Grape");
worksheet.Cells["B2"].PutValue(2020);
worksheet.Cells["C2"].PutValue(100);

worksheet.Cells["A3"].PutValue("Blueberry");
worksheet.Cells["B3"].PutValue(2020);
worksheet.Cells["C3"].PutValue(150);

worksheet.Cells["A4"].PutValue("Kiwi");
worksheet.Cells["B4"].PutValue(2020);
worksheet.Cells["C4"].PutValue(200);

worksheet.Cells["A5"].PutValue("Cherry");
worksheet.Cells["B5"].PutValue(2020);
worksheet.Cells["C5"].PutValue(180);

worksheet.Cells["A6"].PutValue("Grape");
worksheet.Cells["B6"].PutValue(2021);
worksheet.Cells["C6"].PutValue(120);

worksheet.Cells["A7"].PutValue("Blueberry");
worksheet.Cells["B7"].PutValue(2021);
worksheet.Cells["C7"].PutValue(170);

worksheet.Cells["A8"].PutValue("Kiwi");
worksheet.Cells["B8"].PutValue(2021);
worksheet.Cells["C8"].PutValue(210);

worksheet.Cells["A9"].PutValue("Cherry");
worksheet.Cells["B9"].PutValue(2021);
worksheet.Cells["C9"].PutValue(190);

worksheet.Cells["A10"].PutValue("Grape");
worksheet.Cells["B10"].PutValue(2021);
worksheet.Cells["C10"].PutValue(130);

// Ajouter un tableau croisé dynamique à E3 nommé "Pivot1", provenant de A1:C10
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Assigner les champs du tableau croisé dynamique : Fruit -> zone de ligne, Année -> zone de colonne, Montant -> zone de données
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Appliquer un style de tableau croisé dynamique prédéfini nommé moderne d'Excel 2007+.
// PivotTableStyleType est l'API correcte pour les fichiers .xlsx / .xlsm / .xlsb ; AutoFormatType
// est ignoré par Excel pour ces formats. PivotTableStyleDark1 appartient à la famille
// des thèmes sombres (PivotTableStyleDark1..PivotTableStyleDark28), et la même énumération expose également les
// thèmes plus récents d'Excel 2017 clair/sombre (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.PivotTableStyleType = PivotTableStyleType.PivotTableStyleDark1;

// Enregistrer en tant que .xlsx moderne — c'est le format pour lequel PivotTableStyleType a du sens.
workbook.Save("output.xlsx");

Définition et application d’un style personnalisé de tableau croisé dynamique

Les préréglages intégrés ne peuvent pas être modifiés. Dès que vous devez remplacer les couleurs, les bordures ou les polices, vous devez définir un style personnalisé de tableau croisé dynamique. Le flux de travail comporte trois étapes :

Ajoutez un style personnalisé à la collection TableStyles du classeur via Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name). Cela renvoie l’index du style nouvellement créé.
Configurez le style en ajoutant des éléments (tels que WholeTable ou GrandTotalRow) via TableStyle.TableStyleElements.Add(TableStyleElementType), puis attribuez un Style à chaque élément via TableStyleElement.SetElementStyle(Style).
Appliquez le style personnalisé au tableau croisé dynamique en définissant PivotTable.PivotTableStyleName sur le nom du style. N’utilisez pas PivotTableStyleType ici, car cette propriété sélectionne les préréglages intégrés.

PivotTableStyleName et PivotTableStyleType ne sont pas interchangeables. Utilisez PivotTableStyleType pour les préréglages intégrés, et PivotTableStyleName pour les styles personnalisés que vous avez définis via AddPivotTableStyle. Définir les deux est sans incidence, mais seul celui qui correspond à la source prévue est rendu.

Les valeurs TableStyleElementType disponibles incluent WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels et PageFieldValues.

L’exemple suivant définit un style personnalisé de tableau croisé dynamique avec une bordure noire fine sur WholeTable et une police rouge en gras sur GrandTotalRow, puis l’applique via PivotTableStyleName et enregistre au format .xlsx.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;
using System.Drawing;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Remplir les données source : ligne d'en-tête + 9 lignes de données (A1:C10)
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

worksheet.Cells["A2"].PutValue("Grape");
worksheet.Cells["B2"].PutValue(2020);
worksheet.Cells["C2"].PutValue(100);

worksheet.Cells["A3"].PutValue("Blueberry");
worksheet.Cells["B3"].PutValue(2020);
worksheet.Cells["C3"].PutValue(200);

worksheet.Cells["A4"].PutValue("Kiwi");
worksheet.Cells["B4"].PutValue(2020);
worksheet.Cells["C4"].PutValue(300);

worksheet.Cells["A5"].PutValue("Cherry");
worksheet.Cells["B5"].PutValue(2020);
worksheet.Cells["C5"].PutValue(400);

worksheet.Cells["A6"].PutValue("Grape");
worksheet.Cells["B6"].PutValue(2021);
worksheet.Cells["C6"].PutValue(500);

worksheet.Cells["A7"].PutValue("Blueberry");
worksheet.Cells["B7"].PutValue(2021);
worksheet.Cells["C7"].PutValue(600);

worksheet.Cells["A8"].PutValue("Kiwi");
worksheet.Cells["B8"].PutValue(2021);
worksheet.Cells["C8"].PutValue(700);

worksheet.Cells["A9"].PutValue("Cherry");
worksheet.Cells["B9"].PutValue(2021);
worksheet.Cells["C9"].PutValue(800);

worksheet.Cells["A10"].PutValue("Grape");
worksheet.Cells["B10"].PutValue(2021);
worksheet.Cells["C10"].PutValue(900);

// Ajouter un tableau croisé dynamique à partir de A1:C10, ancré à E3, nommé "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Étape 1 : enregistrer un nouveau style de tableau croisé dynamique personnalisé et capturer son index
int styleIndex = workbook.Worksheets.TableStyles.AddPivotTableStyle("CustomPivotStyle");
TableStyle tableStyle = workbook.Worksheets.TableStyles[styleIndex];

// Étape 2 : ajouter un élément WholeTable et appliquer des bordures noires fines sur les quatre côtés
int wholeTableElementIndex = tableStyle.TableStyleElements.Add(TableStyleElementType.WholeTable);
TableStyleElement wholeTableElement = tableStyle.TableStyleElements[wholeTableElementIndex];
Style wholeTableStyle = workbook.CreateStyle();
wholeTableStyle.Borders[BorderType.TopBorder].LineStyle = CellBorderType.Thin;
wholeTableStyle.Borders[BorderType.TopBorder].Color = Color.Black;
wholeTableStyle.Borders[BorderType.BottomBorder].LineStyle = CellBorderType.Thin;
wholeTableStyle.Borders[BorderType.BottomBorder].Color = Color.Black;
wholeTableStyle.Borders[BorderType.LeftBorder].LineStyle = CellBorderType.Thin;
wholeTableStyle.Borders[BorderType.LeftBorder].Color = Color.Black;
wholeTableStyle.Borders[BorderType.RightBorder].LineStyle = CellBorderType.Thin;
wholeTableStyle.Borders[BorderType.RightBorder].Color = Color.Black;
wholeTableElement.SetElementStyle(wholeTableStyle);

// Étape 3 : ajouter un élément GrandTotalRow et appliquer une police rouge en gras
int grandTotalElementIndex = tableStyle.TableStyleElements.Add(TableStyleElementType.GrandTotalRow);
TableStyleElement grandTotalElement = tableStyle.TableStyleElements[grandTotalElementIndex];
Style grandTotalStyle = workbook.CreateStyle();
grandTotalStyle.Font.IsBold = true;
grandTotalStyle.Font.Color = Color.Red;
grandTotalElement.SetElementStyle(grandTotalStyle);

// Étape 4 : appliquer le style personnalisé par nom (PAS par PivotTableStyleType, qui est destiné aux préréglages intégrés)
pivotTable.PivotTableStyleName = "CustomPivotStyle";

workbook.Save("output.xlsx");

Application d’un style unique à chaque cellule du tableau croisé dynamique avec FormatAll

PivotTable.FormatAll(Style) est un raccourci qui applique un seul objet Style à chaque cellule du tableau croisé dynamique, y compris la zone de données, les en-têtes de lignes et de colonnes, ainsi que les totaux. Tout ce qui a été défini précédemment via PivotTableStyleType ou PivotTableStyleName est supplanté.

FormatAll supplante à la fois PivotTableStyleType et PivotTableStyleName. Utilisez-le uniquement lorsqu’une apparence uniforme, indépendante du thème, est requise sur l’ensemble du tableau croisé dynamique.

L’exemple suivant crée un Style avec un remplissage uni jaune, une police bleu foncé en gras et des bordures noires fines sur tous les côtés, puis l’applique avec FormatAll et enregistre au format .xlsx.

using System;
using System.Drawing;
using System.IO;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// Scénario 4 : Appliquer un seul Style à chaque cellule de tableau croisé dynamique en utilisant FormatAll
// API utilisée : PivotTable.FormatAll(Style)
// Format cible : .xlsx
// Référence GitHub : voir le dépôt Aspose.Cells-for-.NET — exemples de mise en forme de tableaux croisés dynamiques

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Remplir les données sources : ligne d'en-tête (ligne 1) + 9 lignes de données (lignes 2-10)
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

worksheet.Cells["A2"].PutValue("Grape");
worksheet.Cells["B2"].PutValue(2020);
worksheet.Cells["C2"].PutValue(5000);

worksheet.Cells["A3"].PutValue("Blueberry");
worksheet.Cells["B3"].PutValue(2020);
worksheet.Cells["C3"].PutValue(3000);

worksheet.Cells["A4"].PutValue("Kiwi");
worksheet.Cells["B4"].PutValue(2020);
worksheet.Cells["C4"].PutValue(4000);

worksheet.Cells["A5"].PutValue("Cherry");
worksheet.Cells["B5"].PutValue(2020);
worksheet.Cells["C5"].PutValue(2000);

worksheet.Cells["A6"].PutValue("Grape");
worksheet.Cells["B6"].PutValue(2021);
worksheet.Cells["C6"].PutValue(6000);

worksheet.Cells["A7"].PutValue("Blueberry");
worksheet.Cells["B7"].PutValue(2021);
worksheet.Cells["C7"].PutValue(3500);

worksheet.Cells["A8"].PutValue("Kiwi");
worksheet.Cells["B8"].PutValue(2021);
worksheet.Cells["C8"].PutValue(4500);

worksheet.Cells["A9"].PutValue("Cherry");
worksheet.Cells["B9"].PutValue(2021);
worksheet.Cells["C9"].PutValue(2500);

worksheet.Cells["A10"].PutValue("Grape");
worksheet.Cells["B10"].PutValue(2021);
worksheet.Cells["C10"].PutValue(5500);

// Ajouter un tableau croisé dynamique : plage source A1:C10, cellule de destination E3, nom "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Assigner les champs du tableau croisé : Fruit -> zone de ligne, Year -> zone de colonne, Amount -> zone de données
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Construire un Style qui sera appliqué de force sur chaque cellule du tableau croisé dynamique
Style style = workbook.CreateStyle();
style.ForegroundColor = Color.Yellow;
style.Pattern = BackgroundType.Solid;
style.Font.IsBold = true;
style.Font.Color = Color.DarkBlue;
style.Borders[BorderType.TopBorder].LineStyle = CellBorderType.Thin;
style.Borders[BorderType.TopBorder].Color = Color.Black;
style.Borders[BorderType.BottomBorder].LineStyle = CellBorderType.Thin;
style.Borders[BorderType.BottomBorder].Color = Color.Black;
style.Borders[BorderType.LeftBorder].LineStyle = CellBorderType.Thin;
style.Borders[BorderType.LeftBorder].Color = Color.Black;
style.Borders[BorderType.RightBorder].LineStyle = CellBorderType.Thin;
style.Borders[BorderType.RightBorder].Color = Color.Black;

// Appliquer FormatAll : force ce style unique sur chaque cellule du tableau croisé dynamique,
// écrasant tout PivotTableStyleType / PivotTableStyleName précédemment défini
pivotTable.FormatAll(style);

// Enregistrer le classeur au format moderne .xlsx
workbook.Save("output.xlsx");

Quelle API de style dois-je utiliser ?

Le choix de l’API de style dépend du format de fichier dans lequel vous enregistrez. Utilisez le tableau ci-dessous comme référence rapide.

Format de fichier cible	API à utiliser	Notes
`.xls` (hérité)	`PivotTable.AutoFormatType`	Valeurs issues de `Aspose.Cells.Pivot.PivotTableAutoFormatType` (par ex. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Ignorée lors de l’enregistrement aux formats modernes.
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style intégré)	`PivotTable.PivotTableStyleType`	Valeurs issues de `Aspose.Cells.PivotTableStyleType` (thèmes clairs/sombres, y compris les ajouts d’Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style personnalisé)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	À utiliser lorsque les préréglages intégrés ne suffisent pas. Configurez via `TableStyleElement.SetElementStyle(...)`.
Tout format (substitution uniforme)	`PivotTable.FormatAll(Style)`	Raccourci qui supplante tout autre paramètre de style sur l’ensemble du tableau croisé dynamique.

En cas de doute, enregistrez au format .xlsx et utilisez PivotTableStyleType pour les thèmes intégrés, ou PivotTableStyleName pour les thèmes personnalisés.

Net: Ajouter des champs de ligne et de colonne à un tableau croisé dynamique dans Aspose.Cells pour .NET

Mon, 01 Jan 0001 00:00:00 +0000

Ajout d’un champ à la zone des lignes ou des colonnes

La méthode PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) déplace un champ de base des données source vers l’une des quatre zones du tableau croisé dynamique. L’argument fieldType accepte l’une des valeurs PivotFieldType suivantes.

Row — champs placés verticalement à gauche
Column — champs placés horizontalement en haut
Data — champs dont les valeurs sont agrégées
Page — champs utilisés comme filtres de rapport

Une fois les champs ajoutés, vous pouvez y accéder via les propriétés PivotTable.RowFields et PivotTable.ColumnFields. Chaque propriété renvoie un PivotFieldCollection. Le champ à l’index 0 de RowFields est le champ de ligne le plus externe, et les indices suivants représentent des champs imbriqués à l’intérieur de celui-ci. La même convention d’indexation s’applique à ColumnFields.

L’ordre d’imbrication des champs est important. Ajouter d’abord Category à la zone des lignes, puis Item, produit un tableau croisé dynamique dont le regroupement externe est Category et dont le regroupement interne est Item. Inverser l’ordre inverse la hiérarchie.

Sous-totaux des champs du tableau croisé dynamique

La méthode PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) contrôle quelles lignes de sous-total s’affichent pour un champ de tableau croisé dynamique. Chaque appel bascule un seul type de sous-total indépendamment. Passer shown = true affiche le sous-total, tandis que shown = false le masque. Étant donné que chaque appel n’affecte qu’un seul type, appeler la méthode plusieurs fois avec différentes valeurs de subtotalType construit un sous-ensemble personnalisé de sous-totaux.

L’énumération PivotFieldSubtotalType définit les types de sous-totaux disponibles.

Automatic — Aspose.Cells choisit la sélection par défaut (généralement Sum pour les champs numériques)
None — supprime toutes les lignes de sous-total
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

Les sous-totaux ne s’affichent que lorsqu’il y a au moins deux champs de tableau croisé dynamique dans la zone des lignes (ou dans la zone des colonnes). Un seul champ n’a rien de significatif à sous-totaliser entre, donc les appels SetSubtotals n’ont aucun effet visible dans ce cas. Cet article place donc deux champs de ligne (Category externe, Item interne) dans chaque exemple afin que la limite du sous-total entre chaque groupe Category soit visible.

Scénario 1 — Sous-totaux automatiques (par défaut)

Lorsque vous n’appelez pas du tout SetSubtotals, Aspose.Cells applique la sélection Automatic aux champs numériques. L’exemple suivant confirme explicitement ce comportement en appelant SetSubtotals(PivotFieldSubtotalType.Automatic, true) sur le champ de ligne externe Category.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

worksheet.Cells[0, 0].PutValue("Category");
worksheet.Cells[0, 1].PutValue("Item");
worksheet.Cells[0, 2].PutValue("Year");
worksheet.Cells[0, 3].PutValue("Amount");

worksheet.Cells[1, 0].PutValue("Fruit");
worksheet.Cells[1, 1].PutValue("Apple");
worksheet.Cells[1, 2].PutValue(2020);
worksheet.Cells[1, 3].PutValue(100);

worksheet.Cells[2, 0].PutValue("Fruit");
worksheet.Cells[2, 1].PutValue("Apple");
worksheet.Cells[2, 2].PutValue(2021);
worksheet.Cells[2, 3].PutValue(150);

worksheet.Cells[3, 0].PutValue("Fruit");
worksheet.Cells[3, 1].PutValue("Banana");
worksheet.Cells[3, 2].PutValue(2020);
worksheet.Cells[3, 3].PutValue(80);

worksheet.Cells[4, 0].PutValue("Fruit");
worksheet.Cells[4, 1].PutValue("Banana");
worksheet.Cells[4, 2].PutValue(2021);
worksheet.Cells[4, 3].PutValue(90);

worksheet.Cells[5, 0].PutValue("Vegetable");
worksheet.Cells[5, 1].PutValue("Carrot");
worksheet.Cells[5, 2].PutValue(2020);
worksheet.Cells[5, 3].PutValue(50);

worksheet.Cells[6, 0].PutValue("Vegetable");
worksheet.Cells[6, 1].PutValue("Carrot");
worksheet.Cells[6, 2].PutValue(2021);
worksheet.Cells[6, 3].PutValue(60);

worksheet.Cells[7, 0].PutValue("Vegetable");
worksheet.Cells[7, 1].PutValue("Daikon");
worksheet.Cells[7, 2].PutValue(2020);
worksheet.Cells[7, 3].PutValue(40);

worksheet.Cells[8, 0].PutValue("Vegetable");
worksheet.Cells[8, 1].PutValue("Daikon");
worksheet.Cells[8, 2].PutValue(2021);
worksheet.Cells[8, 3].PutValue(45);

int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Category");
pivotTable.AddFieldToArea(PivotFieldType.Row, "Item");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

PivotField categoryField = pivotTable.RowFields[0];
categoryField.SetSubtotals(PivotFieldSubtotalType.Automatic, true);

pivotTable.CalculateData();

workbook.Save("output_automatic.xlsx");

Scénario 2 — Suppression de tous les sous-totaux (None)

L’appel de SetSubtotals(PivotFieldSubtotalType.None, true) supprime toutes les lignes de sous-total du tableau croisé dynamique, ne laissant que les lignes de champ et le total général en bas. Ceci est utile lorsque vous souhaitez les données regroupées brutes sans aucune ligne de synthèse.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

string[] headers = { "Category", "Item", "Year", "Amount" };
for (int j = 0; j < headers.Length; j++)
{
    worksheet.Cells[0, j].PutValue(headers[j]);
}

object[,] data = {
    { "Fruit",     "Apple",  2020, 100 },
    { "Fruit",     "Apple",  2021, 150 },
    { "Fruit",     "Banana", 2020, 80  },
    { "Fruit",     "Banana", 2021, 90  },
    { "Vegetable", "Carrot", 2020, 50  },
    { "Vegetable", "Carrot", 2021, 60  },
    { "Vegetable", "Daikon", 2020, 40  },
    { "Vegetable", "Daikon", 2021, 45  }
};

for (int i = 0; i < data.GetLength(0); i++)
{
    for (int j = 0; j < data.GetLength(1); j++)
    {
        worksheet.Cells[i + 1, j].PutValue(data[i, j]);
    }
}

int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Category");
pivotTable.AddFieldToArea(PivotFieldType.Row, "Item");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

PivotField categoryField = pivotTable.RowFields[0];
categoryField.SetSubtotals(PivotFieldSubtotalType.None, true);
pivotTable.CalculateData();

workbook.Save("output_none.xlsx");

Scénario 3 — Sous-ensemble personnalisé de sous-totaux (Sum + Average)

Vous n’êtes pas limité à un seul type de sous-total. Chaque appel de SetSubtotals opère indépendamment sur un seul type, donc appeler la méthode deux fois — une fois avec Sum et une fois avec Average — produit un sous-ensemble personnalisé de deux lignes de sous-total pour chaque groupe Category.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

worksheet.Cells["A1"].PutValue("Category");
worksheet.Cells["B1"].PutValue("Item");
worksheet.Cells["C1"].PutValue("Year");
worksheet.Cells["D1"].PutValue("Amount");

worksheet.Cells[1, 0].PutValue("Fruit");
worksheet.Cells[1, 1].PutValue("Apple");
worksheet.Cells[1, 2].PutValue(2020);
worksheet.Cells[1, 3].PutValue(100);

worksheet.Cells[2, 0].PutValue("Fruit");
worksheet.Cells[2, 1].PutValue("Apple");
worksheet.Cells[2, 2].PutValue(2021);
worksheet.Cells[2, 3].PutValue(150);

worksheet.Cells[3, 0].PutValue("Fruit");
worksheet.Cells[3, 1].PutValue("Banana");
worksheet.Cells[3, 2].PutValue(2020);
worksheet.Cells[3, 3].PutValue(80);

worksheet.Cells[4, 0].PutValue("Fruit");
worksheet.Cells[4, 1].PutValue("Banana");
worksheet.Cells[4, 2].PutValue(2021);
worksheet.Cells[4, 3].PutValue(90);

worksheet.Cells[5, 0].PutValue("Vegetable");
worksheet.Cells[5, 1].PutValue("Carrot");
worksheet.Cells[5, 2].PutValue(2020);
worksheet.Cells[5, 3].PutValue(50);

worksheet.Cells[6, 0].PutValue("Vegetable");
worksheet.Cells[6, 1].PutValue("Carrot");
worksheet.Cells[6, 2].PutValue(2021);
worksheet.Cells[6, 3].PutValue(60);

worksheet.Cells[7, 0].PutValue("Vegetable");
worksheet.Cells[7, 1].PutValue("Daikon");
worksheet.Cells[7, 2].PutValue(2020);
worksheet.Cells[7, 3].PutValue(40);

worksheet.Cells[8, 0].PutValue("Vegetable");
worksheet.Cells[8, 1].PutValue("Daikon");
worksheet.Cells[8, 2].PutValue(2021);
worksheet.Cells[8, 3].PutValue(45);

PivotTableCollection pivotTables = worksheet.PivotTables;
int pivotIndex = pivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = pivotTables[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Category");
pivotTable.AddFieldToArea(PivotFieldType.Row, "Item");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

PivotField categoryField = pivotTable.RowFields[0];
categoryField.SetSubtotals(PivotFieldSubtotalType.Sum, true);
categoryField.SetSubtotals(PivotFieldSubtotalType.Average, true);

pivotTable.CalculateData();

workbook.Save("output_custom.xlsx");

Récapitulatif

Les trois scénarios ci-dessus partagent le même jeu de données et la même structure de tableau croisé dynamique. La seule différence entre eux est l’appel SetSubtotals appliqué au champ de ligne externe Category. Rappelez-vous la règle des deux champs : un seul champ dans une zone n’a rien à sous-totaliser entre, donc placez toujours au moins deux champs dans la zone des lignes ou des colonnes lorsque vous souhaitez que SetSubtotals ait un effet visible.

Net: Gérer les champs de valeur d'un tableau croisé dynamique dans Aspose.Cells pour .NET

Mon, 01 Jan 0001 00:00:00 +0000

Ajout d’un champ à la zone de données

L’ajout d’un champ de base à la zone de données (valeur) constitue la première étape pour définir la manière dont un tableau croisé dynamique agrège vos données sources. Aspose.Cells expose PivotTable.AddFieldToArea(PivotFieldType, string), une surcharge qui accepte la constante PivotFieldType.Data et le nom de la colonne source. Une fois qu’un champ est ajouté à la zone de données, l’API l’expose via la collection PivotTable.DataFields, dans l’ordre dans lequel les champs ont été ajoutés. Par défaut, une colonne source numérique est résumée avec ConsolidationFunction.Sum, tandis qu’une colonne non numérique utilise par défaut Count.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

// En-têtes dans A1:D1
worksheet.Cells[0, 0].PutValue("Category");
worksheet.Cells[0, 1].PutValue("Item");
worksheet.Cells[0, 2].PutValue("Year");
worksheet.Cells[0, 3].PutValue("Amount");

// Lignes de données A2:D9 utilisant des boucles imbriquées avec branchement sur j
for (int i = 1; i <= 8; i++)
{
 for (int j = 0; j < 4; j++)
 {
 switch (j)
 {
 case 0:
 worksheet.Cells[i, j].PutValue(i <= 4 ? "Fruit" : "Vegetable");
 break;
 case 1:
 if (i == 1 || i == 2) worksheet.Cells[i, j].PutValue("Apple");
 else if (i == 3 || i == 4) worksheet.Cells[i, j].PutValue("Banana");
 else if (i == 5 || i == 6) worksheet.Cells[i, j].PutValue("Carrot");
 else worksheet.Cells[i, j].PutValue("Daikon");
 break;
 case 2:
 worksheet.Cells[i, j].PutValue(2020 + ((i - 1) % 2));
 break;
 case 3:
 if (i == 1) worksheet.Cells[i, j].PutValue(100);
 else if (i == 2) worksheet.Cells[i, j].PutValue(150);
 else if (i == 3) worksheet.Cells[i, j].PutValue(80);
 else if (i == 4) worksheet.Cells[i, j].PutValue(90);
 else if (i == 5) worksheet.Cells[i, j].PutValue(50);
 else if (i == 6) worksheet.Cells[i, j].PutValue(60);
 else if (i == 7) worksheet.Cells[i, j].PutValue(40);
 else worksheet.Cells[i, j].PutValue(45);
 break;
 }
 }
}

// Ajouter un tableau croisé dynamique à F3 avec le nom PivotTable1
int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Mise en page du tableau croisé : Catégorie et Article sur Ligne, Année sur Colonne, Montant comme champ de données
pivotTable.AddFieldToArea(PivotFieldType.Row, "Category");
pivotTable.AddFieldToArea(PivotFieldType.Row, "Item");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

pivotTable.CalculateData();
workbook.Save("output_drag.xlsx");

Modification de la fonction de synthèse

Chaque champ placé dans la zone de données est encapsulé en interne sous forme d’instance PivotField, et sa propriété Function renvoie une valeur de l’énumération ConsolidationFunction. Le même accesseur Function vous permet de basculer entre les agrégats disponibles, notamment Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var et Varp.

La modification de Function n’affecte que l’agrégat ; la colonne source ne change pas.

Vous pouvez donc laisser un champ de données en tant que Sum tout en ajoutant un second champ de données qui cible la même colonne source mais utilise Count ou Average, le tout dans un seul tableau croisé dynamique.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

worksheet.Cells[0, 0].PutValue("Category");
worksheet.Cells[0, 1].PutValue("Item");
worksheet.Cells[0, 2].PutValue("Year");
worksheet.Cells[0, 3].PutValue("Amount");

for (int i = 1; i <= 8; i++)
{
 for (int j = 0; j <= 3; j++)
 {
 if (j == 0)
 {
 worksheet.Cells[i, j].PutValue(i <= 5 ? "Fruit" : "Vegetable");
 }
 else if (j == 1)
 {
 string[] items = { "Apple", "Apple", "Banana", "Banana", "Carrot", "Carrot", "Daikon", "Daikon" };
 worksheet.Cells[i, j].PutValue(items[i - 1]);
 }
 else if (j == 2)
 {
 int[] years = { 2020, 2021, 2020, 2021, 2020, 2021, 2020, 2021 };
 worksheet.Cells[i, j].PutValue(years[i - 1]);
 }
 else
 {
 int[] amounts = { 100, 150, 80, 90, 50, 60, 40, 45 };
 worksheet.Cells[i, j].PutValue(amounts[i - 1]);
 }
 }
}

int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Category");
pivotTable.AddFieldToArea(PivotFieldType.Row, "Item");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");

pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

PivotField countField = pivotTable.DataFields[1];
countField.Function = ConsolidationFunction.Count;

pivotTable.CalculateData();

workbook.Save("output_function.xlsx");

Traçage des champs de valeur sur l’axe des lignes ou des colonnes

Lorsqu’un tableau croisé dynamique contient au moins deux champs de données, Aspose.Cells expose un champ virtuel supplémentaire appelé PivotTable.ValuesField. Ce champ virtuel représente l’agrégat de chaque champ de données présent dans la zone de données. Vous pouvez le faire glisser dans la zone des lignes ou des colonnes en tant que champ croisé dynamique de base, ce qui est utile pour disposer plusieurs mesures côte à côte.

PivotTable.ValuesField ne fonctionne pas s’il n’y a aucun ou un seul champ de valeur.

Les scénarios ci-dessous présentent trois exemples de bout en bout qui illustrent chaque capacité décrite ci-dessus par rapport à la même structure de tableau croisé dynamique.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

worksheet.Cells[0, 0].PutValue("Category");
worksheet.Cells[0, 1].PutValue("Item");
worksheet.Cells[0, 2].PutValue("Year");
worksheet.Cells[0, 3].PutValue("Amount");

string[] categories = { "Fruit", "Fruit", "Fruit", "Fruit", "Vegetable", "Vegetable", "Vegetable", "Vegetable" };
string[] items = { "Apple", "Apple", "Banana", "Banana", "Carrot", "Carrot", "Daikon", "Daikon" };
int[] years = { 2020, 2021, 2020, 2021, 2020, 2021, 2020, 2021 };
int[] amounts = { 100, 150, 80, 90, 50, 60, 40, 45 };

for (int i = 1; i <= 8; i++)
{
 for (int j = 0; j <= 3; j++)
 {
 if (j == 0) worksheet.Cells[i, j].PutValue(categories[i - 1]);
 else if (j == 1) worksheet.Cells[i, j].PutValue(items[i - 1]);
 else if (j == 2) worksheet.Cells[i, j].PutValue(years[i - 1]);
 else worksheet.Cells[i, j].PutValue(amounts[i - 1]);
 }
}

int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Category");
pivotTable.AddFieldToArea(PivotFieldType.Row, "Item");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

pivotTable.DataFields[1].Function = ConsolidationFunction.Count;

pivotTable.AddFieldToArea(PivotFieldType.Column, pivotTable.ValuesField.Name);

pivotTable.CalculateData();
workbook.Save("output_plot.xlsx");

Net: Ajouter des champs de filtre à un tableau croisé dynamique dans Aspose.Cells pour .NET

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells prend en charge le cycle de vie complet des champs de filtre dans les tableaux croisés dynamiques. Vous pouvez ajouter un champ de filtre via une API pratique de haut niveau ou via la collection PageFields de bas niveau, et vous pouvez piloter le filtre en mode sélection unique, le réinitialiser pour afficher tous les éléments de page, ou basculer le champ vers la sélection multiple afin que les utilisateurs puissent choisir plusieurs éléments de page à la fois grâce à l’interface à cases à cocher d’Excel.

Introduction

Un champ de filtre est un champ de tableau croisé dynamique qui contrôle quel sous-ensemble des données source le corps du tableau croisé dynamique affiche. L’utilisateur final le voit comme une liste déroulante en haut d’un tableau croisé dynamique rendu dans Excel, et sélectionner l’un des éléments de page disponibles reconstruit le corps du tableau croisé dynamique de sorte que seuls les enregistrements appartenant à cet élément de page soient synthétisés. Un champ de tableau croisé dynamique devient un champ de filtre lorsqu’il est enregistré en tant que PivotFieldType.Page plutôt que PivotFieldType.Row, PivotFieldType.Column ou PivotFieldType.Data.

Un champ de filtre peut fonctionner selon deux comportements. Dans le comportement par défaut en sélection unique, seul un élément de page est visible à la fois, de sorte que le corps du tableau croisé dynamique synthétise exactement un sous-ensemble. Dans le comportement en sélection multiple, le champ expose une liste de cases à cocher, et le corps du tableau croisé dynamique synthétise l’union de tous les éléments de page cochés. Le même champ source peut basculer entre ces comportements en activant ou désactivant une seule propriété.

Aspose.Cells for .NET expose deux façons équivalentes d’enregistrer un champ de filtre. L’API de haut niveau est PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName"), qui prend le nom de la colonne source et ajoute le champ en un seul appel. L’API de bas niveau est PivotTable.PageFields.Add(PivotField), qui est utilisée lorsque vous détenez déjà une référence PivotField et souhaitez ajouter la même instance de champ à la zone de filtre. Les deux API finissent par remplir la même collection PageFields, et la suite de cet article montre comment choisir entre elles et comment piloter chaque mode de filtrage.

Ajout d’un champ de filtre

Il existe deux façons d’enregistrer un champ de tableau croisé dynamique dans la zone de filtre. L’appel de haut niveau prend le nom de la colonne source sous forme de chaîne et constitue le chemin le plus courant. L’appel de bas niveau accepte une instance PivotField existante et est pratique lorsque le même objet champ doit être réutilisé dans plusieurs zones du tableau croisé dynamique. Les deux appels placent le champ dans PivotTable.PageFields, après quoi il apparaît comme la liste déroulante de page en haut du tableau croisé dynamique rendu.

Ajout d’un champ de filtre avec AddFieldToArea

L’exemple suivant construit un petit jeu de données Fruit / Année / Montant, place un tableau croisé dynamique dans la cellule E3 avec Fruit dans la zone de ligne, Amount dans la zone de données, et Year dans la zone de filtre, actualise le tableau croisé dynamique, et enregistre le classeur.

using System;
using System.IO;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// Créer un nouveau classeur
var workbook = new Workbook();
var worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

// Configurer la ligne d'en-tête
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Remplir 9 lignes de données d'exemple : Fruit, Année, Montant
object[,] data = new object[,]
{
    { "apple", 2020, 100 },
    { "banana", 2021, 200 },
    { "apple", 2021, 150 },
    { "grape", 2020, 120 },
    { "orange", 2022, 180 },
    { "banana", 2020, 90 },
    { "grape", 2021, 130 },
    { "apple", 2022, 170 },
    { "orange", 2021, 110 }
};

for (int i = 0; i < data.GetLength(0); i++)
{
    worksheet.Cells[i + 1, 0].PutValue(data[i, 0]);
    worksheet.Cells[i + 1, 1].PutValue(data[i, 1]);
    worksheet.Cells[i + 1, 2].PutValue(data[i, 2]);
}

// Ajouter un tableau croisé dynamique ancré à la cellule E3
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Ajouter des champs à leurs zones : Fruit comme Ligne, Montant comme Données, Année comme champ de Page
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Actualiser et calculer les données du tableau croisé dynamique
pivotTable.CalculateData();

// Enregistrer le classeur
workbook.Save("pageFieldSample.xlsx");

Ajout d’un champ de filtre avec PageFields.Add

Lorsque vous travaillez déjà avec une instance PivotField, vous pouvez la passer directement à PivotTable.PageFields.Add. Le tableau croisé dynamique et le champ de filtre sont construits exactement comme dans le scénario précédent ; seule l’enregistrement final dans la zone de filtre est remplacé par l’appel d’API de bas niveau.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// — Le tableau croisé dynamique et le champ de page sont construits exactement comme dans
//   Scénario 1a (données Fruit/Année/Montant, pivot à E3, Fruit→Ligne,
//   Montant→Données). Ci-dessous, nous obtenons le PivotField Année à partir de la
//   collection BaseFields et le passons à PageFields.Add — l'
//   alternative de bas niveau à AddFieldToArea. Le résultat est
//   fonctionnellement identique au Scénario 1a.

Workbook workbook = new Workbook();
Worksheet sheet = workbook.Worksheets[0];

// En-têtes
sheet.Cells["A1"].PutValue("Fruit");
sheet.Cells["B1"].PutValue("Year");
sheet.Cells["C1"].PutValue("Amount");

// Données d'exemple (9 lignes)
sheet.Cells["A2"].PutValue("apple");    sheet.Cells["B2"].PutValue("2020"); sheet.Cells["C2"].PutValue(100);
sheet.Cells["A3"].PutValue("apple");    sheet.Cells["B3"].PutValue("2021"); sheet.Cells["C3"].PutValue(150);
sheet.Cells["A4"].PutValue("apple");    sheet.Cells["B4"].PutValue("2022"); sheet.Cells["C4"].PutValue(200);
sheet.Cells["A5"].PutValue("grape");    sheet.Cells["B5"].PutValue("2020"); sheet.Cells["C5"].PutValue(300);
sheet.Cells["A6"].PutValue("grape");    sheet.Cells["B6"].PutValue("2021"); sheet.Cells["C6"].PutValue(400);
sheet.Cells["A7"].PutValue("grape");    sheet.Cells["B7"].PutValue("2022"); sheet.Cells["C7"].PutValue(500);
sheet.Cells["A8"].PutValue("blueberry"); sheet.Cells["B8"].PutValue("2020"); sheet.Cells["C8"].PutValue(250);
sheet.Cells["A9"].PutValue("blueberry"); sheet.Cells["B9"].PutValue("2021"); sheet.Cells["C9"].PutValue(350);
sheet.Cells["A10"].PutValue("blueberry");sheet.Cells["B10"].PutValue("2022"); sheet.Cells["C10"].PutValue(450);

// Ajouter un tableau croisé dynamique à E3 couvrant A1:C10
int pivotIndex = sheet.PivotTables.Add("E3", "A1:C10", "PivotTable1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Fruit -> Ligne, Montant -> Données (Année ira à la Page ci-dessous)
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Approche de bas niveau : récupérer le PivotField Année existant à partir de BaseFields
// et l'enregistrer dans la zone Page via PageFields.Add(PivotField).
PivotField yearField = pivotTable.BaseFields["Year"];
pivotTable.PageFields.Add(yearField);

// Actualiser pour que le nouveau champ de page soit reflété dans le classeur enregistré
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Filtrage en sélection unique (affichage d’un seul élément de page)

Dans le comportement par défaut en sélection unique, le champ de filtre s’affiche sous forme de liste déroulante unique et l’entier PivotField.CurrentPageItem sélectionne l’élément de page qui pilote le corps du tableau croisé dynamique. Attribuer un index spécifique sélectionne cet élément ; attribuer la valeur sentinelle spéciale 0x7FFD (décimale 32765) réinitialise le filtre de sorte que tous les éléments de page soient synthétisés en même temps. La sélection unique est le mode par défaut ; vous n’avez pas besoin de l’activer explicitement.

Afficher tous les éléments

Définir CurrentPageItem sur la valeur magique 0x7FFD revient à effacer le filtre : le corps du tableau croisé dynamique synthétise tous les éléments de page comme si aucun filtre n’était appliqué.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

class Program
{
    static void Main()
    {
        // Créer un nouveau classeur
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];

        // Remplir les données Fruit/Année/Montant
        sheet.Cells["A1"].PutValue("Fruit");
        sheet.Cells["B1"].PutValue("Year");
        sheet.Cells["C1"].PutValue("Amount");

        object[,] data = new object[,]
        {
            {"Apple", 2022, 100},
            {"Apple", 2023, 150},
            {"Banana", 2022, 80},
            {"Banana", 2023, 120},
            {"Cherry", 2022, 200},
            {"Cherry", 2023, 250}
        };

        for (int r = 0; r < data.GetLength(0); r++)
        {
            for (int c = 0; c < data.GetLength(1); c++)
            {
                sheet.Cells[r + 1, c].PutValue(data[r, c]);
            }
        }

        // Créer un tableau croisé dynamique à E3
        var pivotTables = sheet.PivotTables;
        int index = pivotTables.Add("=A1:C7", "E3", "PivotTable1");
        PivotTable pivotTable = pivotTables[index];

        // Configurer les champs du tableau croisé : Fruit→Ligne, Montant→Données, Année→Page
        pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
        pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
        pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

        pivotTable.CalculateData();

        // Effacer le filtre de page afin que chaque élément du champ de page soit visible.
        // 0x7FFD (32765 en décimal) est la valeur sentinelle spéciale qui signifie « tous les éléments » —
        // équivalent à sélectionner « (Tous) » dans la liste déroulante du champ de page d'Excel.
        pivotTable.PageFields[0].CurrentPageItem = 0x7FFD;

        workbook.Save("output.xlsx");
    }
}

Afficher un élément spécifique

Définir CurrentPageItem sur un index réel ne sélectionne que cet élément de page. L’index correspond à la position de l’élément dans la liste triée des éléments du champ de filtre ; par exemple, 1 sélectionne le deuxième élément après le tri.

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// Créer le classeur
var workbook = new Workbook();
var sheet = workbook.Worksheets[0];
var cells = sheet.Cells;

// Ajouter des données d'exemple (Fruit/Année/Montant)
cells["A1"].PutValue("Fruit");
cells["B1"].PutValue("Year");
cells["C1"].PutValue("Amount");

cells["A2"].PutValue("Apple");
cells["B2"].PutValue("2020");
cells["C2"].PutValue("100");

cells["A3"].PutValue("Apple");
cells["B3"].PutValue("2021");
cells["C3"].PutValue("150");

cells["A4"].PutValue("Banana");
cells["B4"].PutValue("2020");
cells["C4"].PutValue("200");

cells["A5"].PutValue("Banana");
cells["B5"].PutValue("2021");
cells["C5"].PutValue("250");

// Ajouter un tableau croisé dynamique à E3
var pivotTables = sheet.PivotTables;
int pivotIndex = pivotTables.Add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables[pivotIndex];

// Ajouter des champs : Fruit→Ligne, Montant→Données, Année→Page
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Opérations spécifiques au champ de page
pivotTable.PageFields[0].CurrentPageItem = 1; // 1 = deuxième élément dans l'ordre trié (par ex. "2021")

// Actualiser et calculer le tableau croisé dynamique
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Filtrage en sélection multiple

Le filtrage en sélection multiple transforme la liste déroulante de page en une liste de cases à cocher et permet à l’utilisateur final de sélectionner simultanément plusieurs éléments de page. Aspose.Cells expose deux propriétés qui fonctionnent ensemble. PivotField.IsMultipleItemSelectionAllowed doit être définie sur true pour que l’interface de sélection multiple prenne effet. Une fois activée, PivotItem.IsHidden contrôle quels éléments apparaissent dans la liste de cases à cocher, ce qui vous permet soit d’afficher tous les éléments, soit d’autoriser uniquement des éléments spécifiques.

Le code ci-dessous active la sélection multiple sur le même champ de filtre Year construit dans le scénario 1a, puis montre deux schémas : la partie A révèle tous les éléments de page en laissant IsHidden défini sur false pour chaque entrée, tandis que la partie B autorise uniquement les valeurs source que vous choisissez et masque tout le reste via un bloc switch (pivotItems[i].GetStringValue()).

using System;
using Aspose.Cells;
using Aspose.Cells.Pivot;

// — Le tableau croisé dynamique et le champ de page sont construits exactement comme dans
//   le scénario 1a (données Fruit/Année/Montant, tableau croisé à E3, Fruit→Ligne,
//   Montant→Données, Année→Page via AddFieldToArea).
//   Ci-dessous, nous appliquons un filtrage multi-sélection sur le champ de page.

Workbook workbook = new Workbook();
Worksheet sheet = workbook.Worksheets[0];
Cells cells = sheet.Cells;

// Données d'exemple : Fruit | Année | Montant
cells[0, 0].PutValue("Fruit");
cells[0, 1].PutValue("Year");
cells[0, 2].PutValue("Amount");

string[,] data = new string[,]
{
    { "apple",  "2019", "100" },
    { "apple",  "2020", "150" },
    { "apple",  "2021", "200" },
    { "banana", "2019", "110" },
    { "banana", "2020", "160" },
    { "banana", "2021", "210" },
    { "grape",  "2019", "120" },
    { "grape",  "2020", "170" },
    { "grape",  "2021", "220" }
};

for (int i = 0; i < data.GetLength(0); i++)
{
    cells[i + 1, 0].PutValue(data[i, 0]);
    cells[i + 1, 1].PutValue(Convert.ToInt32(data[i, 1]));
    cells[i + 1, 2].PutValue(Convert.ToInt32(data[i, 2]));
}

Worksheet pivotSheet = workbook.Worksheets.Add("Pivot");
PivotTableCollection pivots = pivotSheet.PivotTables;
int pivotIndex = pivots.Add("A1:C10", "E3", "PivotTable1");
PivotTable pivotTable = pivots[pivotIndex];

pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// — Activer la multi-sélection sur le champ de page
pivotTable.PageFields[0].IsMultipleItemSelectionAllowed = true;

// Partie A — sélectionner TOUS les éléments (rendre chaque élément visible)
PivotItemCollection pivotItems = pivotTable.PageFields[0].PivotItems;
for (int i = 0; i < pivotItems.Count; i++)
{
    pivotItems[i].IsHidden = false;
}

// Partie B — sélectionner uniquement des éléments spécifiques par valeur source
for (int i = 0; i < pivotItems.Count; i++)
{
    switch (pivotItems[i].GetStringValue())
    {
        case "2020":
        case "grape":
        case "blueberry":
            pivotItems[i].IsHidden = false;
            break;
        default:
            pivotItems[i].IsHidden = true;
            break;
    }
}

pivotTable.CalculateData();

workbook.Save("output.xlsx");

Remarque : Lors de l’utilisation du filtrage en sélection multiple via PivotItem.IsHidden, au moins un PivotItem doit rester visible (IsHidden == false). Si tous les éléments sont masqués, Excel plante à l’ouverture du fichier ou affiche un tableau croisé dynamique vide. Vérifiez toujours que votre liste autorisée de sélection multiple inclut au moins un élément de vos données source.

Quelle API et quel mode dois-je utiliser ?

Le tableau ci-dessous résume quand utiliser chaque API et chaque mode afin que vous puissiez choisir la bonne combinaison sans lire chaque scénario en détail.

Scénario / Cas d’utilisation	API recommandée	Propriété utilisée	Remarques
Ajouter un champ de filtre par nom de colonne source (le plus courant)	`PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName")`	n/a	Haut niveau, une seule ligne. Utilisez ceci sauf si vous avez besoin d’une référence `PivotField`.
Ajouter un champ de filtre lorsque vous avez déjà un objet `PivotField`	`PivotTable.PageFields.Add(PivotField)`	n/a	À utiliser lorsque l’objet champ a été obtenu ailleurs ou doit être réutilisé.
Filtrer sur un seul élément de page (mode par défaut)	`PivotField.CurrentPageItem`	définir sur un index spécifique	Par exemple, `1` affiche le deuxième élément de la liste triée.
Afficher tous les éléments / effacer le filtre	`PivotField.CurrentPageItem`	définir sur `0x7FFD`	La valeur magique `0x7FFD` (décimale 32765) est la sentinelle pour « tous les éléments ».
Activer l’interface de sélection multiple dans Excel	`PivotField.IsMultipleItemSelectionAllowed`	définir sur `true`	Requis avant que tout appel à `IsHidden` ne prenne effet.
Masquer / afficher des éléments individuels dans une liste à sélection multiple	`PivotItem.IsHidden`	définir par élément	Au moins un élément doit rester visible (`IsHidden == false`).

N’oubliez jamais la contrainte de visibilité lors de la configuration du filtrage en sélection multiple. Si chaque PivotItem d’un champ de filtre à sélection multiple est masqué, Excel plante à l’ouverture ou affiche un tableau croisé dynamique vide. Construisez votre liste autorisée à partir de vos données source afin qu’au moins un élément reste visible, et vos classeurs enregistrés s’ouvriront de manière fiable sur toutes les machines.

Net: Supprimer le tableau croisé dynamique d une feuille de calcul

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells offre une fonctionnalité pour supprimer ou retirer un tableau croisé dynamique d’une feuille de calcul. Vous pouvez supprimer le tableau croisé dynamique en utilisant l’objet tableau croisé dynamique ou la position du tableau croisé dynamique. Veuillez utiliser la méthode Worksheet.PivotTables.Remove() pour supprimer le tableau croisé dynamique en utilisant l’objet tableau croisé dynamique et la méthode Worksheet.PivotTables.RemoveAt() pour supprimer l’objet tableau croisé dynamique en utilisant sa position dans la collection de tableaux croisés dynamiques.

Le code d’exemple suivant supprime deux tableaux croisés dynamiques de la feuille de calcul. D’abord, il supprime un tableau croisé dynamique en utilisant la méthode Worksheet.PivotTables.Remove() et ensuite il supprime un tableau croisé dynamique en utilisant la méthode Worksheet.PivotTables.RemoveAt()

Net: Enregistrer un tableau croisé dynamique dans un fichier ODS

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells offre la possibilité de sauvegarder un tableau croisé dynamique dans des fichiers ODS. Pour cela, convertissez simplement un classeur avec un tableau croisé dynamique existant ou créez un nouveau tableau croisé dynamique et enregistrez le fichier au format ODS. Assurez-vous d’appeler PivotTable.CalculateData() avant l’enregistrement pour garantir que le tableau croisé dynamique est rendu dans le fichier ODS de sortie. L’extrait de code suivant montre comment enregistrer un tableau croisé dynamique dans un fichier ODS.

Code d’exemple

Le fichier de sortie généré par le code ci-dessus est joint à titre de référence.

Fichier ODS de sortie

Documentation – Insérer un tableau croisé dynamique

Net: Formatage du tableau croisé dynamique

Apparence du tableau croisé dynamique

Configurer les options de formatage du tableau croisé dynamique

Définition du type AutoFormat

Paramétrage des options de formatage

Aspect et sensation du formatage manuel

Options de formatage de champ de tableau croisé dynamique

Formatage des champs de ligne/colonne/page

Formatage des champs de données

Effacement des Champs de Tableau Croisé Dynamique

Net: Créer des tableaux croisés dynamiques et des graphiques croisés dynamiques

Ajout de tables pivot et de graphiques

Préparation à l’utilisation d’Aspose.Cells

Ajouter un tableau croisé dynamique

Ajout d’un graphique croisé dynamique

Net: Tableau croisé dynamique et données sources

Données source du tableau croisé dynamique

Modification des données source d’un tableau croisé dynamique

Net: Ajouter un champ calculé dans le tableau croisé dynamique

Scénarios d’utilisation possibles

Ajouter un champ calculé dans un tableau croisé dynamique dans Excel

Ajouter un champ calculé dans un tableau croisé dynamique en utilisant C#

Code d’exemple

Net: Actualisation des tableaux croisés dynamiques dans Aspose.Cells for .NET

Introduction

Directives Using requises

Actualiser tous les tableaux croisés dynamiques du classeur

Actualiser tous les tableaux croisés dynamiques d’une seule feuille de calcul

Actualiser un seul tableau croisé dynamique

Les données source ont changé — Utilisez PivotCache.Refresh()

Seule l’affichage/la disposition a changé — Utilisez CalculateData()

Obtenir tous les tableaux croisés dynamiques partageant le même PivotCache

Migration depuis l’obsolète PivotTable.RefreshData()

Quelle API d’actualisation dois-je utiliser ?

Net: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells pour .NET

Introduction

Application d’un autoformat prédéfini XLS hérité

Application d’un style prédéfini nommé moderne de tableau croisé dynamique

Définition et application d’un style personnalisé de tableau croisé dynamique

Application d’un style unique à chaque cellule du tableau croisé dynamique avec FormatAll

Quelle API de style dois-je utiliser ?

Net: Ajouter des champs de ligne et de colonne à un tableau croisé dynamique dans Aspose.Cells pour .NET

Ajout d’un champ à la zone des lignes ou des colonnes

Sous-totaux des champs du tableau croisé dynamique

Scénario 1 — Sous-totaux automatiques (par défaut)

Scénario 2 — Suppression de tous les sous-totaux (None)

Scénario 3 — Sous-ensemble personnalisé de sous-totaux (Sum + Average)

Récapitulatif

Net: Gérer les champs de valeur d'un tableau croisé dynamique dans Aspose.Cells pour .NET

Ajout d’un champ à la zone de données

Modification de la fonction de synthèse

Traçage des champs de valeur sur l’axe des lignes ou des colonnes

Net: Ajouter des champs de filtre à un tableau croisé dynamique dans Aspose.Cells pour .NET

Introduction

Ajout d’un champ de filtre

Ajout d’un champ de filtre avec AddFieldToArea

Ajout d’un champ de filtre avec PageFields.Add

Filtrage en sélection unique (affichage d’un seul élément de page)

Afficher tous les éléments

Afficher un élément spécifique

Filtrage en sélection multiple

Quelle API et quel mode dois-je utiliser ?

Net: Supprimer le tableau croisé dynamique d une feuille de calcul

Net: Enregistrer un tableau croisé dynamique dans un fichier ODS

Code d’exemple

Les données source ont changé — Utilisez `PivotCache.Refresh()`

Seule l’affichage/la disposition a changé — Utilisez `CalculateData()`

Migration depuis l’obsolète `PivotTable.RefreshData()`