Documentation – Inserisci tabella pivot

Net: Formattazione della tabella pivot

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

Aspetto della tabella pivot

Come creare una tabella pivot spiega come creare una semplice tabella pivot. Questo articolo descrive come personalizzare l’aspetto di una tabella pivot impostando diverse proprietà:

Opzioni di formato tabella pivot
Opzioni di formato dei campi pivot
Opzioni di formato del campo dati

Impostazione delle opzioni di formato della tabella pivot

La classe PivotTable controlla complessivamente la tabella pivot e può essere formattata in vari modi.

Impostazione del tipo di formato automatico

Microsoft Excel offre diversi formati preimpostati per i report. Anche Aspose.Cells supporta queste opzioni di formattazione. Per accedervi:

Imposta PivotTable.IsAutoFormat su vero.
Assegna un’opzione di formattazione dall’enumerazione PivotTableAutoFormatType.

Impostazione delle Opzioni di Formato

Il codice di esempio qui sotto mostra come formattare la tabella pivot per mostrare i totali generali per righe e colonne, e come impostare l’ordine dei campi del report. Mostra inoltre come impostare una stringa personalizzata per i valori nulli.

Formattazione Aspetto e Sensazione Manualmente

Per formattare manualmente l’aspetto del report della tabella pivot, anziché utilizzare formati di report predefiniti, utilizzare i metodi PivotTable.Format() e PivotTable.FormatAll(). Creare un oggetto stile per la formattazione desiderata, ad esempio:

Impostazione delle opzioni di formato campo pivot

La classe PivotField rappresenta un campo in una tabella pivot e può essere formattata in vari modi. Il codice di esempio qui sotto mostra come:

Accedere ai campi di riga.
Impostare i subtotali.
Impostazione dell’ordinamento automatico.
Impostazione dell’autovisualizzazione.

Impostazione delle opzioni di formato campi riga/colonna/pagina

Impostazione del formato dei campi dati

Il campione di codice sottostante mostra come impostare i formati di visualizzazione e il formato numerico per i campi dati.

Cancellazione dei Campi di Tabella Pivot

Il PivotFieldCollection ha un metodo chiamato Clear() che ti consente di eliminare i campi di un Pivot. Usalo quando vuoi eliminare tutti i campi di un Pivot nelle aree, ad esempio, pagina, colonna, riga o dati. Il campione di codice sottostante mostra come eliminare tutti i campi di un Pivot in un’area dati.

Net: Creare Tabelle Pivot e Grafici Pivot

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

Una tabella pivot è un riassunto interattivo di record. Ad esempio, potresti avere centinaia di voci di fattura in un elenco in un foglio di lavoro. Una tabella pivot può totalizzare le fatture per cliente, prodotto o data. Con Microsoft Excel è possibile ridisporre rapidamente le informazioni nella tabella pivot trascinando i pulsanti in una nuova posizione.

Un grafico pivot è una rappresentazione grafica interattiva dei dati in una tabella pivot. I grafici pivot sono stati introdotti in Excel 2000. Utilizzando un grafico pivot è ancora più facile capire i dati poiché la tabella pivot crea automaticamente subtotali e totali.

Aspose.Cells supporta le tabelle pivot e i grafici pivot.

Aggiunta di tabelle pivot e grafici

Aspose.Cells fornisce un insieme speciale di classi utilizzate per creare tabelle pivot. Queste classi vengono utilizzate per creare e impostare gli oggetti PivotTable, che fungono da blocchi di costruzione di base di un oggetto PivotTable:

PivotField, un campo in un rapporto di tabella pivot.
PivotFields, una raccolta di tutti gli oggetti PivotField in una tabella pivot.
PivotTable, un rapporto di tabella pivot su un foglio di lavoro.
PivotTables, una raccolta di tutti gli oggetti PivotTable sul foglio di lavoro.

Preparazione all’uso di Aspose.Cells

Scarica e installa Aspose.Cells:
1. Scarica Aspose.Cells.
2. Installalo sul tuo computer di sviluppo. Tutti i componenti Aspose, una volta installati, funzionano in modalità di valutazione. La modalità di valutazione non ha limiti di tempo e inserisce solo watermark nei documenti prodotti. Per utilizzare il componente a piena capacità, è necessario disporre di una licenza valida.
Crea un progetto:
1. Avviare Visual Studio.Net.
2. Crea una nuova applicazione console.
Aggiungi riferimenti: Aggiungi un riferimento al componente Aspose.Cells nel tuo progetto, ad esempio …\Program Files\Aspose\Aspose.Cells\Bin\Net1.0\Aspose.Cells.dll

Aggiunta di una tabella pivot

Per creare una tabella pivot utilizzando Aspose.Cells:

Aggiungi alcuni dati a delle celle del foglio di lavoro utilizzando il metodo PutValue/setValue di un oggetto Cell. Puoi anche usare un file modello già compilato con dati. I dati verranno utilizzati come origine dati della tabella pivot.
Aggiungi una tabella pivot al foglio di lavoro chiamando il metodo add della collezione PivotTables (incapsulato nell’oggetto Worksheet).
Accedi al nuovo oggetto PivotTable dalla collezione PivotTables passando il suo indice. # Usa uno qualsiasi degli oggetti tabella pivot incapsulati nell’oggetto PivotTable per gestire la tabella.

Di seguito sono riportati esempi di codice.

Aggiunta di un grafico pivot

Per creare un PivotChart utilizzando Aspose.Cells:

Aggiungi un grafico.
Imposta il PivotSource del grafico per fare riferimento a una tabella pivot esistente nel foglio di calcolo.
Imposta altri attributi.

Net: Tabella Pivot e Dati di Origine

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

Dati di Origine della Tabella Pivot

Ci sono momenti in cui si desidera creare report di Microsoft Excel con tabelle pivot che prendono dati da diverse fonti di dati (come un database) che non sono noti al momento della progettazione. Questo articolo fornisce un approccio per cambiare dinamicamente la fonte dati di una tabella pivot.

Cambiare i Dati di Origine di una Tabella Pivot

Creazione di un nuovo modello di design.
1. Creare un nuovo file di modello di design come nella schermata qui sotto.
2. Definire quindi un intervallo nominato, DataSource, che si riferisce a questo intervallo di celle.
  
  Creazione di un modello di design e definizione di un intervallo nominato, DataSource

Creazione di una Tabella Pivot basata su questo intervallo nominato.
1. In Microsoft Excel, scegliere Dati, quindi Tabella Pivot e Rapporto Tabella Pivot.
2. Creare una tabella pivot basata sull’intervallo nominato creato nel primo passaggio.
  
  Creazione di una tabella pivot basata sull’intervallo nominato, DataSource

Trascinare il campo corrispondente sulla riga e sulla colonna della tabella pivot, quindi creare la tabella pivot risultante come nella schermata qui sotto.

Creazione di una tabella pivot basata su un campo corrispondente

Fare clic con il tasto destro sulla tabella pivot e selezionare Opzioni Tabella.
1. Seleziona Aggiorna all’apertura nelle impostazioni delle Opzioni dati.
  
  Impostare le opzioni della tabella pivot

Ora puoi salvare questo file come il file del modello del tuo designer.

Popolazione di nuovi dati e modifica dei dati di origine di una tabella pivot.
1. Una volta creato il modello del designer, utilizza il codice seguente per modificare i dati di origine della tabella pivot.

Eseguendo il codice di esempio sottostante si cambia il dato di origine della tabella pivot.

Net: Aggiungi campo calcolato nella tabella pivot

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

Possibili Scenari di Utilizzo

Quando crei una tabella pivot basata su dati noti, scopri che i dati al suo interno non sono quelli che desideri. I dati che desideri sono la combinazione di questi dati originali. Ad esempio, è necessario aggiungere, sottrarre, moltiplicare e dividere i dati originali prima di volerli. A questo punto, è necessario creare un campo calcolato e impostare la formula corrispondente per il calcolo. Quindi eseguire alcune statistiche e altre operazioni sul campo calcolato.

Aggiungi campo calcolato nella tabella pivot in Excel

Inserisci un campo calcolato in una tabella pivot in Excel, segui questi passaggi:

Seleziona la tabella pivot a cui desideri aggiungere un campo calcolato.
Vai alla scheda Analizza tabella pivot nel menu a nastro.
Fai clic su “Campi, elementi e set” e quindi seleziona “Campo calcolato” dal menu a discesa.
Nel campo “Nome”, inserire un nome per il campo calcolato.
Nel campo “Formula”, inserire la formula per il calcolo che si desidera eseguire utilizzando i nomi dei campi del PivotTable appropriati e gli operatori matematici.
Fare clic su “ok” per creare il campo calcolato.
Il nuovo campo calcolato apparirà nell’elenco dei campi del PivotTable nella sezione dei Valori.
Trascinare il campo calcolato nella sezione dei Valori del PivotTable per visualizzare i valori calcolati.

Aggiungi campo calcolato nella tabella pivot utilizzando C#

Aggiungi campo calcolato al file Excel utilizzando Aspose.Cells. Si prega di vedere il seguente codice di esempio. Dopo l’esecuzione del codice di esempio, viene aggiunta una tabella pivot con campo calcolato al foglio di lavoro.

Impostare i dati originali e creare una tabella pivot.
Creare il campo calcolato in base al PivotField esistente nella tabella pivot.
Aggiungere il campo calcolato all’area dati.
Infine, salvare il libro di lavoro nel formato output XLSX.

Codice di Esempio

Net: Aggiornare tabelle pivot e cache pivot in Aspose.Cells per .NET

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

Aspose.Cells fornisce un’API di aggiornamento a più livelli che consente di ricaricare i dati delle pivot in quattro ambiti diversi — dall’intera cartella di lavoro fino a una singola tabella pivot. A partire da Aspose.Cells for .NET v26.7, il metodo legacy PivotTable.RefreshData() è contrassegnato come obsoleto e deve essere sostituito con le API più efficienti e consapevoli della cache descritte in questo articolo.

Introduzione

L’aggiornamento di una tabella pivot raramente è una singola operazione. Dietro le quinte, Aspose.Cells mantiene una catena di dati a più livelli che collega i dati di origine originali ai valori visualizzati nel foglio di lavoro. Comprendere questa catena è la chiave per scegliere l’API di aggiornamento giusta per ogni situazione.

La catena di dati a quattro livelli è:

Origine dati — gli intervalli del foglio di lavoro originali, la query del database o l’intervallo di consolidamento in cui risiedono i valori grezzi.
PivotCache — l’istantanea in memoria dei dati di origine. Ogni tabella pivot è costruita sopra un PivotCache; qui vengono raccolti e aggregati tutti i dati.
PivotTable — l’oggetto vista che definisce i campi di riga, colonna, valore e filtro. Una PivotTable legge solo dal proprio PivotCache, mai direttamente dall’origine dati.
Celle — le Cells del foglio di lavoro in cui la PivotTable rende i valori calcolati e gli stili.

Un concetto particolarmente importante è la cache condivisa. Quando più tabelle pivot nella cartella di lavoro fanno riferimento allo stesso intervallo di origine, esse condividono una singola istanza di PivotCache. Un singolo PivotCache può essere referenziato da molte tabelle pivot, e l’aggiornamento di quella cache aggiorna tutte le PivotTable dipendenti contemporaneamente.

PivotCache.SourceType (enum PivotTableSourceType) indica da dove provengono i dati della cache. A partire dalla v26.7, PivotCache.Refresh() supporta solo i tipi di origine Sheet e Consolidation — ovvero dati che risiedono in intervalli del foglio di lavoro. Le origini esterne (database, connessioni esterne, ecc.) non sono ancora aggiornabili tramite l’API della cache.

A causa di questa catena, ci sono due percorsi di aggiornamento fondamentali in Aspose.Cells:

PivotCache.Refresh() — ricarica l’origine → cache E ricalcola tutte le PivotTable dipendenti in una singola operazione.
PivotTable.CalculateData() — ricalcola la visualizzazione di una PivotTable dai dati già memorizzati nella cache, senza tornare all’origine dati.

Tutti gli scenari in questo articolo utilizzano dati di origine da celle del foglio di lavoro, quindi il tipo di origine è Sheet e le operazioni di aggiornamento si comportano come descritto.

Direttive Using richieste

Tutti gli esempi C# in questo articolo iniziano con le seguenti tre direttive using perché i tipi pivot risiedono nel namespace Aspose.Cells.Pivot:

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

Aggiornare tutte le tabelle pivot nella cartella di lavoro

Quando è necessario garantire che ogni cache pivot e ogni tabella pivot nella cartella di lavoro riflettano i dati di origine più recenti, l’API più semplice e completa è Workbook.RefreshAll(). Una singola chiamata attraversa l’intera cartella di lavoro — aggiornando ogni PivotCache dalla propria origine e quindi ricalcolando ogni PivotTable dipendente. Questo è l’approccio consigliato per aggiornamenti generali e completi del documento quando le prestazioni non rappresentano un problema.

L’esempio seguente crea una cartella di lavoro con un intervallo di origine Frutto/Anno/Importo, crea una tabella pivot, modifica alcuni valori di origine e quindi utilizza RefreshAll() per portare tutto aggiornato in una singola chiamata.

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

// Crea una nuova cartella di lavoro
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Scrivi la riga di intestazione nelle celle A1:C1
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Scrivi le righe di dati nelle celle A2:C9 (8 righe di dati sulla frutta per il 2020 e il 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);

// Aggiungi una tabella pivot: intervallo di origine "A1:C9", cella di destinazione "E3", nome "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Assegna i campi pivot: Frutta a Righe, Anno a Colonne, Importo a Dati
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modifica diversi valori di Importo nei dati di origine per simulare cambiamenti
worksheet.Cells["C2"].PutValue(55);
worksheet.Cells["C5"].PutValue(85);
worksheet.Cells["C9"].PutValue(125);

// Aggiorna ogni tabella pivot / cache pivot nella cartella di lavoro
workbook.RefreshAll();

// Salva la cartella di lavoro
workbook.Save("output.xlsx");

Aggiornare tutte le tabelle pivot su un singolo foglio di lavoro

A volte è necessario aggiornare solo le tabelle pivot che risiedono su uno specifico foglio di lavoro — ad esempio, quando è noto che le tabelle pivot su altri fogli di lavoro non sono correlate e non devono essere toccate. Per questo caso, Aspose.Cells fornisce Worksheet.RefreshPivotTables(), che è limitato a una singola istanza di Worksheet.

Questo è più selettivo rispetto a Workbook.RefreshAll(): vengono aggiornate solo le tabelle pivot sul foglio di lavoro di destinazione, lasciando intatte le tabelle pivot sugli altri fogli di lavoro.

L’esempio seguente popola gli stessi dati di origine Frutto/Anno/Importo, aggiunge una tabella pivot sul primo foglio di lavoro, modifica alcuni valori di origine e quindi aggiorna solo le tabelle pivot su quel foglio di lavoro.

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");

Aggiornare una singola tabella pivot

Quando si desidera un controllo granulare su una singola tabella pivot, l’API basata sulla cache offre due opzioni. La scelta tra di esse dipende da cosa è effettivamente cambiato: i dati di origine sottostanti, o solo le impostazioni di vista/layout della tabella pivot stessa.

Dati di origine modificati — Usa `PivotCache.Refresh()`

Se i dati di origine sottostanti sono cambiati, il punto di ingresso corretto è pivotTable.PivotCache.Refresh(). Questa chiamata rilegge i dati di origine nella cache e quindi ricalcola ogni PivotTable che dipende da quella cache.

Poiché le tabelle pivot condividono una singola istanza di PivotCache, la chiamata di PivotCache.Refresh() ricalcola tutte le tabelle pivot costruite su quella stessa cache — non solo quella a cui si fa riferimento. Se due tabelle pivot condividono lo stesso intervallo di origine, l’aggiornamento di una cache aggiorna entrambe.

L’esempio seguente crea due tabelle pivot sullo stesso intervallo di origine per dimostrare questo comportamento di cache condivisa, modifica alcuni valori di origine e quindi aggiorna tramite un riferimento alla cache.

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

// Crea una nuova cartella di lavoro e accedi al primo foglio di lavoro
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Scrivi la riga di intestazione: Frutta / Anno / Importo
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Scrivi circa 9 righe di dati (uva / mirtillo / kiwi / ciliegia tra il 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);

// Aggiungi la prima tabella pivot "Pivot1" ancorata alla cella E3, intervallo di origine A1:C9
int pivotIndex1 = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable1 = worksheet.PivotTables[pivotIndex1];

// Assegna i campi per Pivot1
pivotTable1.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable1.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable1.AddFieldToArea(PivotFieldType.Data, "Amount");

// Aggiungi una SECONDA tabella pivot "Pivot2" ancorata a E15 utilizzando lo STESSO intervallo di origine A1:C9
// Sia Pivot1 che Pivot2 condividono un unico PivotCache perché l'intervallo di origine è identico.
int pivotIndex2 = worksheet.PivotTables.Add("A1:C9", "E15", "Pivot2");
PivotTable pivotTable2 = worksheet.PivotTables[pivotIndex2];

// Assegna gli stessi campi per Pivot2
pivotTable2.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable2.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable2.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modifica diversi valori delle celle Importo nei dati di origine per simulare una modifica dei dati
worksheet.Cells["C2"].PutValue(150);
worksheet.Cells["C4"].PutValue(350);
worksheet.Cells["C7"].PutValue(650);

// Aggiorna il PivotCache condiviso.
// Poiché Pivot1 e Pivot2 condividono lo stesso PivotCache, questa singola chiamata
// aggiorna ENTRAMBE le tabelle pivot (dati + stile) dall'origine aggiornata.
pivotTable1.PivotCache.Refresh();

// Salva la cartella di lavoro
workbook.Save("output.xlsx");

Solo vista/layout modificati — Usa `CalculateData()`

Se i dati di origine non sono cambiati ma solo le impostazioni di vista o layout della tabella pivot sono state modificate (ad esempio, un campo è stato spostato in un’area diversa, o un’impostazione di aggiornamento all’apertura è stata attivata/disattivata), non è necessario tornare all’origine dati. La cache contiene già i dati corretti; deve essere ricalcolata solo la PivotTable resa. In questo caso, pivotTable.CalculateData() è la scelta giusta.

Ciò evita l’inutile recupero dall’origine ed è significativamente più veloce quando molte tabelle pivot condividono la stessa cache.

L’esempio seguente modifica una proprietà non di origine della tabella pivot e quindi chiama CalculateData() per riprodurla dalla cache esistente.

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

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

// Scrivi la riga di intestazione Frutto / Anno / Importo
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Scrivi 8 righe di dati (righe 2-9, adattandosi all'intervallo di origine 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);

// Aggiungi una tabella pivot denominata "Pivot1" posizionata nella cella di destinazione E3, con origine da A1:C9
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.PivotTables[pivotIndex];

// Assegna i campi: Frutto a Riga, Anno a Colonna, Importo a Dati
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modifica una proprietà di visualizzazione/layout — questa è una modifica solo di presentazione,
// quindi NON richiede la rilettura dei dati di origine tramite PivotCache.Refresh().
pivotTable.RefreshDataOnOpeningFile = false;

// CalculateData() ridisegna la visualizzazione di QUESTA tabella pivot (dati + stile) dai
// dati già contenuti nella PivotCache. Poiché i dati di origine non sono cambiati,
// non viene eseguito alcun ritorno all'origine — vengono ricalcolati solo i valori memorizzati nella cache
// nelle celle del foglio di lavoro.
pivotTable.CalculateData();

// Salva la cartella di lavoro su disco
workbook.Save("output.xlsx");

Ottenere tutte le tabelle pivot che condividono lo stesso PivotCache

Una cartella di lavoro spesso contiene molte tabelle pivot che poggiano tutte su una cache condivisa. Per enumerarle — ad esempio, prima di eseguire un aggiornamento in batch, o per diagnosticare l’impatto della cache condivisa — utilizzare PivotCache.GetPivotTables(). Questo metodo restituisce la raccolta di tutte le PivotTable che dipendono dalla cache data.

Questo è anche il modo più diretto per confermare che due tabelle pivot condividono effettivamente la stessa istanza di PivotCache: è possibile confrontare i riferimenti alla cache, o semplicemente iterare la raccolta restituita da GetPivotTables() e osservare quali tabelle pivot vi compaiono.

L’esempio seguente crea due tabelle pivot sullo stesso intervallo di origine, verifica che condividano la stessa istanza di cache, e quindi enumera le tabelle pivot della cache.

Migrazione dall’obsoleto `PivotTable.RefreshData()`

Prima di Aspose.Cells for .NET v26.7, il modo standard per aggiornare una tabella pivot era chiamare PivotTable.RefreshData() su ogni tabella pivot individualmente. A partire dalla v26.7, quel metodo è contrassegnato come obsoleto e deve essere sostituito con le API consapevoli della cache descritte sopra.

Ci sono due motivi per cui l’approccio RefreshData() per tabella è problematico nelle cartelle di lavoro reali:

Recupera i dati dall’origine ogni volta che viene chiamato, anche quando l’origine non è cambiata.
Ogni chiamata aggiorna l’intera cache condivisa. Quando molte tabelle pivot condividono una cache, chiamare ripetutamente RefreshData() per ogni tabella pivot fa sì che la stessa cache venga recuperata più e più volte, il che è molto lento.

Le sostituzioni consigliate sono:

Aggiornare TUTTE le tabelle pivot nella cartella di lavoro → usare workbook.RefreshAll();
Aggiornarne ALCUNE → usare pivotTable.PivotCache.Refresh(); per una cache. Poiché la cache è condivisa, questa singola chiamata aggiorna ogni tabella pivot costruita sopra quella cache. Altre tabelle pivot che poggiano su una cache già aggiornata possono essere tranquillamente saltate.
È cambiata solo la vista/layout della pivot → usare pivotTable.CalculateData(); per riprodurre dalla cache esistente senza alcun ritorno all’origine.

L’esempio seguente dimostra il nuovo pattern efficiente per cartelle di lavoro con più tabelle pivot che condividono una singola cache.

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

// Crea una nuova cartella di lavoro e accedi al primo foglio di lavoro
Workbook workbook = new Workbook();
Worksheet sheet = workbook.Worksheets[0];

// --- Costruisci i dati di origine: Frutta / Anno / Importo (intestazione + 9 righe) ---
sheet.Cells["A1"].PutValue("Fruit");
sheet.Cells["B1"].PutValue("Year");
sheet.Cells["C1"].PutValue("Amount");

sheet.Cells["A2"].PutValue("Grape");      sheet.Cells["B2"].PutValue(2020); sheet.Cells["C2"].PutValue(1000);
sheet.Cells["A3"].PutValue("Blueberry");  sheet.Cells["B3"].PutValue(2020); sheet.Cells["C3"].PutValue(2000);
sheet.Cells["A4"].PutValue("Kiwi");       sheet.Cells["B4"].PutValue(2020); sheet.Cells["C4"].PutValue(1500);
sheet.Cells["A5"].PutValue("Cherry");     sheet.Cells["B5"].PutValue(2020); sheet.Cells["C5"].PutValue(2500);
sheet.Cells["A6"].PutValue("Grape");      sheet.Cells["B6"].PutValue(2021); sheet.Cells["C6"].PutValue(3000);
sheet.Cells["A7"].PutValue("Blueberry");  sheet.Cells["B7"].PutValue(2021); sheet.Cells["C7"].PutValue(1800);
sheet.Cells["A8"].PutValue("Kiwi");       sheet.Cells["B8"].PutValue(2021); sheet.Cells["C8"].PutValue(2200);
sheet.Cells["A9"].PutValue("Cherry");     sheet.Cells["B9"].PutValue(2021); sheet.Cells["C9"].PutValue(2700);

// --- Aggiungi la prima tabella pivot (Pivot1) nella cella di destinazione E3 ---
int idx1 = sheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable1 = sheet.PivotTables[idx1];
pivotTable1.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable1.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable1.AddFieldToArea(PivotFieldType.Data, "Amount");

// --- Aggiungi la SECONDA tabella pivot (Pivot2) sullo STESSO intervallo di origine ---
// Sia Pivot1 che Pivot2 condividono UN unico PivotCache sottostante.
// Questo è esattamente lo scenario in cui l'approccio legacy per-tabella RefreshData()
// diventa inefficiente: aggiornare una tabella recupera nuovamente l'intero
// cache condivisa, quindi aggiornare N tabelle esegue lo stesso recupero costoso N volte.
int idx2 = sheet.PivotTables.Add("A1:C9", "E15", "Pivot2");
PivotTable pivotTable2 = sheet.PivotTables[idx2];
pivotTable2.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable2.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable2.AddFieldToArea(PivotFieldType.Data, "Amount");

// --- Modifica diversi valori di Importo nei dati di origine ---
sheet.Cells["C2"].PutValue(5000);   // Uva 2020
sheet.Cells["C5"].PutValue(7500);   // Ciliegia 2020
sheet.Cells["C9"].PutValue(9500);   // Ciliegia 2021

// --- Pattern OBSOLETO (pre-26.7) — PivotTable.RefreshData() ---
// pivotTable1.RefreshData();  // recupera nuovamente dall'origine, aggiorna l'intera cache
// pivotTable2.RefreshData();  // recupera DI NUOVO — la cache è già aggiornata!
// Ogni chiamata ricostruisce la cache condivisa, quindi N tabelle = N recuperi ridondanti.

// --- NUOVO pattern v26.7+: aggiorna la cache UNA VOLTA, quindi rirenderizza secondo necessità ---
// Una sola chiamata a PivotCache.Refresh() porta i valori modificati nella cache condivisa
// E ricalcola la visualizzazione di OGNI tabella pivot che vi fa riferimento.
// Poiché Pivot1 e Pivot2 condividono un PivotCache, questa singola chiamata aggiorna
// entrambe le tabelle — non è richiesto un secondo viaggio di andata e ritorno all'origine.
pivotTable1.PivotCache.Refresh();

// CalculateData() rirenderizza solo la visualizzazione di una tabella pivot (dati + stile)
// dai dati già contenuti nella cache — NON tocca l'origine.
// Lo chiamiamo qui su Pivot2 puramente per dimostrare l'API: dopo che la cache
// è stata aggiornata una volta, qualsiasi tabella dipendente può essere rirenderizzata senza
// tornare all'origine. Usa CalculateData() da sola quando solo le impostazioni
// di vista/layout della tabella pivot sono cambiate e la cache è aggiornata.
pivotTable2.CalculateData();

workbook.Save("output.xlsx");

Quale API di aggiornamento dovrei usare?

La tabella seguente riassume le API di aggiornamento disponibili e quando scegliere ciascuna di esse.

Obiettivo	API consigliata	Note
Aggiornare tutto nella cartella di lavoro	`Workbook.RefreshAll()`	Una sola chiamata; copre tutte le cache e tabelle.
Aggiornare solo le tabelle pivot su un singolo foglio	`Worksheet.RefreshPivotTables()`	Limitato a un foglio di lavoro.
Dati di origine modificati per una cache	`pivotTable.PivotCache.Refresh()`	Aggiorna TUTTE le tabelle pivot su quella cache condivisa.
Sono cambiate solo le impostazioni di vista/layout	`pivotTable.CalculateData()`	Evita l’inutile ritorno all’origine.
Elencare tutte le tabelle pivot su una cache condivisa	`pivotCache.GetPivotTables()`	Usare per enumerare prima dell’aggiornamento in blocco.

In pratica, preferire le API basate sulla cache rispetto all’obsoleto RefreshData() per tabella. Esse sono consapevoli delle cache condivise, evitano recuperi ridondanti dall’origine e consentono di scegliere l’ambito più piccolo che soddisfa il requisito di aggiornamento.

Net: Applicare stili alle tabelle pivot in Aspose.Cells per .NET

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

Aspose.Cells supporta l’applicazione sia degli autoformati legacy per tabelle pivot (destinati ai file .xls) sia degli stili moderni denominati o personalizzati per tabelle pivot (destinati ai file .xlsx, .xlsm e .xlsb). L’API da chiamare dipende dal formato di file in cui la cartella di lavoro viene salvata, non dal formato da cui è stata caricata.

Introduzione

Aspose.Cells espone due API di stile parallele per le tabelle pivot. La scelta tra di esse è determinata dal formato di file in cui si salva la cartella di lavoro, non dal formato da cui la si legge. Una cartella di lavoro caricata da un file .xls può essere salvata nuovamente come .xlsx, e in tal caso si applica l’API di stile moderna anziché quella legacy.

Per l’output .xls legacy, utilizzare la proprietà PivotTable.AutoFormatType insieme all’enumerazione Aspose.Cells.Pivot.PivotTableAutoFormatType. Questa API corrisponde al selettore di autoformato che la versione classica di Excel offriva per le tabelle pivot.

Per l’output .xlsx, .xlsm e .xlsb moderni, sono disponibili due varianti dell’API di stile:

PivotTable.PivotTableStyleType seleziona uno degli stili denominati predefiniti (temi chiari e scuri, inclusi gli stili aggiunti in Excel 2017). Questi preset sono in sola lettura.
PivotTable.PivotTableStyleName seleziona uno stile personalizzato definito dall’utente tramite Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Gli stili personalizzati sono necessari quando si desidera modificare colori, bordi o caratteri oltre quanto offerto dai preset.

Inoltre, PivotTable.FormatAll(Style) è una scorciatoia che applica un singolo oggetto Style a ogni cella della pivot, sovrascrivendo qualsiasi impostazione effettuata tramite entrambe le API di nome stile sopra descritte. Ciò è utile quando è richiesto un aspetto uniforme indipendentemente dal tema sottostante.

Applicare un autoformato preset legacy XLS

PivotTable.AutoFormatType accetta un valore dall’enumerazione Aspose.Cells.Pivot.PivotTableAutoFormatType. I valori disponibili sono Report1 fino a Report10, Classic e Table1 fino a Table10.

AutoFormatType viene rispettato solo quando la cartella di lavoro viene salvata come .xls. Quando la stessa cartella di lavoro viene salvata come .xlsx, .xlsm o .xlsb, Excel ignora questa proprietà e ricorre alle impostazioni PivotTableStyleType e PivotTableStyleName.

L’esempio seguente carica una nuova cartella di lavoro, popola i dati di esempio Frutto/Anno/Importo, aggiunge una tabella pivot, applica PivotTableAutoFormatType.Report5 e salva il risultato come .xls.

Perché nessun campo colonna? Gli autoformati della serie Report (Report1 fino a Report10, Table1 fino a Table10) erano progettati in Excel classico per tabelle pivot monodimensionali con soli campi riga e valori — non hanno uno stile integrato per le intestazioni dei campi colonna. Se la tua tabella pivot richiede campi colonna, usa i preset moderni PivotTableStyleType dello Scenario 2 qui sotto, progettati per il layout bidimensionale usato da Excel moderno.

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

// Scenario 1: Applica un formato automatico preimpostato XLS legacy
// API in uso: PivotTable.AutoFormatType
// Formato file di destinazione: .xls (legacy)
// Per esempi completi e file di dati, visitare https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Crea una nuova cartella di lavoro
Workbook workbook = new Workbook();

// Ottieni il primo foglio di lavoro
Worksheet sheet = workbook.Worksheets[0];

// Popola i dati di origine con una riga di intestazione (Fruit, Year, Amount)
// e 9 righe di dati che coprono grape, blueberry, kiwi, cherry negli anni 2020 e 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);

// Aggiungi una tabella pivot nella cella di destinazione E3, denominata "Pivot1", usando l'intervallo di origine A1:C10
int pivotIndex = sheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Assegna i campi: Fruit -> Righe, Year -> Colonne, Amount -> Dati
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Applica il formato automatico preimpostato XLS legacy "Report5"
// Nota: questa proprietà è significativa solo quando si salva come .xls.
// Quando si salva come .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
// e utilizza ciò che specifica PivotTableStyleType / PivotTableStyleName.
pivotTable.AutoFormatType = PivotTableAutoFormatType.Report5;

// Salva la cartella di lavoro nel formato .xls legacy
workbook.Save("output.xls");

Applicare uno stile preset denominato moderno per tabelle pivot

PivotTable.PivotTableStyleType accetta un valore dall’enumerazione Aspose.Cells.PivotTableStyleType. L’enumerazione copre i temi chiari PivotTableStyleLight1 fino a PivotTableStyleLight28 e i temi scuri PivotTableStyleDark1 fino a PivotTableStyleDark28. Gli stili aggiunti in Excel 2017 (la seconda ondata di temi chiari e scuri) sono raggiungibili tramite la stessa enumerazione.

Questa è l’API consigliata per qualsiasi formato di file moderno. A differenza dell’autoformato legacy, lo stile qui selezionato viene reso fedelmente da Excel e sopravvive ai round-trip attraverso altri strumenti Office.

L’esempio seguente utilizza gli stessi dati Frutto/Anno/Importo, crea una tabella pivot identica, applica PivotTableStyleDark1 e salva la cartella di lavoro come .xlsx.

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

// Scenario 2: Applica uno stile preimpostato denominato moderno di Excel 2007+ utilizzando PivotTableStyleType.
// Formato del file di destinazione: .xlsx. L'enum PivotTableStyleType si trova nel namespace Aspose.Cells
// (non in Aspose.Cells.Pivot) — ecco perché non abbiamo bisogno di alcuna using aggiuntiva per esso.
// Riferimento 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];

// Riga di intestazione: Frutta / Anno / Importo
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// 9 righe di dati di Frutta / Anno / Importo
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);

// Aggiungi una tabella pivot in E3 denominata "Pivot1", con origine da A1:C10
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Assegna i campi pivot: Frutta -> area Righe, Anno -> area Colonne, Importo -> area Dati
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Applica uno stile pivot preimpostato denominato moderno di Excel 2007+.
// PivotTableStyleType è l'API corretta per i file .xlsx / .xlsm / .xlsb; AutoFormatType
// viene ignorato da Excel per questi formati. PivotTableStyleDark1 appartiene alla famiglia del tema scuro
// (PivotTableStyleDark1..PivotTableStyleDark28), e lo stesso enum espone anche i
// nuovi temi chiari/scuri di Excel 2017 (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.PivotTableStyleType = PivotTableStyleType.PivotTableStyleDark1;

// Salva come .xlsx moderno — questo è il formato per cui PivotTableStyleType è significativo.
workbook.Save("output.xlsx");

Definire e applicare uno stile personalizzato per tabelle pivot

I preset predefiniti non possono essere modificati. Ogni volta che è necessario sovrascrivere colori, bordi o caratteri, è necessario definire uno stile pivot personalizzato. Il flusso di lavoro si articola in tre passaggi:

Aggiungere uno stile personalizzato alla raccolta TableStyles della cartella di lavoro tramite Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name). Questo restituisce l’indice dello stile appena creato.
Configurare lo stile aggiungendo elementi (come WholeTable o GrandTotalRow) tramite TableStyle.TableStyleElements.Add(TableStyleElementType), quindi assegnare un Style a ciascun elemento tramite TableStyleElement.SetElementStyle(Style).
Applicare lo stile personalizzato alla pivot impostando PivotTable.PivotTableStyleName sul nome dello stile. Non utilizzare PivotTableStyleType qui, poiché tale proprietà seleziona i preset predefiniti.

PivotTableStyleName e PivotTableStyleType non sono intercambiabili. Utilizzare PivotTableStyleType per i preset predefiniti e PivotTableStyleName per gli stili personalizzati definiti tramite AddPivotTableStyle. Impostare entrambi è innocuo, ma solo quello corrispondente alla sorgente prevista viene reso.

I valori TableStyleElementType disponibili includono WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels e PageFieldValues.

L’esempio seguente definisce uno stile pivot personalizzato con un bordo nero sottile su WholeTable e un carattere rosso in grassetto su GrandTotalRow, quindi lo applica tramite PivotTableStyleName e salva come .xlsx.

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

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

// Popola i dati di origine: riga intestazione + 9 righe di dati (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);

// Aggiungi tabella pivot con origine da A1:C10, ancorata in E3, denominata "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");

// Passo 1: registra un nuovo stile di tabella pivot personalizzato e cattura il suo indice
int styleIndex = workbook.Worksheets.TableStyles.AddPivotTableStyle("CustomPivotStyle");
TableStyle tableStyle = workbook.Worksheets.TableStyles[styleIndex];

// Passo 2: aggiungi un elemento WholeTable e applica bordi sottili neri su tutti e quattro i lati
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);

// Passo 3: aggiungi un elemento GrandTotalRow e applica un font rosso in grassetto
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);

// Passo 4: applica lo stile personalizzato per nome (NON tramite PivotTableStyleType, che è per preset integrati)
pivotTable.PivotTableStyleName = "CustomPivotStyle";

workbook.Save("output.xlsx");

Applicare un unico stile a ogni cella della pivot con FormatAll

PivotTable.FormatAll(Style) è una scorciatoia che applica un singolo oggetto Style a ogni cella della tabella pivot, inclusi l’area dati, le intestazioni di riga e colonna e i totali. Qualsiasi cosa precedentemente impostata tramite PivotTableStyleType o PivotTableStyleName viene sovrascritta.

FormatAll sovrascrive sia PivotTableStyleType sia PivotTableStyleName. Utilizzarlo solo quando è richiesto un aspetto uniforme, indipendente dal tema, in tutta la pivot.

L’esempio seguente crea un Style con riempimento solido giallo, un carattere blu scuro in grassetto e bordi neri sottili su tutti i lati, quindi lo applica con FormatAll e salva come .xlsx.

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

// Scenario 4: Applica un singolo Stile a ogni cella della tabella pivot usando FormatAll
// API in uso: PivotTable.FormatAll(Style)
// Formato di destinazione: .xlsx
// Riferimento GitHub: vedi il repository Aspose.Cells-for-.NET — esempi di stile tabella pivot

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

// Popola i dati di origine: riga intestazione (riga 1) + 9 righe di dati (righe 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);

// Aggiungi tabella pivot: intervallo di origine A1:C10, cella di destinazione E3, nome "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Assegna i campi pivot: Fruit -> area Riga, Year -> area Colonna, Amount -> area Dati
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Costruisci uno Stile che verrà applicato forzatamente su ogni cella della tabella pivot
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;

// Applica FormatAll: forza questo singolo stile su ogni cella della tabella pivot,
// sovrascrivendo qualsiasi PivotTableStyleType / PivotTableStyleName impostato in precedenza
pivotTable.FormatAll(style);

// Salva la cartella di lavoro nel formato moderno .xlsx
workbook.Save("output.xlsx");

Quale API di stile dovrei usare?

La scelta dell’API di stile dipende dal formato di file in cui si sta salvando. Utilizzare la tabella seguente come riferimento rapido.

Formato di file di destinazione	API da utilizzare	Note
`.xls` (legacy)	`PivotTable.AutoFormatType`	Valori da `Aspose.Cells.Pivot.PivotTableAutoFormatType` (ad esempio `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Ignorato quando si salva in formati moderni.
`.xlsx` / `.xlsm` / `.xlsb` (moderno, stile predefinito)	`PivotTable.PivotTableStyleType`	Valori da `Aspose.Cells.PivotTableStyleType` (temi chiari/scuri, incluse le aggiunte di Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderno, stile personalizzato)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	Da utilizzare quando i preset predefiniti non sono sufficienti. Configurare tramite `TableStyleElement.SetElementStyle(...)`.
Qualsiasi formato (sovrascrittura uniforme)	`PivotTable.FormatAll(Style)`	Scorciatoia che sovrascrive ogni altra impostazione di stile nell’intera pivot.

In caso di dubbio, salvare come .xlsx e utilizzare PivotTableStyleType per i temi predefiniti, oppure PivotTableStyleName per i temi personalizzati.

Net: Aggiungere campi riga e colonna a una tabella pivot in Aspose.Cells per .NET

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

Aggiungere un Campo all’Area Righe o Colonne

Il metodo PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) sposta un campo di base dai dati di origine in una delle quattro aree della pivot. L’argomento fieldType accetta uno dei seguenti valori di PivotFieldType.

Row — campi posizionati verticalmente a sinistra
Column — campi posizionati orizzontalmente nella parte superiore
Data — campi i cui valori sono aggregati
Page — campi usati come filtri del report

Dopo che i campi sono stati aggiunti, è possibile accedervi tramite le proprietà PivotTable.RowFields e PivotTable.ColumnFields. Ogni proprietà restituisce un PivotFieldCollection. Il campo all’indice 0 di RowFields è il campo riga più esterno, e gli indici successivi rappresentano campi nidificati al suo interno. La stessa convenzione di indicizzazione si applica a ColumnFields.

L’ordine di nidificazione dei campi è importante. Aggiungere prima Category all’area righe e poi Item produce una pivot il cui raggruppamento esterno è Category e il cui raggruppamento interno è Item. Invertendo l’ordine si inverte la gerarchia.

Subtotali dei Campi Pivot

Il metodo PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) controlla quali righe di subtotale vengono visualizzate per un campo pivot. Ogni chiamata attiva/disattiva un singolo tipo di subtotale in modo indipendente. Passare shown = true visualizza il subtotale, mentre shown = false lo nasconde. Poiché ogni chiamata riguarda un solo tipo, chiamando il metodo più volte con valori diversi di subtotalType si costruisce un sottoinsieme personalizzato di subtotali.

L’enum PivotFieldSubtotalType definisce i tipi di subtotale disponibili.

Automatic — Aspose.Cells sceglie la selezione predefinita (tipicamente Sum per i campi numerici)
None — elimina ogni riga di subtotale
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

I subtotali vengono visualizzati solo quando ci sono due o più campi pivot nell’area righe (o nell’area colonne). Un singolo campo non ha nulla di significativo tra cui calcolare un subtotale, quindi le chiamate a SetSubtotals non hanno alcun effetto visibile in tal caso. Questo articolo quindi posiziona due campi riga (Category esterno, Item interno) in ogni esempio, in modo che il confine del subtotale tra ogni gruppo Category sia visibile.

Scenario 1 — Subtotali Automatici (Predefiniti)

Quando non si chiama affatto SetSubtotals, Aspose.Cells applica la selezione Automatic ai campi numerici. L’esempio seguente conferma esplicitamente questo comportamento chiamando SetSubtotals(PivotFieldSubtotalType.Automatic, true) sul campo riga esterno 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");

Scenario 2 — Eliminare Tutti i Subtotali (None)

Chiamare SetSubtotals(PivotFieldSubtotalType.None, true) rimuove ogni riga di subtotale dalla pivot, lasciando solo le righe dei campi e il totale generale in basso. Questo è utile quando si desiderano i dati raggruppati grezzi senza righe di riepilogo.

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");

Scenario 3 — Sottoinsieme di Subtotali Personalizzato (Sum + Average)

Non si è limitati a un singolo tipo di subtotale. Ogni chiamata a SetSubtotals opera indipendentemente su un tipo, quindi chiamando il metodo due volte — una con Sum e una con Average — si produce un sottoinsieme personalizzato di due righe di subtotale per ogni gruppo 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");

Riepilogo

I tre scenari precedenti condividono lo stesso dataset e la stessa struttura di tabella pivot. L’unica differenza tra loro è la chiamata a SetSubtotals applicata al campo riga esterno Category. Ricorda la regola dei due campi: un singolo campo in un’area non ha nulla tra cui calcolare un subtotale, quindi posiziona sempre almeno due campi nell’area righe o colonne quando desideri che SetSubtotals abbia un effetto visibile.

Net: Gestire i campi valore di una tabella pivot in Aspose.Cells per .NET

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

Aggiungere un Campo all’Area Dati

Aggiungere un campo base all’area dati (valore) è il primo passo per definire come una tabella pivot aggrega i dati di origine. Aspose.Cells espone PivotTable.AddFieldToArea(PivotFieldType, string), un overload che accetta la costante PivotFieldType.Data e il nome della colonna di origine. Una volta che un campo è stato aggiunto all’area dati, l’API lo espone attraverso la raccolta PivotTable.DataFields, nell’ordine in cui i campi sono stati aggiunti. Per impostazione predefinita, una colonna di origine numerica viene riassunta con ConsolidationFunction.Sum, mentre una colonna non numerica utilizza Count come valore predefinito.

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

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

// Intestazioni in 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");

// Righe di dati A2:D9 utilizzando cicli annidati con diramazione su 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;
 }
 }
}

// Aggiungi tabella pivot in F3 con nome PivotTable1
int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Layout pivot: Category e Item su Riga, Year su Colonna, Amount come campo dati
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");

Modificare la Funzione di Riepilogo

Ogni campo posizionato nell’area dati viene incapsulato internamente come un’istanza di PivotField, e la sua proprietà Function restituisce un valore dall’enum ConsolidationFunction. Lo stesso setter Function consente di passare tra le aggregazioni disponibili, tra cui Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var e Varp.

La modifica di Function influisce solo sull’aggregazione, la colonna di origine non cambia.

Puoi quindi lasciare un campo dati come Sum mentre aggiungi un secondo campo dati che fa riferimento alla stessa colonna di origine ma utilizza Count o Average, tutto in un’unica tabella pivot.

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");

Posizionare i Campi Valore sull’Asse Riga o Colonna

Quando una tabella pivot contiene due o più campi dati, Aspose.Cells espone un ulteriore campo virtuale chiamato PivotTable.ValuesField. Questo campo virtuale rappresenta l’aggregazione di ogni campo dati che risiede nell’area dati. Puoi trascinarlo nell’area Riga o Colonna come campo pivot base, operazione utile per disporre più misure affiancate.

PivotTable.ValuesField non funziona se non ci sono campi valore o se ne è presente solo uno.

Gli scenari seguenti illustrano tre esempi end-to-end che dimostrano ciascuna delle funzionalità descritte sopra applicate alla stessa struttura pivot.

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: Aggiungere campi filtro a una tabella pivot in Aspose.Cells per .NET

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

Aspose.Cells supporta l’intero ciclo di vita dei campi filtro nelle tabelle pivot. È possibile aggiungere un campo filtro tramite un’API di alto livello di comodo utilizzo oppure tramite la raccolta di livello inferiore PageFields, ed è possibile gestire il filtro pagina in modalità a selezione singola, azzerarlo per mostrare ogni elemento della pagina, oppure commutare il campo in selezione multipla in modo che gli utenti possano scegliere più elementi della pagina contemporaneamente tramite l’interfaccia a caselle di controllo in Excel.

Introduzione

Un campo filtro è un campo pivot che controlla quale sottoinsieme dei dati di origine viene visualizzato nel corpo della pivot. Gli utenti finali lo vedono come un menu a discesa nella parte superiore di una pivot renderizzata in Excel, e selezionando uno degli elementi di pagina disponibili il corpo della pivot viene ricostruito in modo che vengano riepilogati solo i record appartenenti a quell’elemento di pagina. Un campo pivot diventa un campo filtro quando viene registrato come PivotFieldType.Page anziché come PivotFieldType.Row, PivotFieldType.Column o PivotFieldType.Data.

Un campo filtro può operare con due comportamenti. Nel comportamento predefinito di selezione singola è visibile un solo elemento di pagina alla volta, quindi il corpo della pivot riepiloga esattamente un sottoinsieme. Nel comportamento di selezione multipla il campo espone un elenco di caselle di controllo e il corpo della pivot riepiloga l’unione di ogni elemento di pagina selezionato. Lo stesso campo di origine può essere spostato avanti e indietro tra questi comportamenti attivando/disattivando una singola proprietà.

Aspose.Cells for .NET espone due modi equivalenti per registrare un campo filtro. L’API di alto livello è PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName"), che prende il nome della colonna di origine e aggiunge il campo in una singola chiamata. L’API di livello inferiore è PivotTable.PageFields.Add(PivotField), che viene utilizzata quando si dispone già di un riferimento a PivotField e si desidera aggiungere la stessa istanza di campo all’area filtro. Entrambe le API finiscono per popolare la stessa raccolta PageFields, e il resto di questo articolo mostra come scegliere tra di esse e come gestire ciascuna modalità di filtraggio.

Aggiungere un campo filtro

Esistono due modi per registrare un campo pivot nell’area filtro. La chiamata di alto livello accetta il nome della colonna di origine come stringa ed è il percorso più comune. La chiamata di livello inferiore accetta un’istanza esistente di PivotField ed è comoda quando lo stesso oggetto campo deve essere riutilizzato in più aree pivot. Entrambe le chiamate inseriscono il campo in PivotTable.PageFields, dopodiché appare come menu a discesa della pagina nella parte superiore della pivot renderizzata.

Aggiungere un campo filtro con AddFieldToArea

L’esempio seguente crea un piccolo set di dati Frutta / Anno / Importo, posiziona una tabella pivot nella cella E3 con Fruit nell’area riga, Amount nell’area dati e Year nell’area filtro, aggiorna la pivot e salva la cartella di lavoro.

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

// Crea una nuova cartella di lavoro
var workbook = new Workbook();
var worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

// Imposta la riga di intestazione
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Popola 9 righe di dati di esempio: Frutto, Anno, Importo
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]);
}

// Aggiungi una tabella pivot ancorata alla cella E3
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Aggiungi campi alle loro aree: Frutto come Riga, Importo come Dati, Anno come campo Pagina
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Aggiorna e calcola i dati della tabella pivot
pivotTable.CalculateData();

// Salva la cartella di lavoro
workbook.Save("pageFieldSample.xlsx");

Aggiungere un campo filtro con PageFields.Add

Quando si lavora già con un’istanza di PivotField, è possibile passarla direttamente a PivotTable.PageFields.Add. La tabella pivot e il campo filtro vengono costruiti esattamente come nello scenario precedente; solo la registrazione finale nell’area filtro viene sostituita con la chiamata API di livello inferiore.

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

// — La tabella pivot e il campo pagina vengono costruiti esattamente come in
//   Scenario 1a (dati Frutto/Anno/Importo, pivot in E3, Frutto→Riga,
//   Importo→Dati). Sotto otteniamo il PivotField Anno dalla
//   raccolta BaseFields e lo passiamo a PageFields.Add — l'
//   alternativa di basso livello a AddFieldToArea. Il risultato è
//   funzionalmente identico allo Scenario 1a.

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

// Intestazioni
sheet.Cells["A1"].PutValue("Fruit");
sheet.Cells["B1"].PutValue("Year");
sheet.Cells["C1"].PutValue("Amount");

// Dati di esempio (9 righe)
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);

// Aggiungi tabella pivot in E3 coprendo A1:C10
int pivotIndex = sheet.PivotTables.Add("E3", "A1:C10", "PivotTable1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Frutto -> Riga, Importo -> Dati (Anno andrà a Pagina sotto)
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Approccio di basso livello: prendi il PivotField Anno esistente da BaseFields
// e registralo nell'area Pagina tramite PageFields.Add(PivotField).
PivotField yearField = pivotTable.BaseFields["Year"];
pivotTable.PageFields.Add(yearField);

// Aggiorna così che il nuovo campo pagina venga riflesso nella cartella di lavoro salvata
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Filtraggio a selezione singola (visualizzazione di un elemento di pagina)

Nel comportamento predefinito di selezione singola, il campo filtro viene renderizzato come un singolo menu a discesa e l’intero PivotField.CurrentPageItem seleziona quale elemento di pagina guida il corpo della pivot. Assegnando un indice specifico si seleziona quell’unico elemento; assegnando il valore sentinella speciale 0x7FFD (decimale 32765) il filtro viene azzerato in modo che ogni elemento di pagina venga riepilogato contemporaneamente. La selezione singola è il valore predefinito; non è necessario abilitarla esplicitamente.

Visualizzare tutti gli elementi

Impostare CurrentPageItem sul valore magico 0x7FFD equivale ad azzerare il filtro pagina: il corpo della pivot riepiloga ogni elemento di pagina come se non fosse applicato alcun filtro.

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

class Program
{
    static void Main()
    {
        // Crea una nuova cartella di lavoro
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];

        // Popola i dati Frutto/Anno/Importo
        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]);
            }
        }

        // Crea una tabella pivot in E3
        var pivotTables = sheet.PivotTables;
        int index = pivotTables.Add("=A1:C7", "E3", "PivotTable1");
        PivotTable pivotTable = pivotTables[index];

        // Configura i campi pivot: Frutto→Riga, Importo→Dati, Anno→Pagina
        pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
        pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
        pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

        pivotTable.CalculateData();

        // Cancella il filtro della pagina in modo che ogni elemento nel campo pagina sia visibile.
        // 0x7FFD (decimale 32765) è il valore sentinella speciale che significa "tutti gli elementi" —
        // equivalente a selezionare "(Tutto)" nel menu a discesa del campo pagina di Excel.
        pivotTable.PageFields[0].CurrentPageItem = 0x7FFD;

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

Visualizzare un elemento specifico

Impostare CurrentPageItem su un indice reale seleziona solo quell’unico elemento di pagina. L’indice è la posizione dell’elemento nell’elenco ordinato degli elementi del campo filtro, quindi ad esempio 1 seleziona il secondo elemento dopo l’ordinamento.

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

// Crea cartella di lavoro
var workbook = new Workbook();
var sheet = workbook.Worksheets[0];
var cells = sheet.Cells;

// Aggiungi dati di esempio (Frutto/Anno/Importo)
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");

// Aggiungi tabella pivot in E3
var pivotTables = sheet.PivotTables;
int pivotIndex = pivotTables.Add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables[pivotIndex];

// Aggiungi campi: Frutto→Riga, Importo→Dati, Anno→Pagina
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Operazioni specifiche del campo pagina
pivotTable.PageFields[0].CurrentPageItem = 1; // 1 = secondo elemento nell'ordine ordinato (ad es. "2021")

// Aggiorna e calcola la tabella pivot
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Filtraggio a selezione multipla

Il filtraggio a selezione multipla trasforma il menu a discesa della pagina in un elenco di caselle di controllo e consente all’utente finale di selezionare più elementi di pagina contemporaneamente. Aspose.Cells espone due proprietà che lavorano insieme. PivotField.IsMultipleItemSelectionAllowed deve essere impostato su true prima che l’interfaccia di selezione multipla abbia effetto. Dopo che è stata abilitata, PivotItem.IsHidden controlla quali elementi appaiono nell’elenco delle caselle di controllo, quindi è possibile mostrare ogni elemento o inserire in una whitelist solo elementi specifici.

Il codice seguente abilita la selezione multipla sullo stesso campo filtro Year costruito nello Scenario 1a, quindi mostra due schemi: la Parte A rivela ogni elemento di pagina lasciando IsHidden impostato su false per ogni voce, mentre la Parte B inserisce in whitelist solo i valori di origine scelti e nasconde tutto il resto tramite un blocco switch (pivotItems[i].GetStringValue()).

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

// — La tabella pivot e il campo pagina sono costruiti esattamente come in
//   Scenario 1a (dati Fruit/Year/Amount, pivot in E3, Fruit→Row,
//   Amount→Data, Year→Page tramite AddFieldToArea).
//   Di seguito applichiamo il filtro a selezione multipla sul campo pagina.

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

// Dati di esempio: Fruit | Year | Amount
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");

// — Abilita la selezione multipla sul campo pagina
pivotTable.PageFields[0].IsMultipleItemSelectionAllowed = true;

// Parte A — seleziona TUTTI gli elementi (rendi visibile ogni elemento)
PivotItemCollection pivotItems = pivotTable.PageFields[0].PivotItems;
for (int i = 0; i < pivotItems.Count; i++)
{
    pivotItems[i].IsHidden = false;
}

// Parte B — seleziona solo elementi specifici per valore sorgente
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");

Nota: Quando si utilizza il filtraggio a selezione multipla tramite PivotItem.IsHidden, almeno un PivotItem deve rimanere visibile (IsHidden == false). Se ogni elemento è nascosto, Excel si arresta in modo anomalo all’apertura del file oppure rende una pivot vuota. Verificare sempre che la whitelist di selezione multipla includa almeno un elemento dei dati di origine.

Quale API e quale modalità dovrei usare?

La tabella seguente riassume quando utilizzare ciascuna API e modalità, in modo da poter scegliere la giusta combinazione senza leggere ogni scenario nel dettaglio.

Scenario / Caso d’uso	API consigliata	Proprietà utilizzata	Note
Aggiungere un campo filtro tramite il nome della colonna di origine (caso più comune)	`PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName")`	n/d	Alto livello, una sola riga. Utilizzare questa opzione a meno che non serva un riferimento a `PivotField`.
Aggiungere un campo filtro quando si dispone già di un oggetto `PivotField`	`PivotTable.PageFields.Add(PivotField)`	n/d	Utilizzare quando l’oggetto campo è stato ottenuto altrove o deve essere riutilizzato.
Filtrare un singolo elemento di pagina (modalità predefinita)	`PivotField.CurrentPageItem`	impostare su un indice specifico	Ad esempio, `1` mostra il secondo elemento nell’elenco ordinato.
Mostrare tutti gli elementi / azzerare il filtro pagina	`PivotField.CurrentPageItem`	impostare su `0x7FFD`	Il valore magico `0x7FFD` (decimale 32765) è la sentinella per “tutti gli elementi”.
Abilitare l’interfaccia di selezione multipla in Excel	`PivotField.IsMultipleItemSelectionAllowed`	impostare su `true`	Richiesto prima che qualsiasi chiamata a `IsHidden` abbia effetto.
Nascondere / mostrare singoli elementi in un elenco a selezione multipla	`PivotItem.IsHidden`	impostare per ogni elemento	Almeno un elemento deve rimanere visibile (`IsHidden == false`).

Ricordare sempre il vincolo di visibilità quando si configura il filtraggio a selezione multipla. Se ogni PivotItem in un campo filtro a selezione multipla è nascosto, Excel si arresta in modo anomalo all’apertura oppure rende una pivot vuota. Costruire la whitelist in base ai dati di origine in modo che almeno un elemento rimanga visibile, e le cartelle di lavoro salvate si apriranno in modo affidabile su ogni macchina.

Net: Elimina la tabella pivot da un foglio di lavoro

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

Aspose.Cells fornisce una funzionalità per eliminare o rimuovere la tabella pivot da un foglio di lavoro. Puoi eliminare la tabella pivot utilizzando l’oggetto tabella pivot o la posizione della tabella pivot. Si prega di utilizzare il metodo Worksheet.PivotTables.Remove() per eliminare la tabella pivot utilizzando l’oggetto tabella pivot e il metodo Worksheet.PivotTables.RemoveAt() per eliminare l’oggetto tabella pivot utilizzando la sua posizione all’interno della collezione delle tabelle pivot.

Il codice di esempio seguente elimina due tabelle pivot dal foglio di lavoro. Prima rimuove la tabella pivot utilizzando il metodo Worksheet.PivotTables.Remove() e poi rimuove la tabella pivot utilizzando il metodo Worksheet.PivotTables.RemoveAt()

Net: Salva tabella pivot nel file ODS

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

Aspose.Cells fornisce la possibilità di salvare la tabella pivot nei file ODS. A tal fine, è sufficiente convertire un workbook con una tabella pivot esistente o creare una nuova tabella pivot e salvare il file nel formato ODS. Assicurati di chiamare PivotTable.CalculateData() prima di salvare per garantire che la tabella pivot sia resa nel file ODS in uscita. Il seguente snippet di codice dimostra il salvataggio della tabella pivot nel file ODS.

Codice di esempio

Il file di output generato dal codice precedente è allegato per il tuo riferimento.

File ODS di output

Documentation – Inserisci tabella pivot

Net: Formattazione della tabella pivot

Aspetto della tabella pivot

Impostazione delle opzioni di formato della tabella pivot

Impostazione del tipo di formato automatico

Impostazione delle Opzioni di Formato

Formattazione Aspetto e Sensazione Manualmente

Impostazione delle opzioni di formato campo pivot

Impostazione delle opzioni di formato campi riga/colonna/pagina

Impostazione del formato dei campi dati

Cancellazione dei Campi di Tabella Pivot

Net: Creare Tabelle Pivot e Grafici Pivot

Aggiunta di tabelle pivot e grafici

Preparazione all’uso di Aspose.Cells

Aggiunta di una tabella pivot

Aggiunta di un grafico pivot

Net: Tabella Pivot e Dati di Origine

Dati di Origine della Tabella Pivot

Cambiare i Dati di Origine di una Tabella Pivot

Net: Aggiungi campo calcolato nella tabella pivot

Possibili Scenari di Utilizzo

Aggiungi campo calcolato nella tabella pivot in Excel

Aggiungi campo calcolato nella tabella pivot utilizzando C#

Codice di Esempio

Net: Aggiornare tabelle pivot e cache pivot in Aspose.Cells per .NET

Introduzione

Direttive Using richieste

Aggiornare tutte le tabelle pivot nella cartella di lavoro

Aggiornare tutte le tabelle pivot su un singolo foglio di lavoro

Aggiornare una singola tabella pivot

Dati di origine modificati — Usa PivotCache.Refresh()

Solo vista/layout modificati — Usa CalculateData()

Ottenere tutte le tabelle pivot che condividono lo stesso PivotCache

Migrazione dall’obsoleto PivotTable.RefreshData()

Quale API di aggiornamento dovrei usare?

Net: Applicare stili alle tabelle pivot in Aspose.Cells per .NET

Introduzione

Applicare un autoformato preset legacy XLS

Applicare uno stile preset denominato moderno per tabelle pivot

Definire e applicare uno stile personalizzato per tabelle pivot

Applicare un unico stile a ogni cella della pivot con FormatAll

Quale API di stile dovrei usare?

Net: Aggiungere campi riga e colonna a una tabella pivot in Aspose.Cells per .NET

Aggiungere un Campo all’Area Righe o Colonne

Subtotali dei Campi Pivot

Scenario 1 — Subtotali Automatici (Predefiniti)

Scenario 2 — Eliminare Tutti i Subtotali (None)

Scenario 3 — Sottoinsieme di Subtotali Personalizzato (Sum + Average)

Riepilogo

Net: Gestire i campi valore di una tabella pivot in Aspose.Cells per .NET

Aggiungere un Campo all’Area Dati

Modificare la Funzione di Riepilogo

Posizionare i Campi Valore sull’Asse Riga o Colonna

Net: Aggiungere campi filtro a una tabella pivot in Aspose.Cells per .NET

Introduzione

Aggiungere un campo filtro

Aggiungere un campo filtro con AddFieldToArea

Aggiungere un campo filtro con PageFields.Add

Filtraggio a selezione singola (visualizzazione di un elemento di pagina)

Visualizzare tutti gli elementi

Visualizzare un elemento specifico

Filtraggio a selezione multipla

Quale API e quale modalità dovrei usare?

Net: Elimina la tabella pivot da un foglio di lavoro

Net: Salva tabella pivot nel file ODS

Codice di esempio

Dati di origine modificati — Usa `PivotCache.Refresh()`

Solo vista/layout modificati — Usa `CalculateData()`

Migrazione dall’obsoleto `PivotTable.RefreshData()`