Documentation – Pivot Tabelle einfügen

Net: Formatieren der Pivot Tabelle

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

Aussehen der Pivot-Tabelle

Wie man eine Pivot-Tabelle erstellt, erklärt, wie man eine einfache Pivot-Tabelle erstellt. Dieser Artikel beschreibt, wie man das Aussehen einer Pivot-Tabelle anpasst, indem man verschiedene Eigenschaften einstellt:

Optionen zum Formatieren von Pivot-Tabellen
Optionen zum Formatieren von Pivot-Feldern
Optionen zum Formatieren von Datenfeldern

Einstellen der Pivot-Tabellenformatoptionen

Die Klasse PivotTable steuert die gesamte Pivot-Tabelle und kann auf verschiedene Arten formatiert werden.

Einstellen des AutoFormat-Typs

Microsoft Excel bietet eine Reihe verschiedener voreingestellter Berichtsformate. Aspose.Cells unterstützt auch diese Formatierungsoptionen. Um darauf zuzugreifen:

Setzen Sie PivotTable.IsAutoFormat auf true.
Weisen Sie eine Formatierungsoption aus der PivotTableAutoFormatType-Aufzählung zu.

Einstellen von Formatoptionen

Das unten stehende Codebeispiel zeigt, wie die Pivot-Tabelle formatiert wird, um Gesamtsummen für Zeilen und Spalten anzuzeigen, und wie die Feldreihenfolge des Berichts festgelegt wird. Es zeigt auch, wie eine benutzerdefinierte Zeichenfolge für Nullwerte festgelegt wird.

Manuelles Anpassen von Aussehen und Anmutung

Um das Aussehen des Pivot-Tabellenberichts manuell anzupassen, anstelle von voreingestellten Berichtsformaten, verwenden Sie die Methoden PivotTable.Format() und PivotTable.FormatAll(). Erstellen Sie ein Style-Objekt für Ihre gewünschte Formatierung, zum Beispiel:

Einstellen von Formatoptionen für Pivot-Felder

Die Klasse PivotField stellt ein Feld in einer Pivot-Tabelle dar und kann auf verschiedene Arten formatiert werden. Das unten stehende Codebeispiel zeigt, wie:

Auf Zeilenfelder zugreifen.
Untergesamtsummen einstellen.
Autosortierung einstellen.
Autoshow einstellen.

Formatieren von Zeilen/Spalten/Seitenfeldern

Einstellen von Datenfeldformaten

Das unten stehende Codebeispiel zeigt, wie man Anzeigeformate und Zahlenformat für Datenfelder einstellt.

Löschen von Pivot-Feldern

Die Methode Clear() der PivotFieldCollection-Klasse ermöglicht es Ihnen, Pivot-Felder zu löschen. Verwenden Sie sie, wenn Sie alle Pivot-Felder in den Bereichen wie Seite, Spalte, Zeile oder Daten löschen möchten. Das unten stehende Codebeispiel zeigt, wie man alle Pivot-Felder in einem Datenbereich löscht.

Net: Erstellen von Pivot Tabellen und Pivot Diagrammen

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

Eine Pivot-Tabelle ist eine interaktive Zusammenfassung von Datensätzen. Sie können beispielsweise Hunderte von Rechnungseinträgen in einer Liste in einem Arbeitsblatt haben. Eine Pivot-Tabelle kann die Rechnungen nach Kunden, Produkt oder Datum zusammenfassen. Mit Microsoft Excel ist es möglich, die Informationen in der Pivot-Tabelle schnell neu anzuordnen, indem Sie Schaltflächen an eine neue Position ziehen.

Ein Pivot-Diagramm ist eine interaktive grafische Darstellung der Daten in einer Pivot-Tabelle. Pivot-Diagramme wurden in Excel 2000 eingeführt. Durch die Verwendung eines Pivot-Diagramms wird es noch einfacher, die Daten zu verstehen, da die Pivot-Tabelle automatisch Teil- und Gesamtsummen erstellt.

Aspose.Cells unterstützt Pivot-Tabellen und Pivot-Diagramme.

Hinzufügen von Pivot-Tabellen und -Diagrammen

Aspose.Cells bietet eine spezielle Reihe von Klassen zur Erstellung von Pivot-Tabellen. Diese Klassen werden verwendet, um PivotTable-Objekte zu erstellen und zu setzen, die als grundlegende Bausteine eines PivotTable-Objekts dienen:

PivotField, ein Feld in einem Pivot-Tabellenbericht.
PivotFields, eine Sammlung aller PivotField-Objekte in einer Pivot-Tabelle.
PivotTable, ein Pivot-Tabellenbericht auf einem Arbeitsblatt.
PivotTables, eine Sammlung aller PivotTable-Objekte auf dem Arbeitsblatt.

Vorbereitung zur Verwendung von Aspose.Cells

Laden Sie Aspose.Cells herunter und installieren Sie es:
1. Aspose.Cells herunterladen.
2. Installieren Sie es auf Ihrem Entwicklungscomputer. Alle Aspose Komponenten, wenn sie installiert sind, arbeiten im Evaluierungsmodus. Der Evaluierungsmodus hat keine zeitliche Begrenzung und fügt nur Wasserzeichen in erstellte Dokumente ein. Um mit der Komponente in vollem Umfang zu arbeiten, benötigen Sie eine gültige Lizenz.
Ein Projekt erstellen:
1. Starten Sie Visual Studio.Net.
2. Erstellen Sie eine neue Konsolenanwendung.
Fügen Sie Verweise hinzu: Fügen Sie einen Verweis auf das Aspose.Cells-Komponent in Ihr Projekt ein, beispielsweise …\Program Files\Aspose\Aspose.Cells\Bin\Net1.0\Aspose.Cells.dll

Hinzufügen einer Pivot-Tabelle

Um eine Pivot-Tabelle mit Aspose.Cells zu erstellen:

Fügen Sie einige Daten in Zellen eines Arbeitsblatts mit der PutValue/setValue-Methode eines Cell-Objekts ein. Sie können auch eine Vorlagendatei verwenden, die bereits mit Daten gefüllt ist. Die Daten werden als Datenquelle der Pivot-Tabelle verwendet.
Fügen Sie dem Arbeitsblatt eine Pivot-Tabelle hinzu, indem Sie die Methode add der PivotTables-Sammlung aufrufen (die im Arbeitsblatt-Objekt gekapselt ist).
Greifen Sie auf das neue PivotTable-Objekt aus der PivotTables-Sammlung zu, indem Sie seinen Index übergeben. # Verwenden Sie eines der in dem PivotTable-Objekt gekapselten Pivot-Tabellenobjekte, um die Tabelle zu verwalten.

Codebeispiele finden Sie unten.

Hinzufügen eines Pivot-Diagramms

Um ein PivotChart mit Aspose.Cells zu erstellen:

Fügen Sie ein Diagramm hinzu.
Setzen Sie den PivotSource des Diagramms so, dass er auf eine vorhandene Pivot-Tabelle in der Tabelle verweist.
Setzen Sie andere Attribute.

Net: Pivot Tabelle und Quelldaten

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

Quelldaten der Pivot-Tabelle

Es gibt Zeiten, in denen Sie Microsoft Excel-Berichte mit Pivot-Tabellen erstellen möchten, die Daten aus verschiedenen Datenquellen (wie einer Datenbank) enthalten, die zur Entwurfszeit nicht bekannt sind. Dieser Artikel stellt einen Ansatz zur Verfügung, um die Datenquelle einer Pivot-Tabelle dynamisch zu ändern.

Ändern der Datenquelle einer Pivot-Tabelle

Erstellen einer neuen Designer-Vorlage.
1. Erstellen Sie eine neue Designer-Vorlagendatei wie im folgenden Screenshot gezeigt.
2. Definieren Sie dann einen benannten Bereich, Datenquelle, der sich auf diesen Zellenbereich bezieht.
  
  Erstellen einer Designer-Vorlage & Definieren eines benannten Bereichs, Datenquelle

Erstellen einer Pivot-Tabelle auf Basis dieses benannten Bereichs.
1. Wählen Sie in Microsoft Excel Daten, dann PivotTable und PivotChart-Bericht aus.
2. Erstellen Sie eine Pivot-Tabelle basierend auf dem im ersten Schritt erstellten benannten Bereich.
  
  Erstellen einer Pivot-Tabelle basierend auf dem benannten Bereich, DataSource

Ziehen Sie das entsprechende Feld in Zeile und Spalte der Pivot-Tabelle und erstellen Sie dann die resultierende Pivot-Tabelle wie im Screenshot unten.

Erstellen einer Pivot-Tabelle basierend auf einem entsprechenden Feld

Klicken Sie mit der rechten Maustaste auf die Pivot-Tabelle und wählen Sie Tabellenoptionen.
1. Aktivieren Sie Beim Öffnen aktualisieren in den Dateneinstellungen.
  
  Festlegen der Pivot-Tabellenoptionen

Nun können Sie diese Datei als Ihre Designer-Vorlagendatei speichern.

Neue Daten einfügen und die Quelldaten einer Pivot-Tabelle ändern.
1. Sobald die Designer-Vorlage erstellt ist, verwenden Sie den folgenden Code, um die Quelldaten der Pivot-Tabelle zu ändern.

Die Ausführung des untenstehenden Beispielcodes ändert die Quelldaten der Pivot-Tabelle.

Net: Erstellen Sie ein berechnetes Feld im Pivot Table

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

Mögliche Verwendungsszenarien

Wenn Sie eine Pivot-Tabelle basierend auf bekannten Daten erstellen, stellen Sie fest, dass die Daten darin nicht das sind, was Sie wollen. Die Daten, die Sie wollen, sind die Kombination dieser Originaldaten. Zum Beispiel müssen Sie die ursprünglichen Daten addieren, subtrahieren, multiplizieren und dividieren, bevor Sie die Daten wollen. Zu diesem Zeitpunkt müssen Sie ein berechnetes Feld erstellen und die entsprechende Formel für die Berechnung festlegen. Führen Sie dann einige Statistiken und andere Operationen auf dem berechneten Feld durch.

Füge ein berechnetes Feld in eine Pivot-Tabelle in Excel ein

Fügen Sie ein berechnetes Feld in eine Pivot-Tabelle in Excel ein, befolgen Sie diese Schritte:

Wählen Sie die Pivot-Tabelle aus, zu der Sie ein berechnetes Feld hinzufügen möchten.
Gehen Sie zum Register PivotTable Analyse in der Menüleiste.
Klicken Sie auf “Felder, Elemente und Sets” und wählen Sie dann “Berechnetes Feld” im Dropdown-Menü aus.
Geben Sie im Feld “Name” einen Namen für das berechnete Feld ein.
Geben Sie im Feld “Formel” die Formel für die Berechnung ein, die Sie unter Verwendung der entsprechenden Feldnamen und mathematischen Operatoren in der Pivot-Tabelle durchführen möchten.
Klicken Sie auf “OK”, um das berechnete Feld zu erstellen.
Das neue berechnete Feld wird im Bereich Wertliste der Pivot-Tabelle unter den Werten angezeigt.
Ziehen Sie das berechnete Feld in den Wertebereich der Pivot-Tabelle, um die berechneten Werte anzuzeigen.

Fügen Sie ein berechnetes Feld in eine Pivot-Tabelle mithilfe von C# ein

Fügen Sie ein berechnetes Feld zu einer Excel-Datei mit Aspose.Cells hinzu. Bitte beachten Sie den folgenden Beispielcode. Nach Ausführung des Beispielcodes wird eine Pivot-Tabelle mit einem berechneten Feld zum Arbeitsblatt hinzugefügt.

Legen Sie die Originaldaten fest und erstellen Sie eine Pivot-Tabelle.
Erstellen Sie das berechnete Feld gemäß dem vorhandenen PivotField in der Pivot-Tabelle.
Fügen Sie das berechnete Feld in den Datenbereich ein.
Schließlich wird die Arbeitsmappe im XLSX-Ausgabeformat gespeichert.

Beispielcode

Net: Stile auf PivotTables in Aspose.Cells für .NET anwenden

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

Aspose.Cells unterstützt die Anwendung sowohl von Legacy-Pivot-Autoformaten (für .xls-Dateien vorgesehen) als auch von modernen benannten oder benutzerdefinierten Pivot-Tabellenstilen (für .xlsx-, .xlsm- und .xlsb-Dateien vorgesehen). Welche API Sie aufrufen sollten, hängt vom Dateiformat ab, in dem die Arbeitsmappe gespeichert wird, und nicht vom Format, aus dem sie geladen wurde.

Einführung

Aspose.Cells stellt zwei parallele Stil-APIs für Pivot-Tabellen bereit. Die Entscheidung zwischen ihnen wird durch das Dateiformat bestimmt, in dem Sie die Arbeitsmappe speichern, nicht durch das Format, aus dem Sie sie lesen. Eine aus einer .xls-Datei geladene Arbeitsmappe kann als .xlsx neu gespeichert werden, und in diesem Fall gilt die moderne Stil-API statt der Legacy-API.

Für die Legacy-Ausgabe im .xls-Format verwenden Sie die Eigenschaft PivotTable.AutoFormatType zusammen mit der Enumeration Aspose.Cells.Pivot.PivotTableAutoFormatType. Diese API entspricht der Autoformat-Auswahl, die das klassische Excel für Pivot-Tabellen angeboten hat.

Für die moderne Ausgabe im .xlsx-, .xlsm- und .xlsb-Format stehen zwei Varianten der Stil-API zur Verfügung:

PivotTable.PivotTableStyleType wählt einen der integrierten benannten Stile aus (helle und dunkle Designs, einschließlich der in Excel 2017 hinzugefügten Stile). Diese Voreinstellungen sind schreibgeschützt.
PivotTable.PivotTableStyleName wählt einen benutzerdefinierten Stil aus, den Sie selbst über Workbook.Worksheets.TableStyles.AddPivotTableStyle(...) definieren. Benutzerdefinierte Stile sind erforderlich, wenn Sie Farben, Rahmen oder Schriftarten ändern möchten, die über die Voreinstellungen hinausgehen.

Darüber hinaus ist PivotTable.FormatAll(Style) eine Verknüpfung, die ein einzelnes Style-Objekt auf jede Zelle der Pivot-Tabelle anwendet und alle über die beiden oben genannten Stilnamen-APIs vorgenommenen Einstellungen überschreibt. Dies ist nützlich, wenn ein einheitliches Erscheinungsbild unabhängig vom zugrunde liegenden Design erforderlich ist.

Anwenden eines Legacy-XLS-Voreinstellungs-Autoformats

PivotTable.AutoFormatType akzeptiert einen Wert aus der Enumeration Aspose.Cells.Pivot.PivotTableAutoFormatType. Die verfügbaren Werte sind Report1 bis Report10, Classic und Table1 bis Table10.

AutoFormatType wird nur berücksichtigt, wenn die Arbeitsmappe als .xls gespeichert wird. Wenn dieselbe Arbeitsmappe als .xlsx, .xlsm oder .xlsb gespeichert wird, ignoriert Excel diese Eigenschaft und greift auf die Einstellungen PivotTableStyleType und PivotTableStyleName zurück.

Das folgende Beispiel lädt eine neue Arbeitsmappe, füllt die Beispieldaten Fruit/Year/Amount, fügt eine Pivot-Tabelle hinzu, wendet PivotTableAutoFormatType.Report5 an und speichert das Ergebnis als .xls.

Warum keine Spaltenfelder? Die Autoformate der Report-Serie (Report1 bis Report10, Table1 bis Table10) wurden im klassischen Excel für eindimensionale Pivot-Tabellen mit nur Zeilenfeldern und Werten entworfen — sie haben keine integrierte Formatierung für Spaltenfeld-Überschriften. Wenn Ihre Pivot-Tabelle Spaltenfelder benötigt, verwenden Sie stattdessen die modernen PivotTableStyleType-Voreinstellungen aus Szenario 2 unten, die für das zweidimensionale Layout moderner Excel-Versionen entwickelt wurden.

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

// Szenario 1: Ein Legacy-XLS-Preset-Autoformat anwenden
// Verwendete API: PivotTable.AutoFormatType
// Zieldateiformat: .xls (Legacy)
// Für vollständige Beispiele und Datendateien besuchen Sie bitte https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Eine neue Arbeitsmappe erstellen
Workbook workbook = new Workbook();

// Das erste Arbeitsblatt abrufen
Worksheet sheet = workbook.Worksheets[0];

// Quelldaten mit Kopfzeile (Fruit, Year, Amount) befüllen
// und 9 Datenzeilen mit grape, blueberry, kiwi, cherry über 2020 und 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);

// Eine Pivot-Tabelle in der Zielzelle E3 mit dem Namen "Pivot1" unter Verwendung des Quellbereichs A1:C10 hinzufügen
int pivotIndex = sheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

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

// Das Legacy-XLS-Preset-Autoformat "Report5" anwenden
// Hinweis: Diese Eigenschaft ist nur beim Speichern als .xls relevant.
// Beim Speichern als .xlsx/.xlsm/.xlsb ignoriert Excel AutoFormatType
// und verwendet das, was PivotTableStyleType / PivotTableStyleName angibt.
pivotTable.AutoFormatType = PivotTableAutoFormatType.Report5;

// Die Arbeitsmappe im Legacy-.xls-Format speichern
workbook.Save("output.xls");

Anwenden eines modernen benannten Pivot-Tabellen-Voreinstellungsstils

PivotTable.PivotTableStyleType akzeptiert einen Wert aus der Enumeration Aspose.Cells.PivotTableStyleType. Die Enumeration umfasst helle Designs PivotTableStyleLight1 bis PivotTableStyleLight28 und dunkle Designs PivotTableStyleDark1 bis PivotTableStyleDark28. Die in Excel 2017 hinzugefügten Stile (die zweite Welle heller und dunkler Designs) sind über dieselbe Enumeration erreichbar.

Dies ist die empfohlene API für jedes moderne Dateiformat. Im Gegensatz zum Legacy-Autoformat wird der hier ausgewählte Stil von Excel originalgetreu wiedergegeben und übersteht Roundtrips durch andere Office-Werkzeuge.

Das folgende Beispiel verwendet dieselben Fruit/Year/Amount-Daten, erstellt eine identische Pivot-Tabelle, wendet PivotTableStyleDark1 an und speichert die Arbeitsmappe als .xlsx.

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

// Szenario 2: Anwendung eines modernen, benannten Excel 2007+ Voreinstellungsstils mit PivotTableStyleType.
// Zieldateiformat: .xlsx. Die PivotTableStyleType-Enumeration befindet sich im Aspose.Cells-Namespace
// (nicht in Aspose.Cells.Pivot) — deshalb benötigen wir keine zusätzliche using-Anweisung dafür.
// GitHub-Referenz: 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];

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

// 9 Datenzeilen mit Fruit / Year / 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(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);

// Hinzufügen einer Pivot-Tabelle an E3 mit dem Namen "Pivot1", basierend auf A1:C10
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Pivot-Felder zuweisen: Fruit -> Zeilenbereich, Year -> Spaltenbereich, Amount -> Datenbereich
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Anwendung eines modernen, benannten Excel 2007+ Pivot-Voreinstellungsstils.
// PivotTableStyleType ist die korrekte API für .xlsx / .xlsm / .xlsb-Dateien; AutoFormatType
// wird von Excel für diese Formate ignoriert. PivotTableStyleDark1 gehört zur Dunkel-Themen-Familie
// (PivotTableStyleDark1..PivotTableStyleDark28), und dieselbe Enumeration stellt auch die
// neueren Excel 2017 Hell/Dunkel-Themen bereit (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.PivotTableStyleType = PivotTableStyleType.PivotTableStyleDark1;

// Speichern als modernes .xlsx — dies ist das Format, für das PivotTableStyleType relevant ist.
workbook.Save("output.xlsx");

Definieren und Anwenden eines benutzerdefinierten Pivot-Tabellenstils

Die integrierten Voreinstellungen können nicht geändert werden. Wann immer Sie Farben, Rahmen oder Schriftarten überschreiben müssen, müssen Sie einen benutzerdefinierten Pivot-Stil definieren. Der Workflow umfasst drei Schritte:

Fügen Sie der TableStyles-Sammlung der Arbeitsmappe einen benutzerdefinierten Stil über Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name) hinzu. Dies gibt den Index des neu erstellten Stils zurück.
Konfigurieren Sie den Stil, indem Sie Elemente (wie WholeTable oder GrandTotalRow) über TableStyle.TableStyleElements.Add(TableStyleElementType) hinzufügen und dann jedem Element über TableStyleElement.SetElementStyle(Style) einen Style zuweisen.
Wenden Sie den benutzerdefinierten Stil auf die Pivot-Tabelle an, indem Sie PivotTable.PivotTableStyleName auf den Namen des Stils setzen. Verwenden Sie hier nicht PivotTableStyleType, da diese Eigenschaft integrierte Voreinstellungen auswählt.

PivotTableStyleName und PivotTableStyleType sind nicht austauschbar. Verwenden Sie PivotTableStyleType für integrierte Voreinstellungen und PivotTableStyleName für benutzerdefinierte Stile, die Sie über AddPivotTableStyle definiert haben. Beide zu setzen ist harmlos, aber nur das mit der beabsichtigten Quelle übereinstimmende wird wiedergegeben.

Die verfügbaren TableStyleElementType-Werte umfassen WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels und PageFieldValues.

Das folgende Beispiel definiert einen benutzerdefinierten Pivot-Stil mit einem dünnen schwarzen Rahmen für WholeTable und einer fetten roten Schriftart für GrandTotalRow, wendet ihn dann über PivotTableStyleName an und speichert als .xlsx.

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

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

// Quelldaten befüllen: Kopfzeile + 9 Datenzeilen (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);

// Pivot-Tabelle hinzufügen, Datenquelle A1:C10, verankert bei E3, Name "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");

// Schritt 1: Neuen benutzerdefinierten Pivot-Tabellenstil registrieren und Index erfassen
int styleIndex = workbook.Worksheets.TableStyles.AddPivotTableStyle("CustomPivotStyle");
TableStyle tableStyle = workbook.Worksheets.TableStyles[styleIndex];

// Schritt 2: WholeTable-Element hinzufügen und dünne schwarze Rahmen auf allen vier Seiten anwenden
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);

// Schritt 3: GrandTotalRow-Element hinzufügen und fettgedruckte rote Schrift anwenden
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);

// Schritt 4: Den benutzerdefinierten Stil namentlich anwenden (NICHT über PivotTableStyleType, dies gilt für eingebaute Voreinstellungen)
pivotTable.PivotTableStyleName = "CustomPivotStyle";

workbook.Save("output.xlsx");

Anwenden eines einzelnen Stils auf jede Pivot-Zelle mit FormatAll

PivotTable.FormatAll(Style) ist eine Verknüpfung, die ein einzelnes Style-Objekt auf jede Zelle der Pivot-Tabelle anwendet, einschließlich des Datenbereichs, der Zeilen- und Spaltenüberschriften sowie der Summen. Alles, was zuvor über PivotTableStyleType oder PivotTableStyleName gesetzt wurde, wird überschrieben.

FormatAll überschreibt sowohl PivotTableStyleType als auch PivotTableStyleName. Verwenden Sie es nur, wenn ein einheitliches, designunabhängiges Erscheinungsbild über die gesamte Pivot-Tabelle hinweg erforderlich ist.

Das folgende Beispiel erstellt einen Style mit gelber Vollfüllung, fetter dunkelblauer Schriftart und dünnen schwarzen Rahmen auf allen Seiten, wendet ihn dann mit FormatAll an und speichert als .xlsx.

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

// Szenario 4: Einen einzelnen Stil auf jede Pivot-Tabellen-Zelle mit FormatAll anwenden
// Verwendete API: PivotTable.FormatAll(Style)
// Zielformat: .xlsx
// GitHub-Referenz: siehe Aspose.Cells-for-.NET-Repository — Beispiele zur Pivot-Tabellen-Formatierung

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

// Quelldaten befüllen: Kopfzeile (Zeile 1) + 9 Datenzeilen (Zeilen 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);

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

// Pivot-Felder zuweisen: Fruit -> Zeilenbereich, Year -> Spaltenbereich, Amount -> Datenbereich
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Einen Stil erstellen, der auf jede Zelle der Pivot-Tabelle angewendet wird
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;

// FormatAll anwenden: erzwingt diesen einzelnen Stil auf jede Zelle der Pivot-Tabelle,
// überschreibt alle zuvor festgelegten PivotTableStyleType / PivotTableStyleName
pivotTable.FormatAll(style);

// Arbeitsmappe im modernen .xlsx-Format speichern
workbook.Save("output.xlsx");

Welche Stil-API sollte ich verwenden?

Die Wahl der Stil-API hängt vom Dateiformat ab, in dem Sie speichern. Verwenden Sie die folgende Tabelle als Kurzreferenz.

Zieldateiformat	Zu verwendende API	Hinweise
`.xls` (Legacy)	`PivotTable.AutoFormatType`	Werte aus `Aspose.Cells.Pivot.PivotTableAutoFormatType` (z. B. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Wird beim Speichern in modernen Formaten ignoriert.
`.xlsx` / `.xlsm` / `.xlsb` (modern, integrierter Stil)	`PivotTable.PivotTableStyleType`	Werte aus `Aspose.Cells.PivotTableStyleType` (helle/dunkle Designs, einschließlich Excel 2017 Ergänzungen).
`.xlsx` / `.xlsm` / `.xlsb` (modern, benutzerdefinierter Stil)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	Verwenden Sie dies, wenn die integrierten Voreinstellungen nicht ausreichen. Konfigurieren Sie über `TableStyleElement.SetElementStyle(...)`.
Beliebiges Format (einheitliche Überschreibung)	`PivotTable.FormatAll(Style)`	Verknüpfung, die jede andere Stileinstellung in der gesamten Pivot-Tabelle überschreibt.

Im Zweifelsfall speichern Sie als .xlsx und verwenden Sie PivotTableStyleType für integrierte Designs oder PivotTableStyleName für benutzerdefinierte Designs.

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

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

Aspose.Cells stellt eine mehrstufige Aktualisierungs-API bereit, mit der Sie Pivot-Daten in vier verschiedenen Geltungsbereichen neu laden können — von der gesamten Arbeitsmappe bis hin zu einer einzelnen Pivot-Tabelle. Ab Aspose.Cells for .NET v26.7 ist die Legacy-Methode PivotTable.RefreshData() als veraltet markiert und sollte durch die effizienteren, cache-bewussten APIs ersetzt werden, die in diesem Artikel beschrieben werden.

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:

Datenquelle — die ursprünglichen Arbeitsblattbereiche, Datenbankabfragen oder Konsolidierungsbereiche, in denen die Rohwerte gespeichert sind.
PivotCache — der In-Memory-Snapshot der Quelldaten. Jede Pivot-Tabelle wird auf einem PivotCache aufgebaut; hier werden alle Daten gesammelt und aggregiert.
PivotTable — das Ansichtsobjekt, das Zeilen-, Spalten-, Werte- und Filterfelder definiert. Eine PivotTable liest nur aus ihrem PivotCache, niemals direkt aus der Datenquelle.
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.

PivotCache.SourceType (Enum PivotTableSourceType) gibt an, woher die Cache-Daten stammen. Ab v26.7 unterstützt PivotCache.Refresh() nur die Quellentypen Sheet und Consolidation — also Daten, die in Arbeitsblattbereichen liegen. Externe Quellen (Datenbanken, externe Verbindungen usw.) sind über die Cache-API noch nicht aktualisierbar.

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.

Da Pivot-Tabellen eine einzelne PivotCache-Instanz gemeinsam nutzen, berechnet der Aufruf von PivotCache.Refresh() alle Pivot-Tabellen neu, die auf demselben Cache aufgebaut sind — nicht nur die, die Sie referenzieren. Wenn zwei Pivot-Tabellen denselben Quellbereich gemeinsam nutzen, aktualisiert das Aktualisieren eines Caches beide.

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.

Net: Zeilen- und Spaltenfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

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

Hinzufügen eines Felds zum Zeilen- oder Spaltenbereich

Die Methode PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) verschiebt ein Basis-Feld aus den Quelldaten in einen der vier PivotTable-Bereiche. Das Argument fieldType akzeptiert einen der folgenden PivotFieldType-Werte.

Row — Felder, die vertikal links platziert werden
Column — Felder, die horizontal oben platziert werden
Data — Felder, deren Werte aggregiert werden
Page — Felder, die als Berichtsfilter verwendet werden

Nachdem Felder hinzugefügt wurden, können Sie über die Eigenschaften PivotTable.RowFields und PivotTable.ColumnFields darauf zugreifen. Jede Eigenschaft gibt eine PivotFieldCollection zurück. Das Feld mit Index 0 von RowFields ist das äußerste Zeilenfeld, und nachfolgende Indizes stellen Felder dar, die darin verschachtelt sind. Die gleiche Indexierungskonvention gilt für ColumnFields.

Die Verschachtelungsreihenfolge der Felder ist wichtig. Wenn Sie zuerst Category zum Zeilenbereich und dann Item hinzufügen, entsteht eine PivotTable, deren äußere Gruppierung Category und deren innere Gruppierung Item ist. Durch Umkehren der Reihenfolge wird die Hierarchie umgekehrt.

PivotField-Zwischensummen

Die Methode PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) steuert, welche Zwischensummenzeilen für ein PivotField angezeigt werden. Jeder Aufruf schaltet einen einzelnen Zwischensummentyp unabhängig um. Wenn Sie shown = true übergeben, wird die Zwischensumme angezeigt, während shown = false sie ausblendet. Da jeder Aufruf nur einen Typ betrifft, können Sie durch mehrfaches Aufrufen der Methode mit unterschiedlichen subtotalType-Werten eine benutzerdefinierte Teilmenge von Zwischensummen erstellen.

Die Enumeration PivotFieldSubtotalType definiert die verfügbaren Zwischensummenarten.

Automatic — Aspose.Cells wählt die Standardauswahl (typischerweise Sum für numerische Felder)
None — unterdrückt jede Zwischensummenzeile
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

Zwischensummen werden nur dann angezeigt, wenn zwei oder mehr Pivot-Felder im Zeilenbereich (oder im Spaltenbereich) vorhanden sind. Ein einzelnes Feld hat nichts Sinnvolles, wofür eine Zwischensumme gebildet werden kann, sodass SetSubtotals-Aufrufe in diesem Fall keine sichtbare Wirkung haben. Dieser Artikel platziert daher in jedem Beispiel zwei Zeilenfelder (Category außen, Item innen), damit die Zwischensummengrenze zwischen jeder Category-Gruppe sichtbar ist.

Szenario 1 — Automatische (Standard-) Zwischensummen

Wenn Sie SetSubtotals überhaupt nicht aufrufen, wendet Aspose.Cells die Automatic-Auswahl auf numerische Felder an. Das folgende Beispiel bestätigt dieses Verhalten explizit, indem es SetSubtotals(PivotFieldSubtotalType.Automatic, true) auf dem äußeren Zeilenfeld Category aufruft.

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

Szenario 2 — Alle Zwischensummen unterdrücken (None)

Der Aufruf von SetSubtotals(PivotFieldSubtotalType.None, true) entfernt jede Zwischensummenzeile aus der PivotTable, sodass nur die Feldzeilen und die Gesamtsumme unten übrig bleiben. Dies ist nützlich, wenn Sie die rohen gruppierten Daten ohne Zusammenfassungszeilen wünschen.

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

Szenario 3 — Benutzerdefinierte Zwischensummen-Teilmenge (Sum + Average)

Sie sind nicht auf einen einzelnen Zwischensummentyp beschränkt. Jeder SetSubtotals-Aufruf wirkt unabhängig auf einen Typ, sodass der zweimalige Aufruf der Methode — einmal mit Sum und einmal mit Average — eine benutzerdefinierte Teilmenge von zwei Zwischensummenzeilen für jede Category-Gruppe erzeugt.

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

Zusammenfassung

Die drei oben genannten Szenarien verwenden denselben Datensatz und dieselbe PivotTable-Struktur. Der einzige Unterschied zwischen ihnen ist der SetSubtotals-Aufruf, der auf das äußere Zeilenfeld Category angewendet wird. Denken Sie an die Zwei-Felder-Regel: Ein einzelnes Feld in einem Bereich hat nichts, wofür eine Zwischensumme gebildet werden kann. Platzieren Sie also immer mindestens zwei Felder im Zeilen- oder Spaltenbereich, wenn Sie möchten, dass SetSubtotals eine sichtbare Wirkung hat.

Net: Wertfelder einer PivotTable in Aspose.Cells für .NET verwalten

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

Hinzufügen eines Felds zum Datenbereich

Das Hinzufügen eines Basisfelds zum Daten- (Wert-)Bereich ist der erste Schritt bei der Gestaltung der Aggregation Ihrer Quelldaten durch eine PivotTable. Aspose.Cells stellt PivotTable.AddFieldToArea(PivotFieldType, string) bereit, eine Überladung, die die Konstante PivotFieldType.Data und den Namen der Quellspalte akzeptiert. Sobald ein Feld zum Datenbereich hinzugefügt wurde, stellt die API es über die Auflistung PivotTable.DataFields in der Reihenfolge bereit, in der die Felder hinzugefügt wurden. Standardmäßig wird eine numerische Quellspalte mit ConsolidationFunction.Sum zusammengefasst, während eine nicht-numerische Spalte standardmäßig Count verwendet.

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

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

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

// Datenzeilen A2:D9 mit verschachtelten Schleifen, die nach j verzweigen
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;
 }
 }
}

// Pivot-Tabelle bei F3 mit dem Namen PivotTable1 hinzufügen
int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Pivot-Layout: Kategorie und Element in Zeile, Jahr in Spalte, Betrag als Datenfeld
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");

Ändern der Zusammenfassungsfunktion

Jedes im Datenbereich platzierte Feld wird intern als PivotField-Instanz gekapselt, und seine Function-Eigenschaft gibt einen Wert aus der Enumeration ConsolidationFunction zurück. Mit demselben Function-Setter können Sie zwischen den verfügbaren Aggregaten wechseln, einschließlich Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var und Varp.

Das Ändern von Function wirkt sich nur auf das Aggregat aus, die Quellspalte ändert sich nicht.

Sie können daher ein Datenfeld als Sum belassen, während Sie ein zweites Datenfeld hinzufügen, das auf dieselbe Quellspalte abzielt, aber Count oder Average verwendet, alles in einer einzigen PivotTable.

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

Wertfelder auf die Zeilen- oder Spaltenachse ablegen

Wenn eine PivotTable zwei oder mehr Datenfelder enthält, stellt Aspose.Cells ein zusätzliches virtuelles Feld mit der Bezeichnung PivotTable.ValuesField bereit. Dieses virtuelle Feld repräsentiert das Aggregat jedes Datenfelds, das sich im Datenbereich befindet. Sie können es als Basis-Pivot-Feld in den Zeilen- oder Spaltenbereich ziehen, was nützlich ist, um mehrere Measures nebeneinander anzuordnen.

PivotTable.ValuesField funktioniert nicht, wenn kein oder nur ein Wertfeld vorhanden ist.

Die folgenden Szenarien führen durch drei durchgängige Beispiele, die jede der oben beschriebenen Funktionen anhand derselben Pivot-Struktur demonstrieren.

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: Filterfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

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

Aspose.Cells unterstützt den gesamten Lebenszyklus von Filterfeldern in Pivot-Tabellen. Sie können ein Filterfeld über eine übergeordnete Komfort-API oder über die niederstufige PageFields-Sammlung hinzufügen. Sie können den Filter im Einzelauswahlmodus steuern, ihn zurücksetzen, um alle Seitenelemente anzuzeigen, oder das Feld auf Mehrfachauswahl umschalten, damit Benutzer über die Kontrollkästchen-Oberfläche in Excel mehrere Seitenelemente gleichzeitig auswählen können.

Einführung

Ein Filterfeld ist ein Pivot-Feld, das steuert, welche Teilmenge der Quelldaten der Pivot-Körper anzeigt. Endbenutzer sehen es als Dropdown am oberen Rand einer gerenderten Pivot-Tabelle in Excel. Durch Auswahl eines der verfügbaren Seitenelemente wird der Pivot-Körper neu aufgebaut, sodass nur die Datensätze zusammengefasst werden, die zu diesem Seitenelement gehören. Ein Pivot-Feld wird zu einem Filterfeld, wenn es als PivotFieldType.Page statt als PivotFieldType.Row, PivotFieldType.Column oder PivotFieldType.Data registriert wird.

Ein Filterfeld kann zwei Verhaltensweisen aufweisen. Im standardmäßigen Einzelauswahl-Verhalten ist jeweils nur ein Seitenelement sichtbar, sodass der Pivot-Körper genau eine Teilmenge zusammenfasst. Im Mehrfachauswahl-Verhalten zeigt das Feld eine Kontrollkästchenliste an, und der Pivot-Körper fasst die Vereinigung aller markierten Seitenelemente zusammen. Dasselbe Quellfeld kann zwischen diesen Verhaltensweisen hin und her verschoben werden, indem eine einzelne Eigenschaft umgeschaltet wird.

Aspose.Cells for .NET stellt zwei gleichwertige Möglichkeiten bereit, ein Filterfeld zu registrieren. Die übergeordnete API ist PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName"), die den Namen der Quellspalte übernimmt und das Feld in einem einzigen Aufruf hinzufügt. Die niederstufige API ist PivotTable.PageFields.Add(PivotField), die verwendet wird, wenn Sie bereits eine PivotField-Referenz besitzen und dieselbe Feldinstanz zum Filterbereich hinzufügen möchten. Beide APIs füllen am Ende dieselbe PageFields-Sammlung, und der Rest dieses Artikels zeigt, wie Sie zwischen ihnen wählen und wie Sie die einzelnen Filtermodi ansteuern.

Hinzufügen eines Filterfelds

Es gibt zwei Möglichkeiten, ein Pivot-Feld im Filterbereich zu registrieren. Der übergeordnete Aufruf übernimmt den Namen der Quellspalte als Zeichenkette und ist der häufigste Weg. Der niederstufige Aufruf akzeptiert eine vorhandene PivotField-Instanz und ist praktisch, wenn dieselbe Feldinstanz in mehreren Pivot-Bereichen wiederverwendet werden muss. Beide Aufrufe platzieren das Feld in PivotTable.PageFields, woraufhin es als Dropdown für die Seite am oberen Rand der gerenderten Pivot-Tabelle erscheint.

Hinzufügen eines Filterfelds mit AddFieldToArea

Das folgende Beispiel erstellt einen kleinen Datensatz mit den Spalten Frucht / Jahr / Betrag, platziert eine Pivot-Tabelle in Zelle E3 mit Fruit im Zeilenbereich, Amount im Datenbereich und Year im Filterbereich, aktualisiert die Pivot-Tabelle und speichert die Arbeitsmappe.

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

// Ein neues Arbeitsbuch erstellen
var workbook = new Workbook();
var worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

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

// 9 Zeilen Beispieldaten einfügen: Frucht, Jahr, Betrag
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]);
}

// Eine Pivot-Tabelle hinzufügen, die an Zelle E3 verankert ist
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Felder zu ihren Bereichen hinzufügen: Frucht als Zeile, Betrag als Daten, Jahr als Seitenfeld
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Pivot-Tabellendaten aktualisieren und berechnen
pivotTable.CalculateData();

// Das Arbeitsbuch speichern
workbook.Save("pageFieldSample.xlsx");

Hinzufügen eines Filterfelds mit PageFields.Add

Wenn Sie bereits mit einer PivotField-Instanz arbeiten, können Sie diese direkt an PivotTable.PageFields.Add übergeben. Die Pivot-Tabelle und das Filterfeld werden genau wie im vorherigen Szenario konstruiert; nur die endgültige Registrierung im Filterbereich wird durch den niederstufigen API-Aufruf ersetzt.

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

// — Die Pivot-Tabelle und das Seitenfeld werden genau wie in
//   Szenario 1a (Frucht/Jahr/Betrag-Daten, Pivot bei E3, Frucht→Zeile,
//   Betrag→Daten) erstellt. Unten holen wir das Jahr-PivotField aus der
//   BaseFields-Sammlung und übergeben es an PageFields.Add — die
//   Low-Level-Alternative zu AddFieldToArea. Das Ergebnis ist
//   funktional identisch mit Szenario 1a.

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

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

// Beispieldaten (9 Zeilen)
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);

// Pivot-Tabelle bei E3 hinzufügen, die A1:C10 abdeckt
int pivotIndex = sheet.PivotTables.Add("E3", "A1:C10", "PivotTable1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Frucht -> Zeile, Betrag -> Daten (Jahr wird unten zur Seite hinzugefügt)
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Low-Level-Ansatz: das vorhandene Jahr-PivotField aus BaseFields holen
// und es über PageFields.Add(PivotField) im Seitenbereich registrieren.
PivotField yearField = pivotTable.BaseFields["Year"];
pivotTable.PageFields.Add(yearField);

// Aktualisieren, damit das neue Seitenfeld in der gespeicherten Arbeitsmappe widergespiegelt wird
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Einzelauswahl-Filterung (Anzeigen eines Seitenelements)

Im standardmäßigen Einzelauswahl-Verhalten wird das Filterfeld als einzelnes Dropdown gerendert, und die Ganzzahl PivotField.CurrentPageItem wählt aus, welches Seitenelement den Pivot-Körper antreibt. Durch Zuweisen eines bestimmten Index wird dieses eine Element ausgewählt; durch Zuweisen des speziellen Sentinelwerts 0x7FFD (Dezimalwert 32765) wird der Filter zurückgesetzt, sodass alle Seitenelemente gleichzeitig zusammengefasst werden. Die Einzelauswahl ist der Standard; Sie müssen sie nicht explizit aktivieren.

Anzeigen aller Elemente

Das Setzen von CurrentPageItem auf den magischen Wert 0x7FFD entspricht dem Aufheben des Filters: Der Pivot-Körper fasst alle Seitenelemente zusammen, als ob kein Filter angewendet worden wäre.

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

class Program
{
    static void Main()
    {
        // Erstellen Sie eine neue Arbeitsmappe
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];

        // Fruit/Year/Amount-Daten einfügen
        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]);
            }
        }

        // Pivot-Tabelle bei E3 erstellen
        var pivotTables = sheet.PivotTables;
        int index = pivotTables.Add("=A1:C7", "E3", "PivotTable1");
        PivotTable pivotTable = pivotTables[index];

        // Pivot-Felder konfigurieren: Fruit→Zeile, Amount→Daten, Year→Seite
        pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
        pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
        pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

        pivotTable.CalculateData();

        // Den Seitenfilter löschen, damit jedes Element im Seitenfeld sichtbar ist.
        // 0x7FFD (Dezimal 32765) ist der spezielle Sentinel-Wert, der "alle Elemente" bedeutet —
        // entspricht der Auswahl von "(Alle)" im Seitenfeld-Dropdown von Excel.
        pivotTable.PageFields[0].CurrentPageItem = 0x7FFD;

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

Anzeigen eines bestimmten Elements

Das Setzen von CurrentPageItem auf einen echten Index wählt genau dieses eine Seitenelement aus. Der Index ist die Position des Elements in der sortierten Elementliste des Filterfelds, sodass beispielsweise 1 das zweite Element nach dem Sortieren auswählt.

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

// Arbeitsmappe erstellen
var workbook = new Workbook();
var sheet = workbook.Worksheets[0];
var cells = sheet.Cells;

// Beispieldaten hinzufügen (Obst/Jahr/Betrag)
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");

// Pivot-Tabelle bei E3 hinzufügen
var pivotTables = sheet.PivotTables;
int pivotIndex = pivotTables.Add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables[pivotIndex];

// Felder hinzufügen: Obst→Zeile, Betrag→Daten, Jahr→Seite
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Seitenfeldspezifische Operationen
pivotTable.PageFields[0].CurrentPageItem = 1; // 1 = zweites Element in sortierter Reihenfolge (z. B. "2021")

// Pivot-Tabelle aktualisieren und berechnen
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Mehrfachauswahl-Filterung

Die Mehrfachauswahl-Filterung verwandelt das Seiten-Dropdown in eine Kontrollkästchenliste und ermöglicht es dem Endbenutzer, mehrere Seitenelemente gleichzeitig auszuwählen. Aspose.Cells stellt zwei Eigenschaften bereit, die zusammenarbeiten. PivotField.IsMultipleItemSelectionAllowed muss auf true gesetzt werden, bevor die Mehrfachauswahl-Benutzeroberfläche überhaupt wirksam wird. Nach der Aktivierung steuert PivotItem.IsHidden, welche Elemente in der Kontrollkästchenliste angezeigt werden, sodass Sie entweder alle Elemente anzeigen oder nur bestimmte Elemente auf eine Whitelist setzen können.

Der folgende Code aktiviert die Mehrfachauswahl für dasselbe Filterfeld Year, das in Szenario 1a erstellt wurde, und zeigt anschließend zwei Muster: Teil A deckt alle Seitenelemente auf, indem IsHidden für jeden Eintrag auf false belassen wird, während Teil B nur die von Ihnen gewählten Quellwerte auf eine Whitelist setzt und alle anderen Elemente über einen switch (pivotItems[i].GetStringValue())-Block ausblendet.

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

// — Die Pivot-Tabelle und das Seitenfeld werden genau wie in
//   Szenario 1a erstellt (Fruit/Year/Amount-Daten, Pivot bei E3, Fruit→Zeile,
//   Amount→Daten, Year→Seite über AddFieldToArea).
//   Unten wenden wir Mehrfachauswahl-Filterung auf das Seitenfeld an.

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

// Beispieldaten: 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");

// — Mehrfachauswahl auf dem Seitenfeld aktivieren
pivotTable.PageFields[0].IsMultipleItemSelectionAllowed = true;

// Teil A — ALLE Elemente auswählen (jedes Element sichtbar machen)
PivotItemCollection pivotItems = pivotTable.PageFields[0].PivotItems;
for (int i = 0; i < pivotItems.Count; i++)
{
    pivotItems[i].IsHidden = false;
}

// Teil B — nur bestimmte Elemente nach Quellwert auswählen
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");

Hinweis: Bei Verwendung der Mehrfachauswahl-Filterung über PivotItem.IsHidden muss mindestens ein PivotItem sichtbar bleiben (IsHidden == false). Wenn jedes Element ausgeblendet ist, stürzt Excel entweder beim Öffnen der Datei ab oder zeigt eine leere Pivot-Tabelle an. Stellen Sie stets sicher, dass Ihre Mehrfachauswahl-Whitelist mindestens ein Element aus Ihren Quelldaten enthält.

Welche API und welcher Modus sollten verwendet werden?

Die folgende Tabelle fasst zusammen, wann welche API und welcher Modus verwendet werden sollte, damit Sie die richtige Kombination wählen können, ohne jedes Szenario im Detail lesen zu müssen.

Szenario / Anwendungsfall	Empfohlene API	Verwendete Eigenschaft	Hinweise
Filterfeld nach Quellspaltenname hinzufügen (am häufigsten)	`PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName")`	n. a.	Übergeordnet, einzeilig. Verwenden Sie dies, sofern Sie keine `PivotField`-Referenz benötigen.
Filterfeld hinzufügen, wenn Sie bereits über ein `PivotField`-Objekt verfügen	`PivotTable.PageFields.Add(PivotField)`	n. a.	Verwenden Sie dies, wenn das Feldobjekt bereits anderweitig bezogen wurde oder wiederverwendet werden muss.
Auf ein einzelnes Seitenelement filtern (Standardmodus)	`PivotField.CurrentPageItem`	auf einen bestimmten Index setzen	Beispielsweise zeigt `1` das zweite Element in der sortierten Liste an.
Alle Elemente anzeigen / Filter zurücksetzen	`PivotField.CurrentPageItem`	auf `0x7FFD` setzen	Der magische Wert `0x7FFD` (Dezimalwert 32765) ist der Sentinelwert für “alle Elemente”.
Mehrfachauswahl-Benutzeroberfläche in Excel aktivieren	`PivotField.IsMultipleItemSelectionAllowed`	auf `true` setzen	Erforderlich, bevor `IsHidden`-Aufrufe wirksam werden.
Einzelne Elemente in einer Mehrfachauswahl-Liste ausblenden / anzeigen	`PivotItem.IsHidden`	pro Element setzen	Mindestens ein Element muss sichtbar bleiben (`IsHidden == false`).

Beachten Sie stets die Sichtbarkeitsbeschränkung bei der Konfiguration der Mehrfachauswahl-Filterung. Wenn jedes PivotItem in einem Mehrfachauswahl-Filterfeld ausgeblendet ist, stürzt Excel beim Öffnen ab oder zeigt eine leere Pivot-Tabelle an. Erstellen Sie Ihre Whitelist auf Grundlage Ihrer Quelldaten, sodass mindestens ein Element sichtbar bleibt, und Ihre gespeicherten Arbeitsmappen werden auf jedem Rechner zuverlässig geöffnet.

Net: Pivot Tabelle aus einem Arbeitsblatt löschen

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

Aspose.Cells bietet die Möglichkeit, eine Pivot-Tabelle aus einem Arbeitsblatt zu löschen oder zu entfernen. Sie können die Pivot-Tabelle unter Verwendung des Pivot-Tabelle-Objekts oder der Position der Pivot-Tabelle löschen. Bitte verwenden Sie die Worksheet.PivotTables.Remove()-Methode, um die Pivot-Tabelle unter Verwendung des Pivot-Tabelle-Objekts zu löschen, und die Worksheet.PivotTables.RemoveAt()-Methode, um das Pivot-Tabellen-Objekt unter Verwendung seiner Position innerhalb der Pivot-Tabellensammlung zu löschen.

Der folgende Beispielcode löscht zwei Pivot-Tabellen aus dem Arbeitsblatt. Zuerst entfernt er die Pivot-Tabelle unter Verwendung der Worksheet.PivotTables.Remove()-Methode und dann entfernt er die Pivot-Tabelle unter Verwendung der Worksheet.PivotTables.RemoveAt()-Methode

Net: Pivot Tabelle in ODS Datei speichern

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

Aspose.Cells ermöglicht das Speichern einer Pivot-Tabelle in ODS-Dateien. Dazu konvertieren Sie einfach eine Arbeitsmappe mit einer vorhandenen Pivot-Tabelle oder erstellen eine neue Pivot-Tabelle und speichern die Datei im ODS-Format. Stellen Sie sicher, dass PivotTable.CalculateData() aufgerufen wird, bevor Sie speichern, um sicherzustellen, dass die Pivot-Tabelle in der Ausgabedatei gerendert wird. Der folgende Code-Ausschnitt zeigt das Speichern der Pivot-Tabelle in einer ODS-Datei.

Beispielcode

Die Ausgabedatei, die durch den obigen Code generiert wurde, ist als Referenz angehängt.

Ausgabedatei ODS

Documentation – Pivot Tabelle einfügen

Net: Formatieren der Pivot Tabelle

Aussehen der Pivot-Tabelle

Einstellen der Pivot-Tabellenformatoptionen

Einstellen des AutoFormat-Typs

Einstellen von Formatoptionen

Manuelles Anpassen von Aussehen und Anmutung

Einstellen von Formatoptionen für Pivot-Felder

Formatieren von Zeilen/Spalten/Seitenfeldern

Einstellen von Datenfeldformaten

Löschen von Pivot-Feldern

Net: Erstellen von Pivot Tabellen und Pivot Diagrammen

Hinzufügen von Pivot-Tabellen und -Diagrammen

Vorbereitung zur Verwendung von Aspose.Cells

Hinzufügen einer Pivot-Tabelle

Hinzufügen eines Pivot-Diagramms

Net: Pivot Tabelle und Quelldaten

Quelldaten der Pivot-Tabelle

Ändern der Datenquelle einer Pivot-Tabelle

Net: Erstellen Sie ein berechnetes Feld im Pivot Table

Mögliche Verwendungsszenarien

Füge ein berechnetes Feld in eine Pivot-Tabelle in Excel ein

Fügen Sie ein berechnetes Feld in eine Pivot-Tabelle mithilfe von C# ein

Beispielcode

Net: Stile auf PivotTables in Aspose.Cells für .NET anwenden

Einführung

Anwenden eines Legacy-XLS-Voreinstellungs-Autoformats

Anwenden eines modernen benannten Pivot-Tabellen-Voreinstellungsstils

Definieren und Anwenden eines benutzerdefinierten Pivot-Tabellenstils

Anwenden eines einzelnen Stils auf jede Pivot-Zelle mit FormatAll

Welche Stil-API sollte ich verwenden?

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

Einführung

Erforderliche Using-Direktiven

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Alle Pivot-Tabellen in einem einzelnen Arbeitsblatt aktualisieren

Eine einzelne Pivot-Tabelle aktualisieren

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

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

Alle Pivot-Tabellen abrufen, die denselben PivotCache gemeinsam nutzen

Migration von der veralteten PivotTable.RefreshData()

Welche Aktualisierungs-API sollte ich verwenden?

Net: Zeilen- und Spaltenfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Hinzufügen eines Felds zum Zeilen- oder Spaltenbereich

PivotField-Zwischensummen

Szenario 1 — Automatische (Standard-) Zwischensummen

Szenario 2 — Alle Zwischensummen unterdrücken (None)

Szenario 3 — Benutzerdefinierte Zwischensummen-Teilmenge (Sum + Average)

Zusammenfassung

Net: Wertfelder einer PivotTable in Aspose.Cells für .NET verwalten

Hinzufügen eines Felds zum Datenbereich

Ändern der Zusammenfassungsfunktion

Wertfelder auf die Zeilen- oder Spaltenachse ablegen

Net: Filterfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Einführung

Hinzufügen eines Filterfelds

Hinzufügen eines Filterfelds mit AddFieldToArea

Hinzufügen eines Filterfelds mit PageFields.Add

Einzelauswahl-Filterung (Anzeigen eines Seitenelements)

Anzeigen aller Elemente

Anzeigen eines bestimmten Elements

Mehrfachauswahl-Filterung

Welche API und welcher Modus sollten verwendet werden?

Net: Pivot Tabelle aus einem Arbeitsblatt löschen

Net: Pivot Tabelle in ODS Datei speichern

Beispielcode

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

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

Migration von der veralteten `PivotTable.RefreshData()`