Documentation – Infoga pivot tabell

Net: Formatera Pivot tabell

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

Pivottabellens utseende

Hur man skapar en pivottabell förklarar hur man skapar en enkel pivottabell. Den här artikeln beskriver hur man anpassar en pivottabells utseende genom att ställa in olika egenskaper:

Pivottabellformatalternativ
Alternativ för pivottabellfältformat
Alternativ för datafältformat

Inställning av pivottabellformatalternativ

Klassen PivotTable kontrollerar den övergripande pivottabellen och kan formateras på olika sätt.

Inställning av autoformat typ

Microsoft Excel erbjuder ett antal olika förinställda rapportformat. Aspose.Cells stöder också dessa formateringsalternativ. För att komma åt dem:

Ställ in PivotTable.IsAutoFormat till true.
Tilldela ett formateringsalternativ från uppräkningen PivotTableAutoFormatType.

Inställning av formatalternativ

Kodprovet nedan visar hur man formaterar pivottabellen för att visa totaler för rader och kolumner, och hur man ställer in rapportens fältsortering. Det visar också hur man ställer in en anpassad sträng för nollvärden.

Manuell formatering av utseende

För att formatera hur pivottabellsrapporten ser ut manuellt, istället för att använda förinställda rapportformat, använd PivotTable.Format()- och PivotTable.FormatAll()-metoderna. Skapa en stilobjekt för den önskade formateringen, till exempel:

Inställning av pivottabellfältformatalternativ

Klassen PivotField representerar ett fält i en pivottabell och kan formateras på olika sätt. Kodprovet nedan visar hur man:

Tillgång till radfält.
Inställning av delsummer.
Inställning av autosortering.
Inställning av autoshow.

Inställning av format för rad/kolumn/sidofältsformat

Inställning av format för datafält

Kodprovet nedan visar hur man ställer in visningsformat och nummerformat för datafält.

Rensa pivottabellsfält

Klassen PivotFieldCollection har en metod som heter Clear() som låter dig rensa pivottabellsfält. Använd den när du vill rensa alla pivottabellfält i områdena, till exempel sida, kolumn, rad eller data. Kodprovet nedan visar hur man rensar alla pivottabellfält i ett dataområde.

Net: Skapa pivottabeller och pivotdiagram

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

En pivottabell är en interaktiv sammanfattning av poster. Till exempel kan du ha hundratals faktura-poster i en lista i ett kalkylblad. En pivottabell kan summera fakturorna efter kund, produkt eller datum. Med Microsoft Excel är det möjligt att snabbt omorganisera informationen i pivottabellen genom att dra knappar till en ny position.

Ett pivotdiagram är en interaktiv grafisk representation av data i en pivottabell. Pivotdiagram introducerades i Excel 2000. Att använda ett pivotdiagram gör det ännu enklare att förstå data eftersom pivottabellen skapar delsummer och totaler automatiskt.

Aspose.Cells stödjer pivottabeller och pivotdiagram.

Lägg till Pivottabeller och Diagram

Aspose.Cells tillhandahåller en speciell uppsättning klasser som används för att skapa pivottabeller. Dessa klasser används för att skapa och ställa in PivotTable-objekt, som fungerar som en pivottabells grundläggande byggstenar:

PivotField, ett fält i en pivottabellrapport.
PivotFields, en samling av alla PivotField-objekt i en pivottabell.
PivotTable, en pivottabellrapport på ett kalkylblad.
PivotTables, en samling av alla PivotTable-objekt på kalkylbladet.

Förberedelser för att använda Aspose.Cells

Ladda ner och installera Aspose.Cells:
1. Ladda ner Aspose.Cells.
2. Installera det på din utvecklingsdator. När alla Aspose -komponenter är installerade fungerar de i utvärderingsläge. Utvärderingsläget har ingen tidsbegränsning och det infogar bara vattenstämplar i producerade dokument. För att använda komponenten i full kapacitet måste du ha en giltig licens.
Skapa ett projekt:
1. Starta Visual Studio.Net.
2. Skapa en ny konsolapplikation.
Lägg till referenser: Lägg till en referens till Aspose.Cells-komponenten i ditt projekt, till exempel …\Program Files\Aspose\Aspose.Cells\Bin\Net1.0\Aspose.Cells.dll

Lägga till en pivottabell

För att skapa en pivot tabell med Aspose.Cells:

Lägg till lite data till arbetsbladsceller med hjälp av en Cell-objekts PutValue/setValue-metod. Du kan också använda en mallfil som redan är ifylld med data. Data kommer att användas som pivot tabellens datakälla.
Lägg till en pivot tabell till arbetsbladet genom att anropa PivotTables -samlingens add-metod (inkapslad i Worksheet-objektet).
Hämta det nya PivotTable-objektet från PivotTables-samlingen genom att ange dess index. # Använd något av de pivottabellobjekt som är inkapslade i PivotTable-objektet för att hantera tabellen.

Kodexempel ges nedan.

Lägga till en PivotChart

För att skapa en PivotChart med Aspose.Cells:

Lägg till en graf.
Ange grafens PivotSource så att den hänvisar till en befintlig pivot tabell i kalkylarket.
Ange andra attribut.

Net: Pivot tabell och källdata

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

Pivot-tabellens källdata

Det finns tillfällen då du vill skapa Microsoft Excel-rapporter med pivottabeller som hämtar data från olika datakällor (t.ex. en databas) som inte är kända vid design-tid. Denna artikel ger en metod för att dynamiskt ändra en pivot-tabells datakälla.

Ändra en pivot-tabells källdata

Skapa en ny designer-mall.
1. Skapa en ny designer-mallfil enligt skärmbilden nedan.
2. Definiera sedan ett namngivet område, Datakälla, som hänvisar till detta cellområde.
  
  Skapa en designer-mall & definiera ett namngivet område, Datakälla

Skapa en pivot-tabell baserad på detta namngivna område.
1. I Microsoft Excel, välj Data, sedan Pivottabell och PivotDiagramrapport.
2. Skapa en pivottabell baserad på det namngivna området som skapats i det första steget.
  
  Skapa en pivottabell baserad på det namngivna området, DataSource

Dra det motsvarande fältet till pivottabellraden och kolumnen, skapa sedan den resulterande pivottabellen enligt skärmdumpen nedan.

Skapa en pivottabell baserad på ett motsvarande fält

Högerklicka på pivottabellen och välj Tabelloptioner.
1. Markera Uppdatera vid öppning i inställningarna för Dataalternativ.
  
  Inställning av pivottabellalternativ

Nu kan du spara den här filen som din designer-mallfil.

Försörjning av ny data och ändring av källdata för en pivottabell.
1. När den designer-mall är skapad, använd följande kod för att ändra källan till pivottabellen.

Genom att köra den här exempelkoden nedan ändras källan till pivottabellen.

Net: Lägg till beräknat fält i pivottabell

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

Möjliga användningsscenario

När du skapar en pivottabell baserad på kända data finner du att datan i den inte är det du vill ha. Den data du vill ha är kombinationen av denna ursprungliga data. Till exempel behöver du lägga till, subtrahera, multiplicera och dividera den ursprungliga datan innan du vill ha datan. Vid den här tiden behöver du bygga ett beräknat fält och ställa in motsvarande formel för beräkning. Utför sedan vissa statistik och andra operationer på det beräknade fältet.

Lägg till beräknat fält i pivottabell i Excel

Så här lägger du till ett beräknat fält i en pivot-tabell i Excel, följ dessa steg:

Välj pivottabellen som du vill lägga till ett beräknat fält i.
Gå till fliken Pivottabell analysera på menyfliken.
Klicka på “Fält, artiklar och uppsättningar” och välj sedan “Beräknat fält” i rullgardinsmenyn.
I fältet “Namn” anger du ett namn för det beräknade fältet.
I fältet “Formel” anger du formeln för beräkningen du vill utföra med hjälp av lämpliga PivotTable-fältnamn och matematiska operatorer.
Klicka på “ok” för att skapa det beräknade fältet.
Det nya beräknade fältet kommer att visas i PivotTable Field List under avsnittet Värden.
Dra det beräknade fältet till värdesektionen i PivotTable för att visa de beräknade värdena.

Lägg till beräknat fält i Pivot-tabell med C#

Lägg till beräknat fält i Excel-fil med hjälp av Aspose.Cells. Se följande exempelkod. Efter att ha kört exempelkoden läggs en pivottabell med beräknad inmatning till arbetsbladet.

Ange originaldata och skapa en pivot-tabell.
Skapa det beräknade fältet enligt det befintliga PivotField i pivot-tabellen.
Lägg till det beräknade fältet i dataområdet.
Slutligen sparas arbetsboken i utdata XLSX-format.

Exempelkod

Net: Tillämpa stilar på pivottabeller i Aspose.Cells för .NET

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

Aspose.Cells stöder både äldre pivot-autoformat (avsedda för .xls-filer) och moderna namngivna eller anpassade pivottabellstilar (avsedda för .xlsx-, .xlsm- och .xlsb-filer). Vilket API du ska anropa beror på det filformat som arbetsboken sparas till, inte det format den lästes in från.

Introduktion

Aspose.Cells exponerar två parallella stil-API:er för pivottabeller. Valet mellan dem styrs av det filformat du sparar arbetsboken till, inte av det format du läser in den från. En arbetsbok som lästs in från en .xls-fil kan sparas om som .xlsx, och i det fallet gäller det moderna stil-API:t snarare än det äldre.

För äldre .xls-utdata använder du egenskapen PivotTable.AutoFormatType tillsammans med enumerationen Aspose.Cells.Pivot.PivotTableAutoFormatType. Detta API motsvarar den autoformatväljare som klassisk Excel erbjöd för pivottabeller.

För modern .xlsx-, .xlsm- och .xlsb-utdata finns två varianter av stil-API:t:

PivotTable.PivotTableStyleType väljer en av de inbyggda namngivna stilarna (ljust och mörkt tema, inklusive de stilar som lades till i Excel 2017). Dessa förinställningar är skrivskyddade.
PivotTable.PivotTableStyleName väljer en anpassad stil som du själv definierar via Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Anpassade stilar krävs när du vill ändra färger, kantlinjer eller teckensnitt utöver vad förinställningarna erbjuder.

Dessutom är PivotTable.FormatAll(Style) en genväg som tillämpar ett enda Style-objekt på varje cell i pivottabellen och åsidosätter det som har ställts in via någon av ovanstående stilnamns-API:er. Detta är användbart när ett enhetligt utseende krävs oavsett det underliggande temat.

Tillämpa ett äldre XLS-förinställt autoformat

PivotTable.AutoFormatType accepterar ett värde från enumerationen Aspose.Cells.Pivot.PivotTableAutoFormatType. De tillgängliga värdena är Report1 till Report10, Classic och Table1 till Table10.

AutoFormatType respekteras endast när arbetsboken sparas som .xls. När samma arbetsbok sparas som .xlsx, .xlsm eller .xlsb ignorerar Excel den här egenskapen och faller tillbaka på inställningarna PivotTableStyleType och PivotTableStyleName.

Följande exempel laddar en ny arbetsbok, fyller i exempeldata för Fruit/Year/Amount, lägger till en pivottabell, tillämpar PivotTableAutoFormatType.Report5 och sparar resultatet som .xls.

Varför inga kolumnfält? Autoformaten i Report-serien (Report1 till Report10, Table1 till Table10) designades i klassiska Excel för endimensionella pivottabeller med endast radfält och värden — de har ingen inbyggd formatering för kolumnfält-rubriker. Om din pivottabell behöver kolumnfält, använd de moderna PivotTableStyleType-förinställningarna från Scenario 2 nedan istället, som är designade för den tvådimensionella layout som moderna Excel använder.

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

// Scenario 1: Tillämpa ett äldre XLS-förinställt automatiskt format
// API in use: PivotTable.AutoFormatType
// Target file format: .xls (legacy)
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Create a new workbook
Workbook workbook = new Workbook();

// Get the first worksheet
Worksheet sheet = workbook.Worksheets[0];

// Populate the source data with header row (Fruit, Year, Amount)
// and 9 data rows covering grape, blueberry, kiwi, cherry across 2020 and 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);

// Add a pivot table at destination cell E3, named "Pivot1", using source range A1:C10
int pivotIndex = sheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Assign fields: Fruit -> Rows, Year -> Columns, Amount -> Data
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Apply the legacy XLS preset autoformat "Report5"
// Note: This property is only meaningful when saving as .xls.
// When saved as .xlsx/.xlsm/.xlsb, Excel ignores AutoFormatType
// and uses whatever PivotTableStyleType / PivotTableStyleName specifies.
pivotTable.AutoFormatType = PivotTableAutoFormatType.Report5;

// Save the workbook in legacy .xls format
workbook.Save("output.xls");

Tillämpa en modern namngiven förinställd pivottabellstil

PivotTable.PivotTableStyleType accepterar ett värde från enumerationen Aspose.Cells.PivotTableStyleType. Enumerationen täcker ljusa teman PivotTableStyleLight1 till PivotTableStyleLight28 och mörka teman PivotTableStyleDark1 till PivotTableStyleDark28. Stilarna som lades till i Excel 2017 (den andra omgången av ljusa och mörka teman) kan nås via samma enumeration.

Detta är det rekommenderade API:t för alla moderna filformat. Till skillnad från det äldre autoformatet återges stilen som väljs här troget av Excel och överlever rundresor genom andra Office-verktyg.

Följande exempel använder samma Fruit/Year/Amount-data, skapar en identisk pivottabell, tillämpar PivotTableStyleDark1 och sparar arbetsboken som .xlsx.

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

// Scenario 2: Tillämpa en modern Excel 2007+ namngiven förinställd stil med PivotTableStyleType.
// Målfilformat: .xlsx. PivotTableStyleType-uppräkningen finns i Aspose.Cells-namnrymden
// (inte i Aspose.Cells.Pivot) — det är därför vi inte behöver någon extra using för den.
// GitHub-referens: 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];

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

// 9 datarader med 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);

// Lägg till en pivottabell vid E3 med namnet "Pivot1", med källa från A1:C10
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Tilldela pivotfält: Fruit -> Radområde, Year -> Kolumnområde, Amount -> Dataområde
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Tillämpa en modern Excel 2007+ namngiven förinställd pivotstil.
// PivotTableStyleType är det korrekta API:et för .xlsx / .xlsm / .xlsb-filer; AutoFormatType
// ignoreras av Excel för dessa format. PivotTableStyleDark1 tillhör den mörka temafamiljen
// (PivotTableStyleDark1..PivotTableStyleDark28), och samma uppräkning exponerar också de
// nyare Excel 2017 ljus/mörk-teman (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.PivotTableStyleType = PivotTableStyleType.PivotTableStyleDark1;

// Spara som modern .xlsx — detta är formatet för vilket PivotTableStyleType är meningsfullt.
workbook.Save("output.xlsx");

Definiera och tillämpa en anpassad pivottabellstil

De inbyggda förinställningarna kan inte modifieras. När du behöver åsidosätta färger, kantlinjer eller teckensnitt måste du definiera en anpassad pivotstil. Arbetsflödet har tre steg:

Lägg till en anpassad stil i arbetsbokens TableStyles-samling via Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name). Detta returnerar indexet för den nyskapade stilen.
Konfigurera stilen genom att lägga till element (t.ex. WholeTable eller GrandTotalRow) via TableStyle.TableStyleElements.Add(TableStyleElementType), och tilldela sedan en Style till varje element via TableStyleElement.SetElementStyle(Style).
Tillämpa den anpassade stilen på pivottabellen genom att sätta PivotTable.PivotTableStyleName till stilens namn. Använd inte PivotTableStyleType här, eftersom den egenskapen väljer inbyggda förinställningar.

PivotTableStyleName och PivotTableStyleType är inte utbytbara. Använd PivotTableStyleType för inbyggda förinställningar, och PivotTableStyleName för anpassade stilar som du har definierat via AddPivotTableStyle. Att sätta båda är ofarligt, men det är bara den som matchar den avsedda källan som återges.

De tillgängliga TableStyleElementType-värdena inkluderar WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels och PageFieldValues.

Följande exempel definierar en anpassad pivotstil med en tunn svart kantlinje på WholeTable och ett fetstilt rött teckensnitt på GrandTotalRow, och tillämpar den sedan via PivotTableStyleName och sparar som .xlsx.

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

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

// Populera källdata: rubrikrad + 9 datarader (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);

// Lägg till pivottabell med källa från A1:C10, förankrad vid E3, namngiven "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");

// Steg 1: registrera en ny anpassad pivottabellstil och fånga dess index
int styleIndex = workbook.Worksheets.TableStyles.AddPivotTableStyle("CustomPivotStyle");
TableStyle tableStyle = workbook.Worksheets.TableStyles[styleIndex];

// Steg 2: lägg till ett WholeTable-element och tillämpa tunna svarta kanter på alla fyra sidor
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);

// Steg 3: lägg till ett GrandTotalRow-element och tillämpa fet röd teckensnitt
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);

// Steg 4: tillämpa den anpassade stilen efter namn (INTE efter PivotTableStyleType, vilket är för inbyggda förinställningar)
pivotTable.PivotTableStyleName = "CustomPivotStyle";

workbook.Save("output.xlsx");

Tillämpa en stil på varje pivotcell med FormatAll

PivotTable.FormatAll(Style) är en genväg som tillämpar ett enda Style-objekt på varje cell i pivottabellen, inklusive dataområdet, rad- och kolumnrubriker samt summor. Det som tidigare ställts in via PivotTableStyleType eller PivotTableStyleName åsidosätts.

FormatAll åsidosätter både PivotTableStyleType och PivotTableStyleName. Använd det endast när ett enhetligt, temaoberoende utseende krävs över hela pivottabellen.

Följande exempel skapar en Style med gul solid fyllning, ett fetstilt mörkblått teckensnitt och tunna svarta kantlinjer på alla sidor, och tillämpar den sedan med FormatAll och sparar som .xlsx.

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

// Scenario 4: Tillämpa en enda Stil på varje pivottabellcell med FormatAll
// API som används: PivotTable.FormatAll(Style)
// Målformat: .xlsx
// GitHub-referens: se Aspose.Cells-for-.NET repository — pivottabellformateringsexempel

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

// Fylla källdata: rubrikrad (rad 1) + 9 datarader (raderna 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);

// Lägg till pivottabell: källområde A1:C10, målcell E3, namn "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Tilldela pivotfält: Fruit -> Rad-område, Year -> Kolumn-område, Amount -> Data-område
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Bygg en Stil som tvingas på varje cell i pivottabellen
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;

// Tillämpa FormatAll: tvingar denna enda stil på varje cell i pivottabellen,
// och åsidosätter alla PivotTableStyleType / PivotTableStyleName som tidigare ställts in
pivotTable.FormatAll(style);

// Spara arbetsboken i det moderna .xlsx-formatet
workbook.Save("output.xlsx");

Vilket stil-API ska jag använda?

Valet av stil-API beror på det filformat du sparar till. Använd tabellen nedan som en snabbreferens.

Målfilformat	API att använda	Anteckningar
`.xls` (äldre)	`PivotTable.AutoFormatType`	Värden från `Aspose.Cells.Pivot.PivotTableAutoFormatType` (t.ex. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Ignoreras vid sparning som moderna format.
`.xlsx` / `.xlsm` / `.xlsb` (modern, inbyggd stil)	`PivotTable.PivotTableStyleType`	Värden från `Aspose.Cells.PivotTableStyleType` (ljust/mörkt tema, inklusive tillägg från Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (modern, anpassad stil)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	Använd när de inbyggda förinställningarna inte räcker. Konfigurera via `TableStyleElement.SetElementStyle(...)`.
Valfritt format (enhetlig åsidosättning)	`PivotTable.FormatAll(Style)`	Genväg som åsidosätter alla andra stilinställningar över hela pivottabellen.

Vid tveksamhet, spara som .xlsx och använd PivotTableStyleType för inbyggda teman, eller PivotTableStyleName för anpassade teman.

Net: Uppdatera pivottabeller och pivotcacheminnen i Aspose.Cells för .NET

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

Aspose.Cells tillhandahåller ett lagerbaserat uppdaterings-API som låter dig läsa in pivotdata igen på fyra olika omfång — från hela arbetsboken ner till en enskild pivottabell. Från och med Aspose.Cells for .NET v26.7 är den äldre metoden PivotTable.RefreshData() markerad som föråldrad och bör ersättas med de mer effektiva, cache-medvetna API:er som beskrivs i den här artikeln.

Introduktion

Att uppdatera en pivottabell är sällan en enskild operation. Bakom kulisserna upprätthåller Aspose.Cells en lagerbaserad datakedja som kopplar samman dina ursprungliga källdata med de renderade värden du ser i kalkylbladet. Att förstå denna kedja är nyckeln till att välja rätt uppdaterings-API för varje situation.

Den fyra lager djupa datakedjan är:

Datakälla — de ursprungliga kalkylbladens intervall, databasfråga eller konsolideringsintervall där de råa värdena finns.
PivotCache — ögonblicksbilden i minnet av källdatan. Varje pivottabell är byggd ovanpå en PivotCache; det är här all data samlas in och aggregeras.
PivotTable — vyn som definierar rad-, kolumn-, värde- och filterfält. En PivotTable läser endast från sin PivotCache, aldrig direkt från datakällan.
Cells — kalkylbladets Cells som PivotTable renderar sina beräknade värden och stilar till.

Ett särskilt viktigt koncept är den delade cachen. När flera pivottabeller i en arbetsbok refererar till samma källintervall delar de en PivotCache-instans. En enskild PivotCache kan refereras av många pivottabeller, och att uppdatera den cachen uppdaterar varje beroende PivotTable på en gång.

PivotCache.SourceType (enum PivotTableSourceType) anger var cachedatan kom ifrån. Från och med v26.7 stöder PivotCache.Refresh() endast källtyperna Sheet och Consolidation — det vill säga data som finns i kalkylbladens intervall. Externa källor (databaser, externa anslutningar etc.) är ännu inte möjliga att uppdatera via cache-API:et.

På grund av denna kedja finns det två grundläggande uppdateringsvägar i Aspose.Cells:

PivotCache.Refresh() — läser in källan → cache igen OCH beräknar om alla beroende PivotTables i en enda operation.
PivotTable.CalculateData() — beräknar om en PivotTables visning från redan cachad data, utan att gå tillbaka till datakällan.

Alla scenarier i den här artikeln använder kalkylbladsceller som källdata, så källtypen är Sheet och uppdateringsoperationerna beter sig enligt beskrivningen.

Nödvändiga Using-direktiv

Alla C#-exempel i den här artikeln börjar med följande tre using-direktiv eftersom pivottyperna ligger i namnrymden Aspose.Cells.Pivot:

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

Uppdatera alla pivottabeller i arbetsboken

När du behöver säkerställa att varje pivotcache och varje pivottabell i arbetsboken återspeglar den senaste källdatan är det enklaste och mest heltäckande API:et Workbook.RefreshAll(). Ett enda anrop traverserar hela arbetsboken — varje PivotCache uppdateras från sin källa och sedan beräknas varje beroende PivotTable om. Detta är den rekommenderade metoden för allmänna, dokumentövergripande uppdateringar där prestanda inte är ett problem.

Följande exempel bygger en arbetsbok med ett Fruit/Year/Amount-källintervall, skapar en pivottabell, ändrar några källvärden och använder sedan RefreshAll() för att uppdatera allt i ett enda anrop.

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

// Skapa en ny arbetsbok
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Skriv rubrikrad i cellerna A1:C1
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Skriv datarader i cellerna A2:C9 (8 rader med fruktdata för 2020 och 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);

// Lägg till en pivottabell: källområde "A1:C9", målcell "E3", namn "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Tilldela pivotfält: Fruit till Rader, Year till Kolumner, Amount till Data
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Ändra flera Amount-värden i källdatan för att simulera ändringar
worksheet.Cells["C2"].PutValue(55);
worksheet.Cells["C5"].PutValue(85);
worksheet.Cells["C9"].PutValue(125);

// Uppdatera alla pivottabeller / pivotcachar i arbetsboken
workbook.RefreshAll();

// Spara arbetsboken
workbook.Save("output.xlsx");

Uppdatera alla pivottabeller på ett enskilt kalkylblad

Ibland behöver du bara uppdatera de pivottabeller som finns på ett specifikt kalkylblad — till exempel när pivottabeller på andra kalkylblad är kända för att vara orelaterade och inte bör röras. För detta fall tillhandahåller Aspose.Cells Worksheet.RefreshPivotTables(), som är begränsat till en enskild Worksheet-instans.

Detta är mer selektivt än Workbook.RefreshAll(): endast pivottabellerna på det riktade kalkylbladet uppdateras, medan pivottabeller på andra kalkylblad förblir orörda.

Följande exempel fyller i samma Fruit/Year/Amount-källdata, lägger till en pivottabell på det första kalkylbladet, ändrar några källvärden och uppdaterar sedan endast pivottabellerna på det kalkylbladet.

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

Uppdatera en enskild pivottabell

När du vill ha finkornig kontroll över en enskild pivottabell ger det cachebaserade API:et dig två alternativ. Valet mellan dem beror på vad som faktiskt har ändrats: underliggande källdata eller bara vy-/layoutinställningarna för själva pivottabellen.

Källdata har ändrats — Använd `PivotCache.Refresh()`

Om den underliggande källdatan har ändrats är rätt startpunkt pivotTable.PivotCache.Refresh(). Detta anrop läser om källdatan in i cachen och beräknar sedan om varje PivotTable som är beroende av den cachen.

Eftersom pivottabeller delar en enda PivotCache-instans beräknar ett anrop till PivotCache.Refresh() om alla pivottabeller som är byggda på samma cache — inte bara den du refererar till. Om två pivottabeller delar samma källintervall uppdaterar ett anrop till en cache båda.

Följande exempel skapar två pivottabeller på samma källintervall för att demonstrera detta delade cache-beteende, ändrar några källvärden och uppdaterar sedan genom en cachereferens.

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

// Skapa en ny arbetsbok och hämta det första kalkylbladet
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Skriv rubrikrad: Frukt / År / Belopp
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Skriv ungefär 9 datarader (druva / blåbär / kiwi / körsbär över 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);

// Lägg till den första pivottabellen "Pivot1" förankrad vid cell E3, källområde A1:C9
int pivotIndex1 = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable1 = worksheet.PivotTables[pivotIndex1];

// Tilldela fält för Pivot1
pivotTable1.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable1.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable1.AddFieldToArea(PivotFieldType.Data, "Amount");

// Lägg till en ANDRA pivottabell "Pivot2" förankrad vid E15 med SAMMA källområde A1:C9
// Både Pivot1 och Pivot2 delar en enda PivotCache eftersom källområdet är identiskt.
int pivotIndex2 = worksheet.PivotTables.Add("A1:C9", "E15", "Pivot2");
PivotTable pivotTable2 = worksheet.PivotTables[pivotIndex2];

// Tilldela samma fält för Pivot2
pivotTable2.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable2.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable2.AddFieldToArea(PivotFieldType.Data, "Amount");

// Ändra flera cellvärden för Belopp i källdatan för att simulera en dataändring
worksheet.Cells["C2"].PutValue(150);
worksheet.Cells["C4"].PutValue(350);
worksheet.Cells["C7"].PutValue(650);

// Uppdatera den delade PivotCache.
// Eftersom Pivot1 och Pivot2 delar samma PivotCache, uppdaterar detta enda anrop
// BÅDA pivottabellerna (data + stil) från den uppdaterade källan.
pivotTable1.PivotCache.Refresh();

// Spara arbetsboken
workbook.Save("output.xlsx");

Endast vy/layout har ändrats — Använd `CalculateData()`

Om källdatan inte har ändrats men bara pivottabellens vy- eller layoutinställningar har modifierats (till exempel har ett fält flyttats till ett annat område, eller en inställning för uppdatering-vid-öppning har växlats), finns det ingen anledning att gå tillbaka till datakällan. Cachen innehåller redan rätt data; bara den renderade PivotTable behöver beräknas om. I detta fall är pivotTable.CalculateData() rätt val.

Detta undviker det onödiga källhämtandet och är avsevärt snabbare när många pivottabeller delar samma cache.

Följande exempel modifierar en icke-källrelaterad egenskap hos pivottabellen och anropar sedan CalculateData() för att rendera om den från den befintliga cachen.

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

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

// Skriv rubrikrad för Frukt / År / Belopp
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Skriv 8 datarader (raderna 2-9, som passar källintervallet 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);

// Lägg till en pivottabell med namnet "Pivot1" placerad i destinationscell E3, med källa från A1:C9
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.PivotTables[pivotIndex];

// Tilldela fält: Frukt till Rad, År till Kolumn, Belopp till Data
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Ändra en visnings-/layout-egenskap — detta är en presentationsändring,
// så den kräver INTE att källdatan läses igen via PivotCache.Refresh().
pivotTable.RefreshDataOnOpeningFile = false;

// CalculateData() renderar om DEN HÄ pivottabellens visning (data + stil) från den
// data som redan finns i PivotCache. Eftersom källdatan inte ändrades,
// utförs ingen tur och retur till källan — endast de cachelagrade värdena beräknas om
// till arbetsbladsceller.
pivotTable.CalculateData();

// Spara arbetsboken till disk
workbook.Save("output.xlsx");

Hämta alla pivottabeller som delar samma PivotCache

En arbetsbok innehåller ofta många pivottabeller som alla ligger ovanpå en delad cache. För att räkna upp dem — till exempel innan en batchuppdatering utförs, eller för att diagnostisera påverkan av delad cache — använd PivotCache.GetPivotTables(). Denna metod returnerar samlingen av varje PivotTable som är beroende av den givna cachen.

Detta är också det mest direkta sättet att bekräfta att två pivottabeller verkligen delar samma PivotCache-instans: du kan jämföra cachereferenser, eller helt enkelt iterera genom samlingen som returneras av GetPivotTables() och observera vilka pivottabeller som finns i den.

Följande exempel skapar två pivottabeller på samma källintervall, verifierar att de delar samma cache-instans och räknar sedan upp cachens pivottabeller.

Migrera från den föråldrade `PivotTable.RefreshData()`

Före Aspose.Cells for .NET v26.7 var standardsättet att uppdatera en pivottabell att anropa PivotTable.RefreshData() på varje pivottabell individuellt. Från och med v26.7 är den metoden markerad som föråldrad och bör ersättas med de cache-medvetna API:er som beskrivs ovan.

Det finns två anledningar till att metoden RefreshData() per tabell är problematisk i verkliga arbetsböcker:

Den hämtar data från källan varje gång den anropas, även när källan inte har ändrats.
Varje anrop uppdaterar hela den delade cachen. När många pivottabeller delar en cache innebär upprepade anrop till RefreshData() per pivottabell att samma cache hämtas om och om igen, vilket är mycket långsamt.

De rekommenderade ersättningarna är:

Uppdatera ALLA pivottabeller i arbetsboken → använd workbook.RefreshAll();
Uppdatera NÅGRA av dem → använd pivotTable.PivotCache.Refresh(); för en cache. Eftersom cachen delas uppdaterar detta enda anrop varje pivottabell som är byggd ovanpå den cachen. Andra pivottabeller som ligger på en redan uppdaterad cache kan säkert hoppas över.
Endast pivotvyn/layouten har ändrats → använd pivotTable.CalculateData(); för att rendera om från den befintliga cachen utan någon källhämtning.

Följande exempel demonstrerar det nya effektiva mönstret för arbetsböcker med flera pivottabeller som delar en enda cache.

Vilket uppdaterings-API ska jag använda?

Tabellen nedan sammanfattar de tillgängliga uppdaterings-API:erna och när du ska välja var och en av dem.

Mål	Rekommenderat API	Anteckningar
Uppdatera allt i arbetsboken	`Workbook.RefreshAll()`	Ett anrop; täcker alla cacheminnen och tabeller.
Uppdatera endast pivottabeller på ett enskilt blad	`Worksheet.RefreshPivotTables()`	Begränsat till ett kalkylblad.
Källdata har ändrats för en cache	`pivotTable.PivotCache.Refresh()`	Uppdaterar ALLA pivottabeller på den delade cachen.
Endast vy-/layoutinställningar har ändrats	`pivotTable.CalculateData()`	Hoppar över onödig källhämtning.
Lista alla pivottabeller på en delad cache	`pivotCache.GetPivotTables()`	Använd för att räkna upp före massuppdatering.

I praktiken bör du föredra de cachebaserade API:erna framför den föråldrade RefreshData() per tabell. De är medvetna om delade cacheminnen, de undviker redundanta källhämtningar, och de låter dig välja det minsta omfånget som uppfyller ditt uppdateringskrav.

Net: Lägga till rad- och kolumnfält i en pivottabell i Aspose.Cells för .NET

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

Lägga till ett fält i rad- eller kolumnregionen

Metoden PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) flyttar ett basfält från källdatan till en av de fyra pivotregionerna. Argumentet fieldType accepterar ett av följande PivotFieldType-värden.

Row — fält som placeras vertikalt till vänster
Column — fält som placeras horisontellt överst
Data — fält vars värden aggregeras
Page — fält som används som rapportfilter

När fälten har lagts till kan du komma åt dem via egenskaperna PivotTable.RowFields och PivotTable.ColumnFields. Varje egenskap returnerar en PivotFieldCollection. Fältet på index 0 i RowFields är det yttersta radfältet, och efterföljande index representerar fält som är nästlade inuti det. Samma indexeringskonvention gäller för ColumnFields.

Ordningen på fältnästningen är viktig. Att lägga till Category i radregionen först och sedan Item skapar en pivot vars yttre gruppering är Category och vars inre gruppering är Item. Om du vänder på ordningen vänds hierarkin.

Pivotfältets delsummor

Metoden PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) styr vilka delsummarader som visas för ett pivotfält. Varje anrop växlar en enskild delsummatyp oberoende. Genom att skicka shown = true visas delsummaraden, medan shown = false döljer den. Eftersom varje anrop endast påverkar en typ, bygger upprepade anrop med olika subtotalType-värden en anpassad delmängd av delsummor.

Enumen PivotFieldSubtotalType definierar de tillgängliga delsummatyperna.

Automatic — Aspose.Cells väljer standardvalet (vanligtvis Sum för numeriska fält)
None — undertrycker varje delsummarad
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

Delsummor renderas endast när det finns två eller fler pivotfält i radregionen (eller i kolumnregionen). Ett enskilt fält har inget meningsfullt att subtotala mellan, så SetSubtotals-anrop har ingen synlig effekt i det fallet. Den här artikeln placerar därför två radfält (Category yttre, Item inre) i varje exempel så att delsummegränsen mellan varje Category-grupp syns.

Scenario 1 — Automatiska (standard) delsummor

När du inte anropar SetSubtotals alls tillämpar Aspose.Cells valet Automatic på numeriska fält. Följande exempel bekräftar uttryckligen detta beteende genom att anropa SetSubtotals(PivotFieldSubtotalType.Automatic, true) på det yttre Category-radfältet.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pivotTable.CalculateData();

workbook.Save("output_automatic.xlsx");

Scenario 2 — Undertrycka alla delsummor (None)

Att anropa SetSubtotals(PivotFieldSubtotalType.None, true) tar bort varje delsummarad från pivottabellen och lämnar bara fältraderna och totalsumman längst ner. Detta är användbart när du vill ha den råa grupperade datan utan några sammanfattningsrader.

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

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

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

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

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

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

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

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

workbook.Save("output_none.xlsx");

Scenario 3 — Anpassad delsummaundergrupp (Sum + Average)

Du är inte begränsad till en enda delsummatyp. Varje SetSubtotals-anrop verkar oberoende på en typ, så att anropa metoden två gånger — en gång med Sum och en gång med Average — skapar en anpassad delmängd av två delsummarader för varje Category-grupp.

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

Sammanfattning

De tre scenarierna ovan delar samma dataset och pivottabellstruktur. Den enda skillnaden mellan dem är SetSubtotals-anropet som tillämpas på det yttre Category-radfältet. Kom ihåg tvåfältsregeln: ett enskilt fält i en region har inget att subtotala mellan, så placera alltid minst två fält i rad- eller kolumnregionen när du vill att SetSubtotals ska ha en synlig effekt.

Net: Hantera värdefält i en pivottabell i Aspose.Cells för .NET

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

Lägga till ett fält i dataområdet

Att lägga till ett basfält i data- (värde-) området är det första steget för att forma hur en pivottabell aggregerar dina källdata. Aspose.Cells exponerar PivotTable.AddFieldToArea(PivotFieldType, string), en överlagring som accepterar konstanten PivotFieldType.Data och källkolonnens namn. När ett fält har lagts till i dataområdet exponerar API:et det genom samlingen PivotTable.DataFields, i den ordning som fälten lades till. Som standard sammanfattas en numerisk källkolumn med ConsolidationFunction.Sum, medan en icke-numerisk kolumn som standard blir Count.

.Cells;
using Aspose.Cells.Pivot;

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

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

// Datarader A2:D9 med kapslade slingor som förgrenar sig på j
for (int i = 1; i <= 8; i++)
{
 for (int j = 0; j < 4; j++)
 {
 switch (j)
 {
 case 0:
 worksheet.Cells[i, j].PutValue(i <= 4 ? "Fruit" : "Vegetable");
 break;
 case 1:
 if (i == 1 || i == 2) worksheet.Cells[i, j].PutValue("Apple");
 else if (i == 3 || i == 4) worksheet.Cells[i, j].PutValue("Banana");
 else if (i == 5 || i == 6) worksheet.Cells[i, j].PutValue("Carrot");
 else worksheet.Cells[i, j].PutValue("Daikon");
 break;
 case 2:
 worksheet.Cells[i, j].PutValue(2020 + ((i - 1) % 2));
 break;
 case 3:
 if (i == 1) worksheet.Cells[i, j].PutValue(100);
 else if (i == 2) worksheet.Cells[i, j].PutValue(150);
 else if (i == 3) worksheet.Cells[i, j].PutValue(80);
 else if (i == 4) worksheet.Cells[i, j].PutValue(90);
 else if (i == 5) worksheet.Cells[i, j].PutValue(50);
 else if (i == 6) worksheet.Cells[i, j].PutValue(60);
 else if (i == 7) worksheet.Cells[i, j].PutValue(40);
 else worksheet.Cells[i, j].PutValue(45);
 break;
 }
 }
}

// Lägg till pivottabell vid F3 med namnet PivotTable1
int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Pivotlayout: Category och Item på Row, Year på Column, Amount som datafält
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");

Ändra summeringsfunktionen

Varje fält som placeras i dataområdet kapslas internt in som en PivotField-instans, och dess egenskap Function returnerar ett värde från enumereringen ConsolidationFunction. Samma Function-setter låter dig växla mellan de tillgängliga aggregaten, inklusive Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var och Varp.

Att ändra Function påverkar endast aggregatet, källkolumnen ändras inte.

Du kan därför låta ett datafält vara Sum medan du lägger till ett andra datafält som riktar sig mot samma källkolumn men använder Count eller Average, allt i en enda pivot.

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

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

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

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

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

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

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

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

pivotTable.CalculateData();

workbook.Save("output_function.xlsx");

Visa värdefält på rad- eller kolumnaxeln

När en pivottabell innehåller två eller flera datafält, exponerar Aspose.Cells ytterligare ett virtuellt fält som kallas PivotTable.ValuesField. Detta virtuella fält representerar aggregatet av varje datafält som finns i dataområdet. Du kan dra det till rad- eller kolumnområdet som ett baspivotfält, vilket är användbart för att lägga ut flera mått sida vid sida.

PivotTable.ValuesField fungerar inte om det inte finns något eller bara ett värdefält.

Scenarierna nedan går igenom tre kompletta exempel som demonstrerar varje funktion som beskrivs ovan mot samma pivotstruktur.

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: Lägga till filterfält i en pivottabell i Aspose.Cells för .NET

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

Aspose.Cells stöder hela livscykeln för filterfält i pivottabeller. Du kan lägga till ett filterfält via ett högnivå-API eller via den lägre nivåns PageFields-samling, och du kan styra sidfiltret i enkelvalsläge, rensa det för att visa varje sidobjekt, eller växla fältet till flerval så att användare kan välja flera sidobjekt samtidigt via kryssrutogränssnittet i Excel.

Introduktion

Ett filterfält är ett pivotfält som styr vilken delmängd av källdatan pivottabellkroppen visar. Slutanvändare ser det som en rullgardinsmeny överst i en renderad pivottabell i Excel, och att välja ett av de tillgängliga sidobjekten bygger om pivottabellkroppen så att endast de poster som tillhör det sidobjektet sammanfattas. Ett pivotfält blir ett filterfält när det registreras som PivotFieldType.Page istället för PivotFieldType.Row, PivotFieldType.Column eller PivotFieldType.Data.

Ett filterfält kan fungera i två beteenden. I standardbeteendet enkelval är endast ett sidobjekt synligt åt gången, så pivottabellkroppen sammanfattar exakt en delmängd. I beteendet flerval exponerar fältet en kryssrutelista, och pivottabellkroppen sammanfattar unionen av alla ikryssade sidobjekt. Samma källfält kan flyttas fram och tillbaka mellan dessa beteenden genom att växla en enskild egenskap.

Aspose.Cells for .NET exponerar två likvärdiga sätt att registrera ett filterfält. Det högnivå-API:t är PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName"), som tar källkolumnnamnet och lägger till fältet i ett enda anrop. Det lägre nivå-API:t är PivotTable.PageFields.Add(PivotField), som används när du redan har en PivotField-referens och vill lägga till samma fältinstans i filterområdet. Båda API:erna slutar med att fylla samma PageFields-samling, och resten av denna artikel visar hur du väljer mellan dem och hur du styr varje filtreringsläge.

Lägga till ett filterfält

Det finns två sätt att registrera ett pivotfält i filterområdet. Det högnivåanropet tar källkolumnnamnet som en sträng och är den vanligaste vägen. Det lägre nivåanropet accepterar en befintlig PivotField-instans och är bekvämt när samma fältobjekt måste återanvändas över flera pivotområden. Båda anropen placerar fältet i PivotTable.PageFields, varefter det visas som sidans rullgardinsmeny överst i den renderade pivottabellen.

Lägga till ett filterfält med AddFieldToArea

Följande exempel bygger ett litet Fruit / Year / Amount-dataset, placerar en pivottabell vid cell E3 med Fruit på radområdet, Amount på dataområdet och Year på filterområdet, uppdaterar pivottabellen och sparar arbetsboken.

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

// Skapa en ny arbetsbok
var workbook = new Workbook();
var worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

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

// Fyll i 9 rader med exempeldata: Frukt, År, Belopp
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]);
}

// Lägg till en pivottabell förankrad vid cell E3
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Lägg till fält i deras områden: Frukt som Rad, Belopp som Data, År som Sidfält
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Uppdatera och beräkna pivottabellens data
pivotTable.CalculateData();

// Spara arbetsboken
workbook.Save("pageFieldSample.xlsx");

Lägga till ett filterfält med PageFields.Add

När du redan arbetar med en PivotField-instans kan du skicka den direkt till PivotTable.PageFields.Add. Pivottabellen och filterfältet konstrueras exakt som i föregående scenario; endast den slutliga registreringen i filterområdet ersätts med anropet på lägre nivå.

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

// — Pivottabellen och sidfältet konstrueras exakt som i
//   Scenario 1a (Frukt/År/Belopp-data, pivot vid E3, Frukt→Rad,
//   Belopp→Data). Nedan hämtar vi År-PivotField från
//   BaseFields-samlingen och skickar den till PageFields.Add — det
//   lågnivåalternativet till AddFieldToArea. Resultatet är
//   funktionellt identiskt med Scenario 1a.

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

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

// Exempeldata (9 rader)
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);

// Lägg till pivottabell vid E3 som täcker A1:C10
int pivotIndex = sheet.PivotTables.Add("E3", "A1:C10", "PivotTable1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Frukt -> Rad, Belopp -> Data (År kommer att gå till Sida nedan)
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Lågnivåmetod: hämta den befintliga År-PivotField från BaseFields
// och registrera den i Sid-området via PageFields.Add(PivotField).
PivotField yearField = pivotTable.BaseFields["Year"];
pivotTable.PageFields.Add(yearField);

// Uppdatera så att det nya sidfältet återspeglas i den sparade arbetsboken
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Enkelvalsfiltrering (visa ett sidobjekt)

I standardbeteendet enkelval renderas filterfältet som en enda rullgardinsmeny och heltalet PivotField.CurrentPageItem väljer vilket sidobjekt som styr pivottabellkroppen. Att tilldela ett specifikt index väljer det specifika objektet; att tilldela det speciella sentinelvärdet 0x7FFD (decimalt 32765) rensar filtret så att varje sidobjekt sammanfattas på en gång. Enkelval är standardinställningen; du behöver inte aktivera det uttryckligen.

Visa alla objekt

Att sätta CurrentPageItem till det magiska värdet 0x7FFD är likvärdigt med att rensa sidfiltret: pivottabellkroppen sammanfattar varje sidobjekt som om inget filter tillämpades.

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

class Program
{
    static void Main()
    {
        // Skapa en ny arbetsbok
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];

        // Fylla i data för Frukt/År/Belopp
        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]);
            }
        }

        // Skapa pivottabell vid E3
        var pivotTables = sheet.PivotTables;
        int index = pivotTables.Add("=A1:C7", "E3", "PivotTable1");
        PivotTable pivotTable = pivotTables[index];

        // Konfigurera pivotfält: Frukt→Rad, Belopp→Data, År→Sida
        pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
        pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
        pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

        pivotTable.CalculateData();

        // Rensa sidfiltret så att alla objekt i sidfältet syns.
        // 0x7FFD (decimal 32765) är det speciella sentinelvärdet som betyder "alla objekt" —
        // motsvarande att välja "(Alla)" i Excels sidfält-rullmeny.
        pivotTable.PageFields[0].CurrentPageItem = 0x7FFD;

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

Visa ett specifikt objekt

Att sätta CurrentPageItem till ett verkligt index väljer bara det ena sidobjektet. Indexet är positionen för objektet i filterfältets sorterade objektlista, så till exempel 1 väljer det andra objektet efter sortering.

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

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

// Lägg till exempeldata (Frukt/År/Belopp)
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");

// Lägg till pivottabell vid E3
var pivotTables = sheet.PivotTables;
int pivotIndex = pivotTables.Add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables[pivotIndex];

// Lägg till fält: Frukt→Rad, Belopp→Data, År→Sida
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Sidfältsspecifika operationer
pivotTable.PageFields[0].CurrentPageItem = 1; // 1 = andra objektet i sorterad ordning (t.ex. "2021")

// Uppdatera och beräkna pivottabell
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Flervalsfiltrering

Flervalsfiltrering förvandlar sidans rullgardinsmeny till en kryssrutelista och låter slutanvändaren välja flera sidobjekt samtidigt. Aspose.Cells exponerar två egenskaper som fungerar tillsammans. PivotField.IsMultipleItemSelectionAllowed måste sättas till true innan flervalsgränssnittet överhuvudtaget får effekt. När det är aktiverat styr PivotItem.IsHidden vilka objekt som visas i kryssrutelistan, så du kan antingen visa varje objekt eller vitlista endast specifika objekt.

Koden nedan aktiverar flerval på samma Year-filterfält som byggdes i Scenario 1a, och visar sedan två mönster: Del A avslöjar varje sidobjekt genom att låta IsHidden vara satt till false för varje post, medan Del B vitlistar endast de källvärden du väljer och döljer allt annat via ett switch (pivotItems[i].GetStringValue())-block.

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

// — Pivottabellen och sidfältet konstrueras exakt som i
//   Scenario 1a (Fruit/Year/Amount-data, pivot vid E3, Fruit→Rad,
//   Amount→Data, Year→Sida via AddFieldToArea).
//   Nedan tillämpar vi flervalsfiltrering på sidfältet.

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

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

// — Aktivera flerval på sidfältet
pivotTable.PageFields[0].IsMultipleItemSelectionAllowed = true;

// Del A — välj ALLA objekt (gör varje objekt synligt)
PivotItemCollection pivotItems = pivotTable.PageFields[0].PivotItems;
for (int i = 0; i < pivotItems.Count; i++)
{
    pivotItems[i].IsHidden = false;
}

// Del B — välj endast specifika objekt efter källvärde
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");

Obs! När du använder flervalsfiltrering via PivotItem.IsHidden måste minst en PivotItem förbli synlig (IsHidden == false). Om varje objekt är dolt kraschar Excel antingen när filen öppnas eller renderar en tom pivottabell. Verifiera alltid att din flervalsvitlista innehåller minst ett objekt från din källdata.

Vilket API och vilket läge bör jag använda?

Tabellen nedan sammanfattar när du ska använda varje API och läge så att du kan välja rätt kombination utan att läsa varje scenario i detalj.

Scenario / användningsfall	Rekommenderat API	Använd egenskap	Anteckningar
Lägg till ett filterfält via källkolumnnamn (vanligast)	`PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName")`	n/a	Hög nivå, en rad. Använd detta om du inte behöver en `PivotField`-referens.
Lägg till ett filterfält när du redan har ett `PivotField`-objekt	`PivotTable.PageFields.Add(PivotField)`	n/a	Använd när fältobjektet erhölls på annan plats eller behöver återanvändas.
Filtrera till ett enskilt sidobjekt (standardläge)	`PivotField.CurrentPageItem`	sätt till ett specifikt index	Till exempel visar `1` det andra objektet i den sorterade listan.
Visa alla objekt / rensa sidfiltret	`PivotField.CurrentPageItem`	sätt till `0x7FFD`	Det magiska värdet `0x7FFD` (decimalt 32765) är sentinelvärdet för “alla objekt”.
Aktivera flervalsgränssnitt i Excel	`PivotField.IsMultipleItemSelectionAllowed`	sätt till `true`	Krävs innan några `IsHidden`-anrop får effekt.
Dölj / visa enskilda objekt i en flervalslista	`PivotItem.IsHidden`	sätt per objekt	Minst ett objekt måste förbli synligt (`IsHidden == false`).

Kom alltid ihåg synlighetsbegränsningen när du konfigurerar flervalsfiltrering. Om varje PivotItem i ett flervalsfilterfält är dolt kraschar Excel vid öppning eller renderar en tom pivottabell. Bygg din vitlista mot din källdata så att minst ett objekt förblir synligt, och dina sparade arbetsböcker kommer att öppnas tillförlitligt på varje maskin.

Net: Ta bort pivottabell från ett arbetsblad

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

Aspose.Cells tillhandahåller en funktion för att radera eller ta bort pivottabell från ett arbetsblad. Du kan ta bort pivottabellen med hjälp av pivottabellobjektet eller pivottabellens position. Använd Worksheet.PivotTables.Remove() -metoden för att ta bort pivottabellen med hjälp av pivottabellobjektet och Worksheet.PivotTables.RemoveAt() metoden för att ta bort pivottabellen med hjälp av dess position i pivottabellssamlingen.

Följande kodexempel tar bort två pivottabeller från arbetsbladet. Först tar det bort pivottabellen med hjälp av Worksheet.PivotTables.Remove() -metoden och sedan tar det bort pivottabellen med hjälp av Worksheet.PivotTables.RemoveAt() -metoden

Net: Spara pivottabell i ODS fil

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

Aspose.Cells ger möjlighet att spara pivottabell i ODS-filer. För detta konverterar du bara en arbetsbok med befintlig pivottabell eller skapar en ny pivottabell och sparar filen i ODS-format. Se till att använda PivotTable.CalculateData() innan du sparar för att säkerställa att pivottabellen renderas i utdata-ODS-filen. Följande kodsnutt demonstrerar sparande av pivottabell i ODS-fil.

Exempelkod

Utdatafilen som genererats av ovanstående kod är bifogad för din referens.

Utgångs-ODS-fil

Documentation – Infoga pivot tabell

Net: Formatera Pivot tabell

Pivottabellens utseende

Inställning av pivottabellformatalternativ

Inställning av autoformat typ

Inställning av formatalternativ

Manuell formatering av utseende

Inställning av pivottabellfältformatalternativ

Inställning av format för rad/kolumn/sidofältsformat

Inställning av format för datafält

Rensa pivottabellsfält

Net: Skapa pivottabeller och pivotdiagram

Lägg till Pivottabeller och Diagram

Förberedelser för att använda Aspose.Cells

Lägga till en pivottabell

Lägga till en PivotChart

Net: Pivot tabell och källdata

Pivot-tabellens källdata

Ändra en pivot-tabells källdata

Net: Lägg till beräknat fält i pivottabell

Möjliga användningsscenario

Lägg till beräknat fält i pivottabell i Excel

Lägg till beräknat fält i Pivot-tabell med C#

Exempelkod

Net: Tillämpa stilar på pivottabeller i Aspose.Cells för .NET

Introduktion

Tillämpa ett äldre XLS-förinställt autoformat

Tillämpa en modern namngiven förinställd pivottabellstil

Definiera och tillämpa en anpassad pivottabellstil

Tillämpa en stil på varje pivotcell med FormatAll

Vilket stil-API ska jag använda?

Net: Uppdatera pivottabeller och pivotcacheminnen i Aspose.Cells för .NET

Introduktion

Nödvändiga Using-direktiv

Uppdatera alla pivottabeller i arbetsboken

Uppdatera alla pivottabeller på ett enskilt kalkylblad

Uppdatera en enskild pivottabell

Källdata har ändrats — Använd PivotCache.Refresh()

Endast vy/layout har ändrats — Använd CalculateData()

Hämta alla pivottabeller som delar samma PivotCache

Migrera från den föråldrade PivotTable.RefreshData()

Vilket uppdaterings-API ska jag använda?

Net: Lägga till rad- och kolumnfält i en pivottabell i Aspose.Cells för .NET

Lägga till ett fält i rad- eller kolumnregionen

Pivotfältets delsummor

Scenario 1 — Automatiska (standard) delsummor

Scenario 2 — Undertrycka alla delsummor (None)

Scenario 3 — Anpassad delsummaundergrupp (Sum + Average)

Sammanfattning

Net: Hantera värdefält i en pivottabell i Aspose.Cells för .NET

Lägga till ett fält i dataområdet

Ändra summeringsfunktionen

Visa värdefält på rad- eller kolumnaxeln

Net: Lägga till filterfält i en pivottabell i Aspose.Cells för .NET

Introduktion

Lägga till ett filterfält

Lägga till ett filterfält med AddFieldToArea

Lägga till ett filterfält med PageFields.Add

Enkelvalsfiltrering (visa ett sidobjekt)

Visa alla objekt

Visa ett specifikt objekt

Flervalsfiltrering

Vilket API och vilket läge bör jag använda?

Net: Ta bort pivottabell från ett arbetsblad

Net: Spara pivottabell i ODS fil

Exempelkod

Källdata har ändrats — Använd `PivotCache.Refresh()`

Endast vy/layout har ändrats — Använd `CalculateData()`

Migrera från den föråldrade `PivotTable.RefreshData()`