PivotTables und Pivot-Caches in Aspose.Cells für .NET aktualisieren

Einführung

Das Aktualisieren einer Pivot-Tabelle ist selten ein einzelner Vorgang. Im Hintergrund verwaltet Aspose.Cells eine mehrschichtige Datenkette, die Ihre ursprünglichen Quelldaten mit den gerenderten Werten verbindet, die Sie im Arbeitsblatt sehen. Das Verständnis dieser Kette ist der Schlüssel zur Auswahl der richtigen Aktualisierungs-API für jede Situation.

Die vierschichtige Datenkette ist:

  1. Datenquelle — die ursprünglichen Arbeitsblattbereiche, Datenbankabfragen oder Konsolidierungsbereiche, in denen die Rohwerte gespeichert sind.
  2. PivotCache — der In-Memory-Snapshot der Quelldaten. Jede Pivot-Tabelle wird auf einem PivotCache aufgebaut; hier werden alle Daten gesammelt und aggregiert.
  3. PivotTable — das Ansichtsobjekt, das Zeilen-, Spalten-, Werte- und Filterfelder definiert. Eine PivotTable liest nur aus ihrem PivotCache, niemals direkt aus der Datenquelle.
  4. Zellen — die Arbeitsblatt-Cells, in die die PivotTable ihre berechneten Werte und Stile rendert.

Ein besonders wichtiges Konzept ist der gemeinsame Cache. Wenn mehrere Pivot-Tabellen in einer Arbeitsmappe auf denselben Quellbereich verweisen, teilen sie sich eine PivotCache-Instanz. Ein einzelner PivotCache kann von vielen Pivot-Tabellen referenziert werden, und das Aktualisieren dieses Caches aktualisiert jede abhängige PivotTable auf einmal.

Aufgrund dieser Kette gibt es in Aspose.Cells zwei grundlegende Aktualisierungspfade:

  • PivotCache.Refresh() — lädt Quelle → Cache neu UND berechnet alle abhängigen PivotTables in einem einzigen Vorgang neu.
  • PivotTable.CalculateData() — berechnet die Anzeige einer PivotTable aus bereits zwischengespeicherten Daten neu, ohne Rückweg zur Datenquelle.

Alle Szenarien in diesem Artikel verwenden Arbeitsblatt-Zellen als Quelldaten, daher ist der Quellentyp Sheet und die Aktualisierungsvorgänge verhalten sich wie beschrieben.

Erforderliche Using-Direktiven

Alle C#-Beispiele in diesem Artikel beginnen mit den folgenden drei Using-Direktiven, da die Pivot-Typen im Namespace Aspose.Cells.Pivot liegen:

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

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Wenn Sie sicherstellen müssen, dass jeder Pivot-Cache und jede Pivot-Tabelle in der Arbeitsmappe die neuesten Quelldaten widerspiegelt, ist die einfachste und umfassendste API Workbook.RefreshAll(). Ein einziger Aufruf durchläuft die gesamte Arbeitsmappe — er aktualisiert jeden PivotCache aus seiner Quelle und berechnet dann jede abhängige PivotTable neu. Dies ist der empfohlene Ansatz für allgemeine, vollständige Dokumentaktualisierungen, bei denen die Leistung keine Rolle spielt.

Das folgende Beispiel erstellt eine Arbeitsmappe mit einem Quellebereich Fruit/Year/Amount, erstellt eine Pivot-Tabelle, ändert einige Quellwerte und verwendet dann RefreshAll(), um alles in einem einzigen Aufruf auf den neuesten Stand zu bringen.

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

// Erstellen einer neuen Arbeitsmappe
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Kopfzeile in die Zellen A1:C1 schreiben
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Datenzeilen in die Zellen A2:C9 schreiben (8 Zeilen mit Fruchtdaten über 2020 und 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);

// Hinzufügen einer Pivot-Tabelle: Quellbereich "A1:C9", Zielzelle "E3", Name "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Pivot-Felder zuweisen: Fruit zu Zeilen, Year zu Spalten, Amount zu Daten
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Mehrere Amount-Werte in den Quelldaten ändern, um Änderungen zu simulieren
worksheet.Cells["C2"].PutValue(55);
worksheet.Cells["C5"].PutValue(85);
worksheet.Cells["C9"].PutValue(125);

// Alle Pivot-Tabellen / Pivot-Caches in der Arbeitsmappe aktualisieren
workbook.RefreshAll();

// Arbeitsmappe speichern
workbook.Save("output.xlsx");

Alle Pivot-Tabellen in einem einzelnen Arbeitsblatt aktualisieren

Manchmal müssen Sie nur die Pivot-Tabellen aktualisieren, die sich auf einem bestimmten Arbeitsblatt befinden — beispielsweise wenn bekannt ist, dass Pivot-Tabellen auf anderen Arbeitsblättern nicht relevant sind und nicht angefasst werden sollen. Für diesen Fall stellt Aspose.Cells Worksheet.RefreshPivotTables() bereit, das auf eine einzelne Worksheet-Instanz beschränkt ist.

Dies ist selektiver als Workbook.RefreshAll(): Es werden nur die Pivot-Tabellen auf dem Zielarbeitsblatt aktualisiert, während Pivot-Tabellen auf anderen Arbeitsblättern unberührt bleiben.

Das folgende Beispiel füllt die gleichen Fruit/Year/Amount-Quelldaten, fügt eine Pivot-Tabelle auf dem ersten Arbeitsblatt hinzu, ändert einige Quellwerte und aktualisiert dann nur die Pivot-Tabellen auf diesem Arbeitsblatt.

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

Eine einzelne Pivot-Tabelle aktualisieren

Wenn Sie eine fein abgestimmte Kontrolle über eine einzelne Pivot-Tabelle wünschen, bietet Ihnen die cache-basierte API zwei Optionen. Die Wahl zwischen ihnen hängt davon ab, was sich tatsächlich geändert hat: die zugrunde liegenden Quelldaten oder nur die Ansichts-/Layout-Einstellungen der Pivot-Tabelle selbst.

Quelldaten geändert — Verwenden Sie PivotCache.Refresh()

Wenn sich die zugrunde liegenden Quelldaten geändert haben, ist der richtige Einstiegspunkt pivotTable.PivotCache.Refresh(). Dieser Aufruf liest die Quelldaten erneut in den Cache und berechnet dann jede PivotTable neu, die von diesem Cache abhängt.

Das folgende Beispiel erstellt zwei Pivot-Tabellen auf demselben Quellbereich, um dieses Verhalten mit gemeinsamem Cache zu demonstrieren, ändert einige Quellwerte und aktualisiert dann über eine Cache-Referenz.

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

// Erstellen Sie eine neue Arbeitsmappe und greifen Sie auf das erste Arbeitsblatt zu
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

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

// Schreiben Sie ungefähr 9 Datenzeilen (Traube / Blaubeere / Kiwi / Kirsche über 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);

// Fügen Sie die erste Pivot-Tabelle "Pivot1" hinzu, verankert bei Zelle E3, Quellbereich A1:C9
int pivotIndex1 = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable1 = worksheet.PivotTables[pivotIndex1];

// Felder für Pivot1 zuweisen
pivotTable1.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable1.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable1.AddFieldToArea(PivotFieldType.Data, "Amount");

// Fügen Sie eine ZWEITE Pivot-Tabelle "Pivot2" hinzu, verankert bei E15, unter Verwendung desselben Quellbereichs A1:C9
// Sowohl Pivot1 als auch Pivot2 teilen sich einen einzelnen PivotCache, da der Quellbereich identisch ist.
int pivotIndex2 = worksheet.PivotTables.Add("A1:C9", "E15", "Pivot2");
PivotTable pivotTable2 = worksheet.PivotTables[pivotIndex2];

// Die gleichen Felder für Pivot2 zuweisen
pivotTable2.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable2.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable2.AddFieldToArea(PivotFieldType.Data, "Amount");

// Ändern Sie mehrere Amount-Zellenwerte in den Quelldaten, um eine Datenänderung zu simulieren
worksheet.Cells["C2"].PutValue(150);
worksheet.Cells["C4"].PutValue(350);
worksheet.Cells["C7"].PutValue(650);

// Den gemeinsam genutzten PivotCache aktualisieren.
// Da Pivot1 und Pivot2 denselben PivotCache teilen, aktualisiert dieser einzelne Aufruf
// BEIDE Pivot-Tabellen (Daten + Stil) aus der aktualisierten Quelle.
pivotTable1.PivotCache.Refresh();

// Die Arbeitsmappe speichern
workbook.Save("output.xlsx");

Nur Ansicht/Layout geändert — Verwenden Sie CalculateData()

Wenn sich die Quelldaten nicht geändert haben, sondern nur die Ansichts- oder Layout-Einstellungen der Pivot-Tabelle geändert wurden (zum Beispiel wurde ein Feld in einen anderen Bereich verschoben oder eine Einstellung zum Aktualisieren beim Öffnen umgeschaltet), besteht keine Notwendigkeit, zur Datenquelle zurückzukehren. Der Cache enthält bereits die richtigen Daten; nur die gerenderte PivotTable muss neu berechnet werden. In diesem Fall ist pivotTable.CalculateData() die richtige Wahl.

Dies vermeidet den unnötigen Quellabruf und ist erheblich schneller, wenn viele Pivot-Tabellen denselben Cache gemeinsam nutzen.

Das folgende Beispiel ändert eine Nicht-Quell-Eigenschaft der Pivot-Tabelle und ruft dann CalculateData() auf, um sie aus dem vorhandenen Cache neu zu rendern.

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

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

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

// 8 Datenzeilen schreiben (Zeilen 2-9, passend zum Quellbereich 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);

// Pivot-Tabelle namens "Pivot1" hinzufügen, platziert in der Zielzelle E3, mit Quelle A1:C9
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.PivotTables[pivotIndex];

// Felder zuweisen: Fruit nach Zeile, Year nach Spalte, Amount nach Daten
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Eine Ansichts-/Layout-Eigenschaft ändern — dies ist eine rein darstellungsbezogene Änderung,
// daher ist KEIN erneutes Einlesen der Quelldaten über PivotCache.Refresh() erforderlich.
pivotTable.RefreshDataOnOpeningFile = false;

// CalculateData() rendert die Anzeige DIESER Pivot-Tabelle (Daten + Stil) neu aus den
// bereits im PivotCache gespeicherten Daten. Da sich die Quelldaten nicht geändert haben,
// erfolgt kein Rückgriff auf die Quelle — nur die zwischengespeicherten Werte werden
// in die Arbeitsblattzellen neu berechnet.
pivotTable.CalculateData();

// Arbeitsbuch auf der Festplatte speichern
workbook.Save("output.xlsx");

Alle Pivot-Tabellen abrufen, die denselben PivotCache gemeinsam nutzen

Eine Arbeitsmappe enthält oft viele Pivot-Tabellen, die alle auf einem gemeinsamen Cache aufbauen. Um sie aufzulisten — beispielsweise vor einer Massenaktualisierung oder zur Diagnose der Auswirkungen des gemeinsamen Caches — verwenden Sie PivotCache.GetPivotTables(). Diese Methode gibt die Sammlung jeder PivotTable zurück, die von dem angegebenen Cache abhängt.

Dies ist auch der direkteste Weg, um zu bestätigen, dass zwei Pivot-Tabellen tatsächlich dieselbe PivotCache-Instanz gemeinsam nutzen: Sie können Cache-Referenzen vergleichen oder einfach die von GetPivotTables() zurückgegebene Sammlung durchlaufen und beobachten, welche Pivot-Tabellen darin erscheinen.

Das folgende Beispiel erstellt zwei Pivot-Tabellen auf demselben Quellbereich, überprüft, dass sie dieselbe Cache-Instanz gemeinsam nutzen, und listet dann die Pivot-Tabellen des Caches auf.

Migration von der veralteten PivotTable.RefreshData()

Vor Aspose.Cells for .NET v26.7 war die Standardmethode zum Aktualisieren einer Pivot-Tabelle der Aufruf von PivotTable.RefreshData() für jede Pivot-Tabelle einzeln. Ab v26.7 ist diese Methode als veraltet markiert und sollte durch die oben beschriebenen cache-bewussten APIs ersetzt werden.

Es gibt zwei Gründe, warum der RefreshData()-Ansatz pro Tabelle in realen Arbeitsmappen problematisch ist:

  • Er ruft die Daten bei jedem Aufruf erneut aus der Quelle ab, selbst wenn sich die Quelle nicht geändert hat.
  • Jeder Aufruf aktualisiert den gesamten gemeinsamen Cache. Wenn viele Pivot-Tabellen einen Cache gemeinsam nutzen, verursacht der wiederholte Aufruf von RefreshData() pro Pivot-Tabelle, dass derselbe Cache immer wieder erneut abgerufen wird, was sehr langsam ist.

Die empfohlenen Ersetzungen sind:

  • Aktualisieren Sie ALLE Pivot-Tabellen in der Arbeitsmappe → verwenden Sie workbook.RefreshAll();
  • Aktualisieren Sie EINIGE davon → verwenden Sie pivotTable.PivotCache.Refresh(); für einen Cache. Da der Cache gemeinsam genutzt wird, aktualisiert dieser einzelne Aufruf jede Pivot-Tabelle, die auf diesem Cache aufbaut. Andere Pivot-Tabellen, die auf einem bereits aktualisierten Cache sitzen, können sicher übersprungen werden.
  • Nur die Pivot-Ansicht/das Layout hat sich geändert → verwenden Sie pivotTable.CalculateData();, um aus dem vorhandenen Cache ohne Quell-Roundtrip neu zu rendern.

Das folgende Beispiel demonstriert das neue effiziente Muster für Arbeitsmappen mit mehreren Pivot-Tabellen, die einen einzigen Cache gemeinsam nutzen.

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

// Erstellen Sie eine neue Arbeitsmappe und greifen Sie auf das erste Arbeitsblatt zu
Workbook workbook = new Workbook();
Worksheet sheet = workbook.Worksheets[0];

// --- Quelldaten erstellen: Frucht / Jahr / Betrag (Kopfzeile + 9 Zeilen) ---
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);

// --- Erste Pivot-Tabelle (Pivot1) in Zielzelle E3 hinzufügen ---
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");

// --- ZWEITE Pivot-Tabelle (Pivot2) im SELBEN Quellbereich hinzufügen ---
// Sowohl Pivot1 als auch Pivot2 teilen sich EINEN zugrunde liegenden PivotCache.
// Dies ist genau das Szenario, in dem der alte pro-Tabelle RefreshData()-Ansatz
// ineffizient wird: Das Aktualisieren einer Tabelle ruft den gesamten Cache erneut ab
// geteilter Cache, sodass das Aktualisieren von N Tabellen den gleichen teuren Abruf N-mal durchführt.
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");

// --- Mehrere Betragswerte in den Quelldaten ändern ---
sheet.Cells["C2"].PutValue(5000);   // Traube  2020
sheet.Cells["C5"].PutValue(7500);   // Kirsche 2020
sheet.Cells["C9"].PutValue(9500);   // Kirsche 2021

// --- VERALTETES Muster (vor 26.7) — PivotTable.RefreshData() ---
// pivotTable1.RefreshData();  // ruft erneut von der Quelle ab, aktualisiert den gesamten Cache
// pivotTable2.RefreshData();  // ruft ERNEUT ab — der Cache ist bereits aktuell!
// Jeder Aufruf baut den geteilten Cache neu auf, also N Tabellen = N redundante Abrufe.

// --- NEUES Muster ab v26.7: Cache EINMAL aktualisieren, dann nach Bedarf neu rendern ---
// Ein Aufruf von PivotCache.Refresh() holt die geänderten Werte in den geteilten Cache
// UND berechnet die Anzeige JEDER Pivot-Tabelle neu, die darauf verweist.
// Da Pivot1 und Pivot2 einen PivotCache teilen, aktualisiert dieser eine Aufruf
// beide Tabellen — kein zweiter Quellrundgang ist erforderlich.
pivotTable1.PivotCache.Refresh();

// CalculateData() rendert nur die Anzeige einer Pivot-Tabelle neu (Daten + Stil)
// aus den bereits im Cache enthaltenen Daten — es greift NICHT auf die Quelle zu.
// Wir rufen es hier auf Pivot2 auf, nur um die API zu demonstrieren: Nachdem der Cache
// einmal aktualisiert wurde, kann jede abhängige Tabelle neu gerendert werden, ohne
// auf die Quelle zurückzugreifen. Verwenden Sie CalculateData() eigenständig, wenn nur die
// Ansichts-/Layouteinstellungen der Pivot-Tabelle geändert wurden und der Cache aktuell ist.
pivotTable2.CalculateData();

workbook.Save("output.xlsx");

Welche Aktualisierungs-API sollte ich verwenden?

Die folgende Tabelle fasst die verfügbaren Aktualisierungs-APIs zusammen und wann welche zu wählen ist.

Ziel Empfohlene API Hinweise
Alles in der Arbeitsmappe aktualisieren Workbook.RefreshAll() Ein Aufruf; deckt alle Caches und Tabellen ab.
Nur Pivot-Tabellen auf einem einzelnen Blatt aktualisieren Worksheet.RefreshPivotTables() Beschränkt auf ein Arbeitsblatt.
Quelldaten für einen Cache geändert pivotTable.PivotCache.Refresh() Aktualisiert ALLE Pivot-Tabellen in diesem gemeinsamen Cache.
Nur Ansichts-/Layout-Einstellungen geändert pivotTable.CalculateData() Überspringt unnötigen Quell-Roundtrip.
Alle Pivot-Tabellen in einem gemeinsamen Cache auflisten pivotCache.GetPivotTables() Zur Aufzählung vor der Massenaktualisierung verwenden.

In der Praxis sollten die cache-basierten APIs der veralteten RefreshData() pro Tabelle vorgezogen werden. Sie kennen gemeinsame Caches, vermeiden redundante Quellabrufe und ermöglichen es Ihnen, den kleinsten Geltungsbereich zu wählen, der Ihre Aktualisierungsanforderung erfüllt.

Erstellen Sie ein berechnetes Feld im Pivot Table Zeilen- und Spaltenfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen