Documentation – Insertar tabla dinámica

Net: Dar formato a la tabla dinámica

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

Apariencia de la tabla dinámica

Cómo crear una tabla dinámica explica cómo crear una tabla dinámica simple. Este artículo describe cómo personalizar la apariencia de una tabla dinámica estableciendo diversas propiedades:

Opciones de formato de tabla dinámica
Opciones de formato de campos de tabla dinámica
Opciones de formato de campos de datos

Configuración de opciones de formato de tabla dinámica

La clase PivotTable controla la tabla dinámica general y se puede formatear de varias maneras.

Establecer el tipo de autoformato

Microsoft Excel ofrece varios formatos de informe predefinidos. Aspose.Cells también admite estas opciones de formato. Para acceder a ellas:

Establezca PivotTable.IsAutoFormat en verdadero.
Asignar una opción de formato de la enumeración PivotTableAutoFormatType.

Configuración de opciones de formato

El ejemplo de código a continuación muestra cómo dar formato a la tabla dinámica para mostrar totales generales para filas y columnas, y cómo establecer el orden de los campos del informe. También muestra cómo establecer una cadena personalizada para los valores nulos.

Dar formato manualmente al aspecto visual

Para dar formato manualmente al informe de la tabla dinámica en lugar de usar formatos de informe preestablecidos, use los métodos PivotTable.Format() y PivotTable.FormatAll(). Cree un objeto de estilo para el formato deseado, por ejemplo:

Configuración de opciones de formato de campo de tabla dinámica

La clase PivotField representa un campo en una tabla dinámica y se puede formatear de varias formas. El ejemplo de código a continuación muestra cómo:

Acceder a los campos de fila.
Establecer subtotales.
Establecer orden automático.
Establecer autover.

Configuración de formato de campos de fila/columna/página

Configuración de formato de campos de datos

El ejemplo de código a continuación muestra cómo establecer formatos de visualización y formato numérico para los campos de datos.

Borrado de campos de tabla dinámica

La clase PivotFieldCollection tiene un método llamado Clear() que te permite borrar campos de tabla dinámica. Úsalo cuando quieras borrar todos los campos de tabla dinámica en las áreas, por ejemplo, página, columna, fila o datos. El ejemplo de código a continuación muestra cómo borrar todos los campos de tabla dinámica en un área de datos.

Net: Crear tablas dinámicas y gráficos dinámicos

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

Una tabla dinámica es un resumen interactivo de registros. Por ejemplo, puede tener cientos de entradas de factura en una lista en una hoja de cálculo. Una tabla dinámica puede totalizar las facturas por cliente, producto o fecha. Con Microsoft Excel es posible reorganizar rápidamente la información en la tabla dinámica arrastrando botones a una nueva posición.

Un gráfico dinámico es una representación gráfica interactiva de los datos en una tabla dinámica. Los gráficos dinámicos se introdujeron en Excel 2000. El uso de un gráfico dinámico facilita aún más la comprensión de los datos, ya que la tabla dinámica crea subtotales y totales automáticamente.

Aspose.Cells admite tablas dinámicas y gráficos dinámicos.

Añadiendo tablas dinámicas y gráficos

Aspose.Cells proporciona un conjunto especial de clases utilizadas para crear tablas dinámicas. Estas clases se utilizan para crear y configurar objetos PivotTable, que actúan como bloques de construcción básicos de un objeto PivotTable:

PivotField, un campo en un informe de tabla dinámica.
PivotFields, una colección de todos los objetos PivotField en una tabla dinámica.
PivotTable, un informe de tabla dinámica en una hoja de cálculo.
PivotTables, una colección de todos los objetos PivotTable en la hoja de cálculo.

Preparación para usar Aspose.Cells

Descargue e instale Aspose.Cells:
1. Descargar Aspose.Cells.
2. Instálelo en su equipo de desarrollo. Todos los componentes de Aspose, al ser instalados, funcionan en modo de evaluación. El modo de evaluación no tiene límite de tiempo y solo inserta marcas de agua en los documentos producidos. Para trabajar con el componente en su capacidad total, necesitas tener una licencia válida.
Cree un proyecto:
1. Inicia Visual Studio.Net.
2. Cree una nueva aplicación de consola.
Agregue referencias: Agrega una referencia al componente Aspose.Cells en tu proyecto, por ejemplo …\Program Files\Aspose\Aspose.Cells\Bin\Net1.0\Aspose.Cells.dll

Añadiendo una tabla dinámica

Para crear una tabla dinámica usando Aspose.Cells:

Agregue algunos datos a las celdas de una hoja de cálculo utilizando el método PutValue/setValue de un objeto Cell. También puede utilizar un archivo de plantilla ya lleno con datos. Los datos se utilizarán como origen de datos de la tabla dinámica.
Agregue una tabla dinámica a la hoja de cálculo llamando al método add de la colección PivotTables (encapsulada en el objeto Worksheet).
Accede al nuevo objeto PivotTable desde la colección PivotTables pasando su índice. # Usa cualquiera de los objetos de tabla dinámica encapsulados en el objeto PivotTable para gestionar la tabla.

A continuación se muestran ejemplos de código.

Añadiendo un gráfico dinámico

Para crear un gráfico dinámico usando Aspose.Cells:

Agregue un gráfico.
Establezca el PivotSource del gráfico para hacer referencia a una tabla dinámica existente en la hoja de cálculo.
Establezca otros atributos.

Net: Tabla dinámica y datos fuente

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

Datos fuente de la tabla dinámica

Hay momentos en los que deseas crear informes de Microsoft Excel con tablas dinámicas que toman datos de diferentes fuentes de datos (como una base de datos) que no se conocen en el momento del diseño. Este artículo proporciona un enfoque para cambiar dinámicamente la fuente de datos de una tabla dinámica.

Cambio de la fuente de datos de una tabla dinámica

Crear una nueva plantilla de diseño.
1. Crea un nuevo archivo de plantilla de diseñador como se muestra en la captura de pantalla a continuación.
2. Luego define un rango nombrado, DataSource, que se refiere a este rango de celdas.
  
  Creando una plantilla de diseñador y definiendo un rango nombrado, DataSource

Crear una tabla dinámica basada en este rango nombrado.
1. En Microsoft Excel, elige Datos, luego Tabla Dinámica y Informe de Tabla Dinámica.
2. Crear una tabla dinámica basada en el rango nombrado creado en el primer paso.
  
  Creando una tabla dinámica basada en el rango nombrado, DataSource

Arrastra el campo correspondiente a la fila y columna de la tabla dinámica, luego crea la tabla dinámica resultante como en la captura de pantalla a continuación.

Creando una tabla dinámica basada en un campo correspondiente

Haz clic derecho en la tabla dinámica y selecciona Opciones de Tabla.
1. Marca Actualizar al abrir en la configuración de Opciones de Datos.
  
  Configuración de las opciones de la tabla dinámica

Ahora, puedes guardar este archivo como tu archivo de plantilla de diseñador.

Poblar nuevos datos y cambiar la fuente de datos de una tabla dinámica.
1. Una vez que se haya creado la plantilla de diseñador, utiliza el siguiente código para cambiar la fuente de datos de la tabla dinámica.

La ejecución del código de ejemplo a continuación cambia los datos fuente de la tabla dinámica.

Net: Agregar campo calculado en tabla dinámica

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

Escenarios de uso posibles

Cuando crea una tabla dinámica basada en datos conocidos, se encuentra con que los datos no son los que desea. Los datos que desea es la combinación de estos datos originales. Por ejemplo, necesita sumar, restar, multiplicar y dividir los datos originales antes de querer los datos. En ese momento, necesita crear un campo calculado y establecer la fórmula correspondiente para el cálculo. Luego realizar algunas estadísticas y otras operaciones en el campo calculado.

Añadir campo calculado en tabla dinámica en Excel

Para insertar un campo calculado en una tabla dinámica en Excel, siga estos pasos:

Seleccione la tabla dinámica a la que desea agregar un campo calculado.
Vaya a la pestaña Analizar tabla dinámica en la cinta.
Haga clic en “Campos, elementos y conjuntos” y luego seleccione “Campo calculado” en el menú desplegable.
En el campo “Nombre”, ingrese un nombre para el campo calculado.
En el campo “Fórmula”, ingresa la fórmula para el cálculo que deseas realizar utilizando los nombres adecuados de los campos de la tabla dinámica y los operadores matemáticos correspondientes.
Haga clic en “ok” para crear el campo calculado.
El nuevo campo calculado aparecerá en la Lista de campos de la Tabla Dinámica bajo la sección de Valores.
Arrastre el campo calculado a la sección de Valores de la Tabla Dinámica para mostrar los valores calculados.

Agregar campo calculado en tabla dinámica usando C#

Agrega un campo calculado al archivo de Excel usando Aspose.Cells. Por favor, consulta el siguiente código de muestra. Después de ejecutar el código de ejemplo, se agregará una tabla dinámica con campo calculado a la hoja de cálculo.

Establece los datos originales y crea una tabla dinámica.
Crea el campo calculado de acuerdo con el CampoPivote existente en la tabla dinámica.
Agrega el campo calculado al área de datos.
Finalmente, guarda el libro en formato XLSX de salida.

Código de muestra

Net: Actualizar tablas dinámicas y memorias caché de tablas dinámicas en Aspose.Cells para .NET

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

Aspose.Cells ofrece una API de actualización en capas que le permite recargar datos de tablas dinámicas en cuatro niveles diferentes, desde el libro completo hasta una sola tabla dinámica. A partir de Aspose.Cells for .NET v26.7, el método heredado PivotTable.RefreshData() está marcado como obsoleto y debe reemplazarse por las API más eficientes y conscientes de la caché que se describen en este artículo.

Introducción

Actualizar una tabla dinámica rara vez es una operación única. En segundo plano, Aspose.Cells mantiene una cadena de datos en capas que conecta los datos originales de origen con los valores representados en la hoja de cálculo. Comprender esta cadena es la clave para elegir la API de actualización adecuada para cualquier situación.

La cadena de datos de cuatro capas es:

Origen de datos — los rangos originales de la hoja de cálculo, la consulta a la base de datos o el rango de consolidación donde residen los valores sin procesar.
PivotCache — la instantánea en memoria de los datos de origen. Cada tabla dinámica se construye sobre un PivotCache; aquí es donde se recopilan y agregan todos los datos.
PivotTable — el objeto de vista que define los campos de fila, columna, valor y filtro. Una PivotTable lee únicamente desde su PivotCache, nunca directamente desde el origen de datos.
Cells — el Cells de la hoja de cálculo donde la PivotTable representa sus valores calculados y estilos.

Un concepto particularmente importante es la caché compartida. Cuando varias tablas dinámicas en un libro hacen referencia al mismo rango de origen, comparten una instancia de PivotCache. Una sola PivotCache puede ser referenciada por muchas tablas dinámicas, y al actualizar esa caché se actualizan todas las PivotTable dependientes a la vez.

PivotCache.SourceType (enum PivotTableSourceType) indica de dónde provienen los datos de la caché. A partir de v26.7, PivotCache.Refresh() solo admite los tipos de origen Sheet y Consolidation, es decir, datos que residen en rangos de hojas de cálculo. Las fuentes externas (bases de datos, conexiones externas, etc.) aún no se pueden actualizar mediante la API de caché.

Debido a esta cadena, hay dos rutas fundamentales de actualización en Aspose.Cells:

PivotCache.Refresh() — recarga origen → caché Y recalcula todas las PivotTable dependientes en una sola operación.
PivotTable.CalculateData() — recalcula la visualización de una PivotTable a partir de datos ya almacenados en caché, sin volver al origen de datos.

Todos los escenarios en este artículo usan datos de origen de celdas de hoja de cálculo, por lo que el tipo de origen es Sheet y las operaciones de actualización se comportan como se describe.

Directivas Using Requeridas

Todos los ejemplos en C# de este artículo comienzan con las siguientes tres directivas using porque los tipos de tablas dinámicas se encuentran en el espacio de nombres Aspose.Cells.Pivot:

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

Actualizar Todas las Tablas Dinámicas del Libro

Cuando necesite asegurarse de que cada caché de tablas dinámicas y cada tabla dinámica del libro refleje los últimos datos de origen, la API más simple y completa es Workbook.RefreshAll(). Una sola llamada recorre todo el libro, actualizando cada PivotCache desde su origen y luego recalculando cada PivotTable dependiente. Este es el enfoque recomendado para actualizaciones generales y completas del documento donde el rendimiento no es una preocupación.

El siguiente ejemplo crea un libro con un rango de origen Fruta/Año/Monto, crea una tabla dinámica, modifica algunos valores de origen y luego usa RefreshAll() para actualizar todo en una sola llamada.

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

// Crear un nuevo libro
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Escribir fila de encabezado en las celdas A1:C1
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Escribir filas de datos en las celdas A2:C9 (8 filas de datos de frutas entre 2020 y 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);

// Agregar una tabla dinámica: rango de origen "A1:C9", celda de destino "E3", nombre "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Asignar campos dinámicos: Fruit a Filas, Year a Columnas, Amount a Datos
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modificar varios valores de Amount en los datos de origen para simular cambios
worksheet.Cells["C2"].PutValue(55);
worksheet.Cells["C5"].PutValue(85);
worksheet.Cells["C9"].PutValue(125);

// Actualizar todas las tablas dinámicas / caché de tablas dinámicas en el libro
workbook.RefreshAll();

// Guardar el libro
workbook.Save("output.xlsx");

Actualizar Todas las Tablas Dinámicas en una Sola Hoja de Cálculo

A veces solo necesita actualizar las tablas dinámicas que se encuentran en una hoja de cálculo específica, por ejemplo, cuando se sabe que las tablas dinámicas en otras hojas no están relacionadas y no deben tocarse. Para este caso, Aspose.Cells proporciona Worksheet.RefreshPivotTables(), que tiene alcance sobre una sola instancia de Worksheet.

Esto es más selectivo que Workbook.RefreshAll(): solo se actualizan las tablas dinámicas de la hoja de cálculo objetivo, dejando intactas las tablas dinámicas de otras hojas de cálculo.

El siguiente ejemplo completa los mismos datos de origen Fruta/Año/Monto, agrega una tabla dinámica en la primera hoja de cálculo, modifica algunos valores de origen y luego actualiza solo las tablas dinámicas de esa hoja.

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

Actualizar una Sola Tabla Dinámica

Cuando desee un control detallado sobre una sola tabla dinámica, la API basada en caché le ofrece dos opciones. La elección entre ellas depende de qué cambió realmente: los datos de origen subyacentes, o solo la configuración de vista/diseño de la tabla dinámica misma.

Cambiaron los Datos de Origen — Use `PivotCache.Refresh()`

Si los datos de origen subyacentes han cambiado, el punto de entrada correcto es pivotTable.PivotCache.Refresh(). Esta llamada vuelve a leer los datos de origen en la caché y luego recalcula cada PivotTable que depende de esa caché.

Dado que las tablas dinámicas comparten una sola instancia de PivotCache, llamar a PivotCache.Refresh() recalcula todas las tablas dinámicas construidas sobre esa misma caché, no solo la que usted referencia. Si dos tablas dinámicas comparten el mismo rango de origen, al actualizar una caché se actualizan ambas.

El siguiente ejemplo crea dos tablas dinámicas sobre el mismo rango de origen para demostrar este comportamiento de caché compartida, modifica algunos valores de origen y luego actualiza a través de una referencia de caché.

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

// Crear un nuevo libro de trabajo y acceder a la primera hoja
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Escribir fila de encabezado: Fruta / Año / Cantidad
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Escribir aproximadamente 9 filas de datos (uva / arándano / kiwi / cereza entre 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);

// Agregar la primera tabla dinámica "Pivot1" anclada en la celda E3, rango de origen A1:C9
int pivotIndex1 = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable1 = worksheet.PivotTables[pivotIndex1];

// Asignar campos para Pivot1
pivotTable1.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable1.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable1.AddFieldToArea(PivotFieldType.Data, "Amount");

// Agregar una SEGUNDA tabla dinámica "Pivot2" anclada en E15 usando el MISMO rango de origen A1:C9
// Tanto Pivot1 como Pivot2 comparten un único PivotCache porque el rango de origen es idéntico.
int pivotIndex2 = worksheet.PivotTables.Add("A1:C9", "E15", "Pivot2");
PivotTable pivotTable2 = worksheet.PivotTables[pivotIndex2];

// Asignar los mismos campos para Pivot2
pivotTable2.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable2.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable2.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modificar varios valores de celda de Cantidad en los datos de origen para simular un cambio de datos
worksheet.Cells["C2"].PutValue(150);
worksheet.Cells["C4"].PutValue(350);
worksheet.Cells["C7"].PutValue(650);

// Refrescar el PivotCache compartido.
// Debido a que Pivot1 y Pivot2 comparten el mismo PivotCache, esta única llamada
// refresca AMBAS tablas dinámicas (datos + estilo) desde el origen actualizado.
pivotTable1.PivotCache.Refresh();

// Guardar el libro de trabajo
workbook.Save("output.xlsx");

Solo Cambió la Vista/Diseño — Use `CalculateData()`

Si los datos de origen no han cambiado pero solo se han modificado la configuración de vista o diseño de la tabla dinámica (por ejemplo, se ha movido un campo a un área diferente, o se ha activado/desactivado la configuración de actualización al abrir), no es necesario volver al origen de datos. La caché ya contiene los datos correctos; solo la PivotTable renderizada necesita un recálculo. En este caso, pivotTable.CalculateData() es la opción correcta.

Esto evita la obtención innecesaria del origen y es significativamente más rápido cuando muchas tablas dinámicas comparten la misma caché.

El siguiente ejemplo modifica una propiedad que no es de origen de la tabla dinámica y luego llama a CalculateData() para volver a renderizarla desde la caché existente.

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

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

// Escribir fila de encabezado Fruta / Año / Monto
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Escribir 8 filas de datos (filas 2-9, ajustándose al rango de origen 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);

// Agregar una tabla dinámica llamada "Pivot1" ubicada en la celda destino E3, con origen en A1:C9
int pivotIndex = worksheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.PivotTables[pivotIndex];

// Asignar campos: Fruta a Fila, Año a Columna, Monto a Datos
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Modificar una propiedad de vista/disposición — este es un cambio solo de presentación,
// por lo que NO requiere releer los datos de origen a través de PivotCache.Refresh().
pivotTable.RefreshDataOnOpeningFile = false;

// CalculateData() vuelve a renderizar la visualización de ESTA tabla dinámica (datos + estilo) a partir de
// los datos ya almacenados en el PivotCache. Dado que los datos de origen no cambiaron,
// no se realiza un viaje de ida y vuelta al origen — solo se recalculan los valores en caché
// en las celdas de la hoja de cálculo.
pivotTable.CalculateData();

// Guardar el libro en disco
workbook.Save("output.xlsx");

Obtener Todas las Tablas Dinámicas que Comparten el Mismo PivotCache

Un libro a menudo contiene muchas tablas dinámicas que se asientan sobre una caché compartida. Para enumerarlas, por ejemplo, antes de realizar una actualización por lotes o para diagnosticar el impacto de la caché compartida, use PivotCache.GetPivotTables(). Este método devuelve la colección de todas las PivotTable que dependen de la caché dada.

Esta es también la forma más directa de confirmar que dos tablas dinámicas efectivamente comparten la misma instancia de PivotCache: puede comparar referencias de caché, o simplemente iterar la colección devuelta por GetPivotTables() y observar qué tablas dinámicas aparecen en ella.

El siguiente ejemplo crea dos tablas dinámicas sobre el mismo rango de origen, verifica que comparten la misma instancia de caché y luego enumera las tablas dinámicas de la caché.

Migración desde el Método Obsoleto `PivotTable.RefreshData()`

Antes de Aspose.Cells for .NET v26.7, la forma estándar de actualizar una tabla dinámica era llamar a PivotTable.RefreshData() en cada tabla dinámica individualmente. A partir de v26.7, ese método está marcado como obsoleto y debe reemplazarse por las API conscientes de la caché descritas anteriormente.

Hay dos razones por las que el enfoque de RefreshData() por tabla es problemático en libros del mundo real:

Vuelve a obtener datos del origen cada vez que se llama, incluso cuando el origen no ha cambiado.
Cada llamada actualiza toda la caché compartida. Cuando muchas tablas dinámicas comparten una caché, llamar repetidamente a RefreshData() por tabla dinámica hace que la misma caché se vuelva a obtener una y otra vez, lo cual es muy lento.

Los reemplazos recomendados son:

Actualizar TODAS las tablas dinámicas del libro → use workbook.RefreshAll();
Actualizar ALGUNAS de ellas → use pivotTable.PivotCache.Refresh(); para una caché. Debido a que la caché es compartida, esta única llamada actualiza todas las tablas dinámicas construidas sobre esa caché. Otras tablas dinámicas que se asientan sobre una caché ya actualizada pueden omitirse de forma segura.
Solo cambió la vista/diseño de la tabla dinámica → use pivotTable.CalculateData(); para volver a renderizar desde la caché existente sin ningún viaje de ida y vuelta al origen.

El siguiente ejemplo demuestra el nuevo patrón eficiente para libros con varias tablas dinámicas que comparten una sola caché.

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

// Crear un nuevo libro y acceder a la primera hoja
Workbook workbook = new Workbook();
Worksheet sheet = workbook.Worksheets[0];

// --- Construir los datos de origen: Fruta / Año / Cantidad (encabezado + 9 filas) ---
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);

// --- Agregar la primera tabla dinámica (Pivot1) en la celda de destino E3 ---
int idx1 = sheet.PivotTables.Add("A1:C9", "E3", "Pivot1");
PivotTable pivotTable1 = sheet.PivotTables[idx1];
pivotTable1.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable1.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable1.AddFieldToArea(PivotFieldType.Data, "Amount");

// --- Agregar la SEGUNDA tabla dinámica (Pivot2) en el MISMO rango de origen ---
// Tanto Pivot1 como Pivot2 comparten UN ÚNICO PivotCache subyacente.
// Este es exactamente el escenario donde el método heredado RefreshData() por tabla
// se vuelve ineficiente: actualizar una tabla vuelve a obtener toda la
// caché compartida, por lo que actualizar N tablas realiza la misma obtención costosa N veces.
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");

// --- Modificar varios valores de Cantidad en los datos de origen ---
sheet.Cells["C2"].PutValue(5000);   // Uva 2020
sheet.Cells["C5"].PutValue(7500);   // Cereza 2020
sheet.Cells["C9"].PutValue(9500);   // Cereza 2021

// --- Patrón OBSOLETO (anterior a 26.7) — PivotTable.RefreshData() ---
// pivotTable1.RefreshData();  // vuelve a obtener del origen, actualiza toda la caché
// pivotTable2.RefreshData();  // vuelve a obtener OTRA VEZ — ¡la caché ya está actualizada!
// Cada llamada reconstruye la caché compartida, por lo que N tablas = N obtenciones redundantes.

// --- Nuevo patrón v26.7+: actualizar la caché UNA VEZ, luego re-renderizar según sea necesario ---
// Una sola llamada a PivotCache.Refresh() introduce los valores modificados en la caché compartida
// Y recalcula la visualización de TODAS las tablas dinámicas que la referencian.
// Dado que Pivot1 y Pivot2 comparten un único PivotCache, esta única llamada actualiza
// ambas tablas — no se requiere un segundo viaje al origen.
pivotTable1.PivotCache.Refresh();

// CalculateData() solo re-renderiza la visualización (datos + estilo) de una tabla dinámica
// a partir de los datos ya almacenados en la caché — NO toca el origen.
// La llamamos en Pivot2 aquí puramente para demostrar la API: después de que la caché
// haya sido actualizada una vez, cualquier tabla dependiente puede re-renderizarse sin
// volver al origen. Use CalculateData() por sí sola cuando solo la configuración de
// la vista/distribución de la tabla dinámica haya cambiado y la caché esté actualizada.
pivotTable2.CalculateData();

workbook.Save("output.xlsx");

¿Qué API de Actualización Debo Usar?

La tabla a continuación resume las API de actualización disponibles y cuándo elegir cada una.

Objetivo	API Recomendada	Notas
Actualizar todo en el libro	`Workbook.RefreshAll()`	Una llamada; cubre todas las cachés y tablas.
Actualizar solo las tablas dinámicas de una sola hoja	`Worksheet.RefreshPivotTables()`	Con alcance a una sola hoja de cálculo.
Cambiaron los datos de origen para una caché	`pivotTable.PivotCache.Refresh()`	Actualiza TODAS las tablas dinámicas sobre esa caché compartida.
Solo cambió la configuración de vista/diseño	`pivotTable.CalculateData()`	Omite el viaje innecesario al origen.
Listar todas las tablas dinámicas sobre una caché compartida	`pivotCache.GetPivotTables()`	Use para enumerar antes de una actualización masiva.

En la práctica, prefiera las API basadas en caché sobre el obsoleto RefreshData() por tabla. Son conscientes de las cachés compartidas, evitan búsquedas redundantes en el origen y le permiten elegir el alcance más pequeño que satisface su requisito de actualización.

Net: Aplicar estilos a tablas dinámicas en Aspose.Cells para .NET

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

Aspose.Cells admite la aplicación tanto de autoformatos heredados para tablas dinámicas (diseñados para archivos .xls) como de estilos modernos con nombre o personalizados para tablas dinámicas (diseñados para archivos .xlsx, .xlsm y .xlsb). La API que debe llamar depende del formato de archivo en el que se guarda el libro, no del formato desde el que se cargó.

Introducción

Aspose.Cells expone dos APIs de estilo paralelas para tablas dinámicas. La decisión entre ellas depende del formato de archivo en el que guarde el libro, no del formato desde el que lo lea. Un libro cargado desde un archivo .xls puede volver a guardarse como .xlsx, y en ese caso se aplica la API de estilo moderna en lugar de la heredada.

Para la salida heredada en formato .xls, utilice la propiedad PivotTable.AutoFormatType junto con la enumeración Aspose.Cells.Pivot.PivotTableAutoFormatType. Esta API corresponde al selector de autoformato que el Excel clásico ofrecía para las tablas dinámicas.

Para la salida moderna en formatos .xlsx, .xlsm y .xlsb, están disponibles dos variantes de la API de estilo:

PivotTable.PivotTableStyleType selecciona uno de los estilos con nombre integrados (temas claros y oscuros, incluidos los estilos añadidos en Excel 2017). Estos preajustes son de solo lectura.
PivotTable.PivotTableStyleName selecciona un estilo personalizado que usted mismo define mediante Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Los estilos personalizados son obligatorios cuando se desea modificar colores, bordes o fuentes más allá de lo que ofrecen los preajustes.

Además, PivotTable.FormatAll(Style) es un acceso directo que aplica un único objeto Style a cada celda de la tabla dinámica, anulando todo lo establecido mediante cualquiera de las APIs de nombre de estilo anteriores. Esto resulta útil cuando se requiere una apariencia uniforme independientemente del tema subyacente.

Aplicar un autoformato predefinido heredado de XLS

PivotTable.AutoFormatType acepta un valor de la enumeración Aspose.Cells.Pivot.PivotTableAutoFormatType. Los valores disponibles son Report1 a Report10, Classic y Table1 a Table10.

AutoFormatType solo se respeta cuando el libro se guarda como .xls. Cuando el mismo libro se guarda como .xlsx, .xlsm o .xlsb, Excel ignora esta propiedad y recurre a la configuración de PivotTableStyleType y PivotTableStyleName.

El siguiente ejemplo carga un libro nuevo, rellena los datos de muestra de Fruta/Año/Importe, añade una tabla dinámica, aplica PivotTableAutoFormatType.Report5 y guarda el resultado como .xls.

¿Por qué no hay campos de columna? Los autoformatos de la serie Report (Report1 a Report10, Table1 a Table10) se diseñaron en el Excel clásico para tablas dinámicas unidimensionales con solo campos de fila y valores — no tienen estilo integrado para los encabezados de campos de columna. Si tu tabla dinámica necesita campos de columna, usa los preajustes modernos PivotTableStyleType del Escenario 2 a continuación, que están diseñados para el diseño bidimensional que usa el Excel moderno.

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

// Escenario 1: Aplicar un autoformato preestablecido XLS heredado
// API en uso: PivotTable.AutoFormatType
// Formato de archivo de destino: .xls (heredado)
// Para ejemplos completos y archivos de datos, vaya a https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Crear un nuevo libro de trabajo
Workbook workbook = new Workbook();

// Obtener la primera hoja de trabajo
Worksheet sheet = workbook.Worksheets[0];

// Rellenar los datos de origen con la fila de encabezado (Fruit, Year, Amount)
// y 9 filas de datos que cubren grape, blueberry, kiwi, cherry entre 2020 y 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);

// Agregar una tabla dinámica en la celda de destino E3, llamada "Pivot1", usando el rango de origen A1:C10
int pivotIndex = sheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Asignar campos: Fruit -> Filas, Year -> Columnas, Amount -> Datos
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Aplicar el autoformato preestablecido XLS heredado "Report5"
// Nota: Esta propiedad solo tiene sentido al guardar como .xls.
// Cuando se guarda como .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
// y usa lo que especifique PivotTableStyleType / PivotTableStyleName.
pivotTable.AutoFormatType = PivotTableAutoFormatType.Report5;

// Guardar el libro en formato .xls heredado
workbook.Save("output.xls");

Aplicar un estilo predefinido moderno con nombre para tablas dinámicas

PivotTable.PivotTableStyleType acepta un valor de la enumeración Aspose.Cells.PivotTableStyleType. La enumeración cubre los temas claros PivotTableStyleLight1 a PivotTableStyleLight28 y los temas oscuros PivotTableStyleDark1 a PivotTableStyleDark28. Los estilos añadidos en Excel 2017 (la segunda oleada de temas claros y oscuros) están disponibles a través de la misma enumeración.

Esta es la API recomendada para cualquier formato de archivo moderno. A diferencia del autoformato heredado, el estilo seleccionado aquí se representa fielmente en Excel y sobrevive a los intercambios con otras herramientas de Office.

El siguiente ejemplo utiliza los mismos datos de Fruta/Año/Importe, crea una tabla dinámica idéntica, aplica PivotTableStyleDark1 y guarda el libro como .xlsx.

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

// Escenario 2: Aplicar un estilo preestablecido con nombre de Excel 2007+ moderno usando PivotTableStyleType.
// Formato de archivo de destino: .xlsx. La enumeración PivotTableStyleType reside en el espacio de nombres Aspose.Cells
// (no en Aspose.Cells.Pivot) — es por eso que no necesitamos ninguna cláusula using adicional para ello.
// Referencia en GitHub: https://github.com/aspose-cells/Aspose.Cells-for-.NET/blob/master/Examples/CSharp/PivotTables/ApplyStyleToPivotTable2.cs

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

// Fila de encabezado: Fruta / Año / Monto
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// 9 filas de datos de Fruta / Año / Monto
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);

// Añadir una tabla dinámica en E3 con el nombre "Pivot1", con origen en A1:C10
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Asignar campos dinámicos: Fruta -> área de fila, Año -> área de columna, Monto -> área de datos
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Aplicar un estilo de tabla dinámica preestablecido con nombre de Excel 2007+ moderno.
// PivotTableStyleType es la API correcta para archivos .xlsx / .xlsm / .xlsb; AutoFormatType
// es ignorado por Excel para esos formatos. PivotTableStyleDark1 pertenece a la familia del tema oscuro
// (PivotTableStyleDark1..PivotTableStyleDark28), y la misma enumeración también expone los
// temas más recientes de Excel 2017 claro/oscuro (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.PivotTableStyleType = PivotTableStyleType.PivotTableStyleDark1;

// Guardar como .xlsx moderno — este es el formato para el cual PivotTableStyleType es significativo.
workbook.Save("output.xlsx");

Definir y aplicar un estilo personalizado para tablas dinámicas

Los preajustes integrados no se pueden modificar. Cuando necesite anular colores, bordes o fuentes, debe definir un estilo personalizado para tablas dinámicas. El flujo de trabajo consta de tres pasos:

Añada un estilo personalizado a la colección TableStyles del libro mediante Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name). Esto devuelve el índice del estilo recién creado.
Configure el estilo añadiendo elementos (como WholeTable o GrandTotalRow) mediante TableStyle.TableStyleElements.Add(TableStyleElementType) y, a continuación, asigne un Style a cada elemento mediante TableStyleElement.SetElementStyle(Style).
Aplique el estilo personalizado a la tabla dinámica asignando a PivotTable.PivotTableStyleName el nombre del estilo. No utilice PivotTableStyleType aquí, ya que esa propiedad selecciona los preajustes integrados.

PivotTableStyleName y PivotTableStyleType no son intercambiables. Utilice PivotTableStyleType para los preajustes integrados y PivotTableStyleName para los estilos personalizados que haya definido mediante AddPivotTableStyle. Establecer ambos no causa problemas, pero solo se representa el que coincida con el origen previsto.

Los valores disponibles de TableStyleElementType incluyen WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels y PageFieldValues.

El siguiente ejemplo define un estilo personalizado para tablas dinámicas con un borde negro fino en WholeTable y una fuente roja en negrita en GrandTotalRow, lo aplica mediante PivotTableStyleName y guarda como .xlsx.

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

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

// Poblar datos de origen: fila de encabezado + 9 filas de datos (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);

// Agregar tabla dinámica con origen en A1:C10, anclada en E3, llamada "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");

// Paso 1: registrar un nuevo estilo de tabla dinámica personalizado y capturar su índice
int styleIndex = workbook.Worksheets.TableStyles.AddPivotTableStyle("CustomPivotStyle");
TableStyle tableStyle = workbook.Worksheets.TableStyles[styleIndex];

// Paso 2: agregar un elemento WholeTable y aplicar bordes negros finos en los cuatro lados
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);

// Paso 3: agregar un elemento GrandTotalRow y aplicar fuente roja en negrita
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);

// Paso 4: aplicar el estilo personalizado por nombre (NO por PivotTableStyleType, que es para estilos predefinidos)
pivotTable.PivotTableStyleName = "CustomPivotStyle";

workbook.Save("output.xlsx");

Aplicar un solo estilo a cada celda de la tabla dinámica con FormatAll

PivotTable.FormatAll(Style) es un acceso directo que aplica un único objeto Style a cada celda de la tabla dinámica, incluidas el área de datos, los encabezados de filas y columnas y los totales. Todo lo establecido previamente mediante PivotTableStyleType o PivotTableStyleName queda anulado.

FormatAll anula tanto PivotTableStyleType como PivotTableStyleName. Utilícelo solo cuando se requiera una apariencia uniforme e independiente del tema en toda la tabla dinámica.

El siguiente ejemplo crea un Style con un relleno sólido amarillo, una fuente azul oscuro en negrita y bordes negros finos en todos los lados, lo aplica con FormatAll y guarda como .xlsx.

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

// Escenario 4: Aplicar un único Estilo a cada celda de la tabla dinámica usando FormatAll
// API en uso: PivotTable.FormatAll(Style)
// Formato de destino: .xlsx
// Referencia de GitHub: ver el repositorio Aspose.Cells-for-.NET — ejemplos de estilo de tablas dinámicas

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

// Rellenar datos de origen: fila de encabezado (fila 1) + 9 filas de datos (filas 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);

// Agregar tabla dinámica: rango de origen A1:C10, celda de destino E3, nombre "Pivot1"
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "Pivot1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Asignar campos dinámicos: Fruit -> área de Filas, Year -> área de Columnas, Amount -> área de Datos
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Column, "Year");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Construir un Estilo que se forzará sobre cada celda de la tabla dinámica
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;

// Aplicar FormatAll: fuerza este único estilo sobre cada celda de la tabla dinámica,
// anulando cualquier PivotTableStyleType / PivotTableStyleName establecido previamente
pivotTable.FormatAll(style);

// Guardar el libro en el formato moderno .xlsx
workbook.Save("output.xlsx");

¿Qué API de estilo debo usar?

La elección de la API de estilo depende del formato de archivo en el que va a guardar. Utilice la tabla siguiente como referencia rápida.

Formato de archivo de destino	API a utilizar	Notas
`.xls` (heredado)	`PivotTable.AutoFormatType`	Valores de `Aspose.Cells.Pivot.PivotTableAutoFormatType` (p. ej., `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Se ignora al guardar en formatos modernos.
`.xlsx` / `.xlsm` / `.xlsb` (moderno, estilo integrado)	`PivotTable.PivotTableStyleType`	Valores de `Aspose.Cells.PivotTableStyleType` (temas claros y oscuros, incluidas las adiciones de Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderno, estilo personalizado)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	Utilícelo cuando los preajustes integrados no sean suficientes. Configurar mediante `TableStyleElement.SetElementStyle(...)`.
Cualquier formato (anulación uniforme)	`PivotTable.FormatAll(Style)`	Acceso directo que anula cualquier otra configuración de estilo en toda la tabla dinámica.

En caso de duda, guarde como .xlsx y utilice PivotTableStyleType para los temas integrados, o PivotTableStyleName para los temas personalizados.

Net: Agregar campos de fila y columna a una tabla dinámica en Aspose.Cells para .NET

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

Agregar un campo a la región de fila o columna

El método PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) mueve un campo base desde los datos de origen a una de las cuatro regiones de la tabla dinámica. El argumento fieldType acepta uno de los siguientes valores de PivotFieldType.

Row — campos colocados verticalmente a la izquierda
Column — campos colocados horizontalmente en la parte superior
Data — campos cuyos valores se agregan
Page — campos utilizados como filtros de informe

Después de agregar los campos, puede acceder a ellos a través de las propiedades PivotTable.RowFields y PivotTable.ColumnFields. Cada propiedad devuelve un PivotFieldCollection. El campo en el índice 0 de RowFields es el campo de fila más externo, y los índices siguientes representan campos anidados dentro de él. La misma convención de indexación se aplica a ColumnFields.

El orden de anidamiento de los campos es importante. Si se agrega primero Category a la región de fila y luego Item, se obtiene una tabla dinámica cuya agrupación externa es Category y cuya agrupación interna es Item. Si se invierte el orden, se invierte la jerarquía.

Subtotales de campos dinámicos

El método PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) controla qué filas de subtotal aparecen para un campo dinámico. Cada llamada activa o desactiva un único tipo de subtotal de forma independiente. Si se pasa shown = true se muestra el subtotal, mientras que shown = false lo oculta. Dado que cada llamada solo afecta a un tipo, llamar al método varias veces con distintos valores de subtotalType construye un subconjunto personalizado de subtotales.

La enumeración PivotFieldSubtotalType define los tipos de subtotal disponibles.

Automatic — Aspose.Cells elige la selección predeterminada (normalmente Sum para campos numéricos)
None — suprime todas las filas de subtotal
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

Los subtotales solo se renderizan cuando hay dos o más campos dinámicos en la región de fila (o en la región de columna). Un solo campo no tiene nada significativo entre lo que calcular un subtotal, por lo que las llamadas a SetSubtotals no tienen ningún efecto visible en ese caso. Por este motivo, este artículo coloca dos campos de fila (Category externo, Item interno) en cada ejemplo, de modo que el límite de subtotal entre cada grupo Category sea visible.

Escenario 1 — Subtotales automáticos (predeterminados)

Cuando no se llama a SetSubtotals en absoluto, Aspose.Cells aplica la selección Automatic a los campos numéricos. El siguiente ejemplo confirma explícitamente este comportamiento al llamar a SetSubtotals(PivotFieldSubtotalType.Automatic, true) sobre el campo de fila Category externo.

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

Escenario 2 — Suprimir todos los subtotales (None)

Llamar a SetSubtotals(PivotFieldSubtotalType.None, true) elimina todas las filas de subtotal de la tabla dinámica, dejando solo las filas de los campos y el total general en la parte inferior. Esto resulta útil cuando se desean los datos agrupados en bruto sin ninguna fila de resumen.

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

Escenario 3 — Subconjunto personalizado de subtotales (Sum + Average)

No se limita a un único tipo de subtotal. Cada llamada a SetSubtotals opera de forma independiente sobre un tipo, por lo que llamar al método dos veces — una con Sum y otra con Average — produce un subconjunto personalizado de dos filas de subtotal para cada grupo Category.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pivotTable.CalculateData();

workbook.Save("output_custom.xlsx");

Resumen

Los tres escenarios anteriores comparten el mismo conjunto de datos y la misma estructura de tabla dinámica. La única diferencia entre ellos es la llamada a SetSubtotals aplicada al campo de fila Category externo. Recuerde la regla de los dos campos: un solo campo en una región no tiene nada entre lo que calcular un subtotal, así que coloque siempre al menos dos campos en la región de fila o de columna cuando desee que SetSubtotals tenga un efecto visible.

Net: Administrar campos de valor de una tabla dinámica en Aspose.Cells para .NET

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

Agregar un campo a la región de datos

Agregar un campo base a la región de datos (valor) es el primer paso para dar forma a cómo una tabla dinámica agrega los datos de origen. Aspose.Cells expone PivotTable.AddFieldToArea(PivotFieldType, string), una sobrecarga que acepta la constante PivotFieldType.Data y el nombre de la columna de origen. Una vez que se agrega un campo a la región de datos, la API lo expone a través de la colección PivotTable.DataFields, en el orden en que se agregaron los campos. Por defecto, una columna de origen numérica se resume con ConsolidationFunction.Sum, mientras que una columna no numérica toma por defecto Count.

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

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

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

// Filas de datos A2:D9 usando bucles anidados que se ramifican en 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;
 }
 }
}

// Agregar tabla dinámica en F3 con el nombre PivotTable1
int pivotIndex = worksheet.PivotTables.Add("A1:D9", "F3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Diseño de la tabla dinámica: Categoría e Ítem en Fila, Año en Columna, Monto como campo de datos
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");

Cambiar la función de resumen

Cada campo colocado en la región de datos se envuelve internamente como una instancia de PivotField, y su propiedad Function devuelve un valor de la enumeración ConsolidationFunction. El mismo setter de Function le permite cambiar entre los agregados disponibles, incluidos Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var y Varp.

Cambiar Function solo afecta al agregado, la columna de origen no cambia.

Por lo tanto, puede dejar un campo de datos como Sum mientras agrega un segundo campo de datos que apunte a la misma columna de origen pero que use Count o Average, todo en una sola tabla dinámica.

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

Representar campos de valor en el eje de fila o columna

Cuando una tabla dinámica contiene dos o más campos de datos, Aspose.Cells expone un campo virtual adicional llamado PivotTable.ValuesField. Este campo virtual representa el agregado de cada campo de datos que se encuentra en la región de datos. Puede arrastrarlo a la región de fila o columna como un campo dinámico base, lo que resulta útil para disponer varias medidas una al lado de la otra.

PivotTable.ValuesField no funciona si no hay ningún campo de valor o si solo hay uno.

Los escenarios a continuación recorren tres ejemplos completos que demuestran cada capacidad descrita anteriormente sobre la misma estructura de tabla dinámica.

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: Agregar campos de filtro a una tabla dinámica en Aspose.Cells para .NET

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

Aspose.Cells admite el ciclo de vida completo de los campos de filtro en tablas dinámicas. Puede agregar un campo de filtro mediante una API de conveniencia de alto nivel o mediante la colección de bajo nivel PageFields, y puede controlar el filtro de página en modo de selección única, limpiarlo para mostrar cada elemento de página, o cambiar el campo a selección múltiple para que los usuarios puedan elegir varios elementos de página a la vez a través de la interfaz de casillas de verificación en Excel.

Introducción

Un campo de filtro es un campo dinámico que controla qué subconjunto de los datos de origen muestra el cuerpo de la tabla dinámica. Los usuarios finales lo ven como un menú desplegable en la parte superior de una tabla dinámica renderizada en Excel, y al seleccionar uno de los elementos de página disponibles, el cuerpo de la tabla dinámica se reconstruye de modo que solo se resumen los registros que pertenecen a ese elemento de página. Un campo dinámico se convierte en un campo de filtro cuando se registra como PivotFieldType.Page en lugar de PivotFieldType.Row, PivotFieldType.Column o PivotFieldType.Data.

Un campo de filtro puede operar con dos comportamientos. En el comportamiento predeterminado de selección única, solo un elemento de página es visible a la vez, por lo que el cuerpo de la tabla dinámica resume exactamente un subconjunto. En el comportamiento de selección múltiple, el campo expone una lista de casillas de verificación, y el cuerpo de la tabla dinámica resume la unión de cada elemento de página marcado. El mismo campo de origen puede moverse de un lado a otro entre estos comportamientos alternando una sola propiedad.

Aspose.Cells for .NET expone dos formas equivalentes de registrar un campo de filtro. La API de alto nivel es PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName"), que toma el nombre de la columna de origen y agrega el campo en una sola llamada. La API de bajo nivel es PivotTable.PageFields.Add(PivotField), que se utiliza cuando ya tiene una referencia PivotField y desea agregar la misma instancia de campo al área de filtro. Ambas API terminan rellenando la misma colección PageFields, y el resto de este artículo demuestra cómo elegir entre ellas y cómo controlar cada modo de filtrado.

Agregar un campo de filtro

Hay dos formas de registrar un campo dinámico en el área de filtro. La llamada de alto nivel toma el nombre de la columna de origen como una cadena de texto y es la ruta más común. La llamada de bajo nivel acepta una instancia existente de PivotField y es conveniente cuando el mismo objeto de campo debe reutilizarse en múltiples áreas de la tabla dinámica. Ambas llamadas colocan el campo en PivotTable.PageFields, después de lo cual aparece como el menú desplegable de página en la parte superior de la tabla dinámica renderizada.

Agregar un campo de filtro con AddFieldToArea

El siguiente ejemplo crea un pequeño conjunto de datos de Fruta / Año / Cantidad, coloca una tabla dinámica en la celda E3 con Fruit en el área de filas, Amount en el área de datos y Year en el área de filtro, actualiza la tabla dinámica y guarda el libro de trabajo.

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

// Crear un nuevo libro de trabajo
var workbook = new Workbook();
var worksheet = workbook.Worksheets[0];
worksheet.Name = "Data";

// Configurar la fila de encabezado
worksheet.Cells["A1"].PutValue("Fruit");
worksheet.Cells["B1"].PutValue("Year");
worksheet.Cells["C1"].PutValue("Amount");

// Poblar 9 filas de datos de muestra: Fruta, Año, Cantidad
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]);
}

// Agregar una tabla dinámica anclada en la celda E3
int pivotIndex = worksheet.PivotTables.Add("A1:C10", "E3", "PivotTable1");
PivotTable pivotTable = worksheet.PivotTables[pivotIndex];

// Agregar campos a sus áreas: Fruta como Fila, Cantidad como Datos, Año como campo de Página
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Actualizar y calcular los datos de la tabla dinámica
pivotTable.CalculateData();

// Guardar el libro de trabajo
workbook.Save("pageFieldSample.xlsx");

Agregar un campo de filtro con PageFields.Add

Cuando ya trabaja con una instancia de PivotField, puede pasarla directamente a PivotTable.PageFields.Add. La tabla dinámica y el campo de filtro se construyen exactamente como en el escenario anterior; solo el registro final del área de filtro se reemplaza con la llamada a la API de bajo nivel.

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

// — La tabla dinámica y el campo de página se construyen exactamente como en
//   Escenario 1a (datos de Fruta/Año/Cantidad, pivote en E3, Fruta→Fila,
//   Cantidad→Datos). A continuación obtenemos el PivotField Año desde la
//   colección BaseFields y lo pasamos a PageFields.Add — la
//   alternativa de bajo nivel a AddFieldToArea. El resultado es
//   funcionalmente idéntico al Escenario 1a.

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

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

// Datos de muestra (9 filas)
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);

// Agregar tabla dinámica en E3 cubriendo A1:C10
int pivotIndex = sheet.PivotTables.Add("E3", "A1:C10", "PivotTable1");
PivotTable pivotTable = sheet.PivotTables[pivotIndex];

// Fruta -> Fila, Cantidad -> Datos (Año irá a Página abajo)
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");

// Enfoque de bajo nivel: tomar el PivotField Año existente de BaseFields
// y registrarlo en el área Página mediante PageFields.Add(PivotField).
PivotField yearField = pivotTable.BaseFields["Year"];
pivotTable.PageFields.Add(yearField);

// Actualizar para que el nuevo campo de página se refleje en el libro guardado
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Filtrado de selección única (mostrar un elemento de página)

En el comportamiento predeterminado de selección única, el campo de filtro se renderiza como un único menú desplegable y el entero PivotField.CurrentPageItem selecciona qué elemento de página dirige el cuerpo de la tabla dinámica. Asignar un índice específico elige ese único elemento; asignar el centinela especial 0x7FFD (decimal 32765) limpia el filtro para que cada elemento de página se resuma de una vez. La selección única es la predeterminada; no necesita habilitarla explícitamente.

Mostrar todos los elementos

Establecer CurrentPageItem en el valor mágico 0x7FFD equivale a limpiar el filtro de página: el cuerpo de la tabla dinámica resume cada elemento de página como si no se aplicara ningún filtro.

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

class Program
{
    static void Main()
    {
        // Crear un nuevo libro de trabajo
        Workbook workbook = new Workbook();
        Worksheet sheet = workbook.Worksheets[0];

        // Rellenar datos de Fruta/Año/Cantidad
        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]);
            }
        }

        // Crear tabla dinámica en E3
        var pivotTables = sheet.PivotTables;
        int index = pivotTables.Add("=A1:C7", "E3", "PivotTable1");
        PivotTable pivotTable = pivotTables[index];

        // Configurar campos dinámicos: Fruta→Fila, Cantidad→Dato, Año→Página
        pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
        pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
        pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

        pivotTable.CalculateData();

        // Borrar el filtro de página para que cada elemento del campo de página sea visible.
        // 0x7FFD (decimal 32765) es el valor centinela especial que significa "todos los elementos" —
        // equivalente a seleccionar "(Todos)" en el menú desplegable del campo de página de Excel.
        pivotTable.PageFields[0].CurrentPageItem = 0x7FFD;

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

Mostrar un elemento específico

Establecer CurrentPageItem en un índice real selecciona solo ese elemento de página. El índice es la posición del elemento en la lista ordenada de elementos del campo de filtro, por ejemplo, 1 selecciona el segundo elemento después de ordenar.

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

// Crear libro de trabajo
var workbook = new Workbook();
var sheet = workbook.Worksheets[0];
var cells = sheet.Cells;

// Agregar datos de muestra (Fruta/Año/Cantidad)
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");

// Agregar tabla dinámica en E3
var pivotTables = sheet.PivotTables;
int pivotIndex = pivotTables.Add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables[pivotIndex];

// Agregar campos: Fruta→Fila, Cantidad→Datos, Año→Página
pivotTable.AddFieldToArea(PivotFieldType.Row, "Fruit");
pivotTable.AddFieldToArea(PivotFieldType.Data, "Amount");
pivotTable.AddFieldToArea(PivotFieldType.Page, "Year");

// Operaciones específicas del campo de página
pivotTable.PageFields[0].CurrentPageItem = 1; // 1 = segundo elemento en orden ordenado (por ejemplo, "2021")

// Refrescar y calcular tabla dinámica
pivotTable.CalculateData();

workbook.Save("output.xlsx");

Filtrado de selección múltiple

El filtrado de selección múltiple convierte el menú desplegable de página en una lista de casillas de verificación y permite al usuario final elegir varios elementos de página simultáneamente. Aspose.Cells expone dos propiedades que trabajan juntas. PivotField.IsMultipleItemSelectionAllowed debe establecerse en true antes de que la interfaz de selección múltiple surta efecto. Después de habilitarla, PivotItem.IsHidden controla qué elementos aparecen en la lista de casillas de verificación, por lo que puede mostrar cada elemento o incluir en la lista blanca solo elementos específicos.

El código siguiente habilita la selección múltiple en el mismo campo de filtro Year construido en el escenario 1a, y luego muestra dos patrones: la Parte A revela cada elemento de página dejando IsHidden establecido en false para cada entrada, mientras que la Parte B incluye en la lista blanca solo los valores de origen que elija y oculta todo lo demás mediante un bloque switch (pivotItems[i].GetStringValue()).

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

// — La tabla dinámica y el campo de página se construyen exactamente como en
//   Escenario 1a (datos de Fruta/Año/Cantidad, pivote en E3, Fruta→Fila,
//   Cantidad→Datos, Año→Página vía AddFieldToArea).
//   A continuación aplicamos el filtrado de selección múltiple en el campo de página.

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

// Datos de muestra: Fruta | Año | Cantidad
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");

// — Habilitar selección múltiple en el campo de página
pivotTable.PageFields[0].IsMultipleItemSelectionAllowed = true;

// Parte A — seleccionar TODOS los elementos (hacer visible cada elemento)
PivotItemCollection pivotItems = pivotTable.PageFields[0].PivotItems;
for (int i = 0; i < pivotItems.Count; i++)
{
    pivotItems[i].IsHidden = false;
}

// Parte B — seleccionar solo elementos específicos por valor de origen
for (int i = 0; i < pivotItems.Count; i++)
{
    switch (pivotItems[i].GetStringValue())
    {
        case "2020":
        case "grape":
        case "blueberry":
            pivotItems[i].IsHidden = false;
            break;
        default:
            pivotItems[i].IsHidden = true;
            break;
    }
}

pivotTable.CalculateData();

workbook.Save("output.xlsx");

Nota: Cuando use el filtrado de selección múltiple a través de PivotItem.IsHidden, al menos un PivotItem debe permanecer visible (IsHidden == false). Si cada elemento está oculto, Excel se bloquea al abrir el archivo o renderiza una tabla dinámica en blanco. Siempre verifique que su lista blanca de selección múltiple incluya al menos un elemento de sus datos de origen.

¿Qué API y qué modo debo usar?

La tabla siguiente resume cuándo usar cada API y modo para que pueda elegir la combinación correcta sin leer cada escenario en detalle.

Escenario / Caso de uso	API recomendada	Propiedad utilizada	Notas
Agregar un campo de filtro por nombre de columna de origen (más común)	`PivotTable.AddFieldToArea(PivotFieldType.Page, "fieldName")`	n/a	Alto nivel, una sola línea. Use esto a menos que necesite una referencia `PivotField`.
Agregar un campo de filtro cuando ya tiene un objeto `PivotField`	`PivotTable.PageFields.Add(PivotField)`	n/a	Use cuando el objeto de campo se obtuvo en otro lugar o necesita reutilizarse.
Filtrar a un único elemento de página (modo predeterminado)	`PivotField.CurrentPageItem`	establecer en un índice específico	Por ejemplo, `1` muestra el segundo elemento en la lista ordenada.
Mostrar todos los elementos / limpiar el filtro de página	`PivotField.CurrentPageItem`	establecer en `0x7FFD`	El valor mágico `0x7FFD` (decimal 32765) es el centinela para “todos los elementos”.
Habilitar la interfaz de selección múltiple en Excel	`PivotField.IsMultipleItemSelectionAllowed`	establecer en `true`	Requerido antes de que cualquier llamada a `IsHidden` surta efecto.
Ocultar / mostrar elementos individuales en una lista de selección múltiple	`PivotItem.IsHidden`	establecer por elemento	Al menos un elemento debe permanecer visible (`IsHidden == false`).

Recuerde siempre la restricción de visibilidad al configurar el filtrado de selección múltiple. Si cada PivotItem en un campo de filtro de selección múltiple está oculto, Excel se bloquea al abrir o renderiza una tabla dinámica en blanco. Construya su lista blanca contra sus datos de origen para que al menos un elemento permanezca visible, y sus libros de trabajo guardados se abrirán de manera confiable en cualquier máquina.

Net: Eliminar la tabla dinámica de una hoja de cálculo

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

Aspose.Cells proporciona una función para eliminar o quitar la Tabla Dinámica de una hoja de cálculo. Puede eliminar la tabla dinámica usando el objeto de tabla dinámica o la posición de la tabla dinámica. Utilice el método Worksheet.PivotTables.Remove() para eliminar la tabla dinámica usando el objeto de tabla dinámica y el método Worksheet.PivotTables.RemoveAt() para eliminar el objeto de tabla dinámica usando su posición dentro de la colección de tablas dinámicas.

El siguiente código de muestra elimina dos tablas dinámicas de la hoja de cálculo. Primero elimina la tabla dinámica usando el método Worksheet.PivotTables.Remove() y luego elimina la tabla dinámica usando el método Worksheet.PivotTables.RemoveAt()

Net: Guardar tabla dinámica en archivo ODS

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

Aspose.Cells proporciona la capacidad de guardar la tabla dinámica en archivos ODS. Para ello, simplemente convierta un libro de trabajo con una tabla dinámica existente o cree una nueva tabla dinámica y guarde el archivo en formato ODS. Asegúrese de llamar a PivotTable.CalculateData() antes de guardar para garantizar que la tabla dinámica se represente en el archivo ODS de salida. El siguiente fragmento de código demuestra cómo guardar la tabla dinámica en un archivo ODS.

Código de Muestra

El archivo de salida generado del código anterior está adjunto para su referencia.

Archivo ODS de salida

Documentation – Insertar tabla dinámica

Net: Dar formato a la tabla dinámica

Apariencia de la tabla dinámica

Configuración de opciones de formato de tabla dinámica

Establecer el tipo de autoformato

Configuración de opciones de formato

Dar formato manualmente al aspecto visual

Configuración de opciones de formato de campo de tabla dinámica

Configuración de formato de campos de fila/columna/página

Configuración de formato de campos de datos

Borrado de campos de tabla dinámica

Net: Crear tablas dinámicas y gráficos dinámicos

Añadiendo tablas dinámicas y gráficos

Preparación para usar Aspose.Cells

Añadiendo una tabla dinámica

Añadiendo un gráfico dinámico

Net: Tabla dinámica y datos fuente

Datos fuente de la tabla dinámica

Cambio de la fuente de datos de una tabla dinámica

Net: Agregar campo calculado en tabla dinámica

Escenarios de uso posibles

Añadir campo calculado en tabla dinámica en Excel

Agregar campo calculado en tabla dinámica usando C#

Código de muestra

Net: Actualizar tablas dinámicas y memorias caché de tablas dinámicas en Aspose.Cells para .NET

Introducción

Directivas Using Requeridas

Actualizar Todas las Tablas Dinámicas del Libro

Actualizar Todas las Tablas Dinámicas en una Sola Hoja de Cálculo

Actualizar una Sola Tabla Dinámica

Cambiaron los Datos de Origen — Use PivotCache.Refresh()

Solo Cambió la Vista/Diseño — Use CalculateData()

Obtener Todas las Tablas Dinámicas que Comparten el Mismo PivotCache

Migración desde el Método Obsoleto PivotTable.RefreshData()

¿Qué API de Actualización Debo Usar?

Net: Aplicar estilos a tablas dinámicas en Aspose.Cells para .NET

Introducción

Aplicar un autoformato predefinido heredado de XLS

Aplicar un estilo predefinido moderno con nombre para tablas dinámicas

Definir y aplicar un estilo personalizado para tablas dinámicas

Aplicar un solo estilo a cada celda de la tabla dinámica con FormatAll

¿Qué API de estilo debo usar?

Net: Agregar campos de fila y columna a una tabla dinámica en Aspose.Cells para .NET

Agregar un campo a la región de fila o columna

Subtotales de campos dinámicos

Escenario 1 — Subtotales automáticos (predeterminados)

Escenario 2 — Suprimir todos los subtotales (None)

Escenario 3 — Subconjunto personalizado de subtotales (Sum + Average)

Resumen

Net: Administrar campos de valor de una tabla dinámica en Aspose.Cells para .NET

Agregar un campo a la región de datos

Cambiar la función de resumen

Representar campos de valor en el eje de fila o columna

Net: Agregar campos de filtro a una tabla dinámica en Aspose.Cells para .NET

Introducción

Agregar un campo de filtro

Agregar un campo de filtro con AddFieldToArea

Agregar un campo de filtro con PageFields.Add

Filtrado de selección única (mostrar un elemento de página)

Mostrar todos los elementos

Mostrar un elemento específico

Filtrado de selección múltiple

¿Qué API y qué modo debo usar?

Net: Eliminar la tabla dinámica de una hoja de cálculo

Net: Guardar tabla dinámica en archivo ODS

Código de Muestra

Cambiaron los Datos de Origen — Use `PivotCache.Refresh()`

Solo Cambió la Vista/Diseño — Use `CalculateData()`

Migración desde el Método Obsoleto `PivotTable.RefreshData()`