Ícono de mensaje
Saltar al pie de página
  1. IronXL
  2. Blog de IronXL
  3. Usando IronXL
  4. Crear Pivot de Excel en C#
USANDO IRONXL

Cómo crear una tabla dinámica de Excel en C#

Jordi Bardia
Jordi Bardia
Publicado:

Generar tablas dinámicas de forma programática en Excel requiere ya sea Interoperabilidad de C# con sus dependencias de Office o bibliotecas modernas como IronXL que funcionan de manera independiente. Este tutorial demuestra ambos enfoques, destacando por qué cada vez más desarrolladores eligen IronXL en lugar de métodos tradicionales de Interop.

En este artículo, aprenderemos cómo editar, crear, diseñar y calcular tablas y grupos dinámicos, con análisis automático y manejo de errores.

¿Qué es una tabla dinámica de Excel?

Un tipo de tabla dinámica es una de las herramientas más poderosas que puedes agregar en Excel. Es una manera fácil y sencilla de resumir grandes conjuntos de datos. Consecuentemente, las tablas dinámicas te permiten mostrar, entender y analizar datos numéricos fácilmente. Las tablas dinámicas están disponibles no solo en Excel, sino también en otros programas como Google Sheets, Apple Numbers y exportaciones CSV. Proporciona una solución para ver datos en vista general, actuando como una consola de datos para permitir que las personas vean su información de una manera significativa, enlazando con la realidad.

Hagamos una tabla dinámica de la manera incorrecta y luego aprendamos a hacerla de la manera correcta en C#:

¿Cómo crear una tabla dinámica en tablas de Excel usando interoperabilidad C#?

C# Excel Interop proporciona acceso directo a la funcionalidad de tabla dinámica de Excel a través de la automatización COM. Aquí está el enfoque tradicional que muchos desarrolladores encuentran al buscar una herramienta para usar para generar una tabla dinámica en C#: (Obsoleto)

Cómo crear tablas dinámicas a la antigua usanza en .NET

using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();
// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;
// Row area and column area 
// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase,
    dataRange,
    Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
    xlPivotSheet.Cells[3, 1],
    "SalesPivot",
    Type.Missing,
    Type.Missing); // fields by field
// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;
Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;
Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);
// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();
// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);
using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();
// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;
// Row area and column area 
// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase,
    dataRange,
    Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
    xlPivotSheet.Cells[3, 1],
    "SalesPivot",
    Type.Missing,
    Type.Missing); // fields by field
// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;
Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;
Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);
// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();
// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este ejemplo de Interop crea una tabla dinámica nativa XL con el Producto como filas, la Región como columnas y las Ventas sumadas en el área de datos. Aunque funcional, este enfoque requiere la instalación de Microsoft Office y una cuidadosa gestión de objetos COM. Consulta la documentación de Microsoft sobre por qué no usar este enfoque es moderno.

¿Qué problemas crea la interoperabilidad de C#?

El enfoque de Interop presenta varios desafíos importantes:

Desafortunadamente, Stack Overflow y otros sitios web de programación continúan recomendándolo porque están atrapados en el tiempo con hilos bloqueados a Ideas desde principios de la década de 2000.

Dependencias de implementación: se requiere la instalación de Microsoft Office en cada máquina que ejecute el código fuente, incluidos los servidores de producción. Esto agrega costos de licencias y complejidad de implementación.

Gestión de memoria: los objetos COM deben liberarse explícitamente usando Marshal.ReleaseComObject(). Faltar siquiera un objeto causa que los procesos de Excel se cuelguen en la memoria, como está ampliamente documentado en Stack Overflow. Considera el caché dinámico.

Detalles de limitación de plataforma: esta solución antigua solo funciona en Windows con Office instalado. Y puede ser increíblemente lenta: confusa para el usuario y puede llevar a fugas de memoria. No hay soporte para Linux, macOS, contenedores Docker o plataformas en la nube como Azure Functions.

Problemas de rendimiento: iniciar instancias de la aplicación Excel es lento y consume muchos recursos, especialmente para el procesamiento del lado del servidor.

Compatibilidad de versiones: diferentes versiones de Office pueden tener interfaces COM variables, causando problemas de compatibilidad entre entornos.

¿Cómo crea IronXL una tabla dinámica mediante programación sin interoperabilidad?

IronXL aborda la creación de tablas dinámicas de manera diferente, usando código gestionado sin dependencias COM. Aunque no crea tablas dinámicas nativas de Excel, proporciona potentes capacidades de agregación:

Cómo crear una tabla dinámica XLSX o XLS programáticamente de la forma moderna:

using IronXL;
using System.Linq;
using System.Data; // Keep this namespace
using static System.Data.DataTableExtensions; // Use 'using static' for DataTableExtensions
class Program
{
    static void Main(string[] args)
    {
        // Load Excel file - no Office required
        WorkBook workbook = WorkBook.Load("SalesData.xlsx");
        WorkSheet dataSheet = workbook.WorkSheets[0];
        // Convert to DataTable for powerful manipulation
        var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers
        // Create pivot-style aggregation using LINQ
        var pivotData = dataTable.AsEnumerable()
            .GroupBy(row => new {
                Product = row["Product"].ToString(),
                Region = row["Region"].ToString()
            }) //range
            .Select(g => new {
                Product = g.Key.Product,
                Region = g.Key.Region,
                TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
                AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
                Count = g.Count()
            }); 
        // Create pivot report worksheet
        WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");
        // Build cross-tabulation structure
        var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
        var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);
        // Create headers
        pivotSheet["A1"].Value = "Product/Region";
        int col = 2;
        foreach (var region in regions)
        {
            pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // string  
            col++;
        }
        // Populate pivot data
        int row = 2;
        foreach (var product in products)
        {
            pivotSheet[$"A{row}"].Value = product;
            col = 2;
            foreach (var region in regions)
            {
                var sales = pivotData
                    .Where(p => p.Product == product && p.Region == region)
                    .Select(p => p.TotalSales)
                    .FirstOrDefault();
                pivotSheet[$"{(char)('A' + col - 1)}{row}"].Value = sales;
                col++;
            }
            row++;
        }
        // Add totals using Excel formulas
        pivotSheet[$"A{row}"].Value = "Total"; // grand totals
        for (int c = 2; c <= regions.Count() + 1; c++)
        {
            pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
        }
        // Proceeding to apply formatting
        var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
        dataRange.FormatString = "$#,##0.00";
        workbook.SaveAs("PivotReport.xlsx");
    }
}
using IronXL;
using System.Linq;
using System.Data; // Keep this namespace
using static System.Data.DataTableExtensions; // Use 'using static' for DataTableExtensions
class Program
{
    static void Main(string[] args)
    {
        // Load Excel file - no Office required
        WorkBook workbook = WorkBook.Load("SalesData.xlsx");
        WorkSheet dataSheet = workbook.WorkSheets[0];
        // Convert to DataTable for powerful manipulation
        var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers
        // Create pivot-style aggregation using LINQ
        var pivotData = dataTable.AsEnumerable()
            .GroupBy(row => new {
                Product = row["Product"].ToString(),
                Region = row["Region"].ToString()
            }) //range
            .Select(g => new {
                Product = g.Key.Product,
                Region = g.Key.Region,
                TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
                AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
                Count = g.Count()
            }); 
        // Create pivot report worksheet
        WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");
        // Build cross-tabulation structure
        var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
        var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);
        // Create headers
        pivotSheet["A1"].Value = "Product/Region";
        int col = 2;
        foreach (var region in regions)
        {
            pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // string  
            col++;
        }
        // Populate pivot data
        int row = 2;
        foreach (var product in products)
        {
            pivotSheet[$"A{row}"].Value = product;
            col = 2;
            foreach (var region in regions)
            {
                var sales = pivotData
                    .Where(p => p.Product == product && p.Region == region)
                    .Select(p => p.TotalSales)
                    .FirstOrDefault();
                pivotSheet[$"{(char)('A' + col - 1)}{row}"].Value = sales;
                col++;
            }
            row++;
        }
        // Add totals using Excel formulas
        pivotSheet[$"A{row}"].Value = "Total"; // grand totals
        for (int c = 2; c <= regions.Count() + 1; c++)
        {
            pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
        }
        // Proceeding to apply formatting
        var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
        dataRange.FormatString = "$#,##0.00";
        workbook.SaveAs("PivotReport.xlsx");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Así que, en 2025, así es como se crean las tablas dinámicas.

Resultado

Cómo crear una tabla dinámica de Excel en C#: Figura 1 - El archivo de Excel original vs. la tabla dinámica que creamos mostrando las celdas.

¿Cómo crear resúmenes dinámicos con fórmulas IronXL?

Para escenarios que requieren actualizaciones dinámicas similares a crear una tabla dinámica, calcular la funcionalidad de actualización de tabla dinámica, IronXL puede aprovechar las fórmulas integradas de Excel para obtener tus respuestas. En general, esto es preferible a la respuesta anterior: Tu registro está siendo manejado de una manera mucho más moderna y elegante, con código que una persona puede entender fácilmente. Fácil de configurar, Sin la necesidad de contactar soporte o leer un manual.

// Load the workbook
WorkBook workbook = WorkBook.Load(inputPath);
// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet";
// Convert worksheet to DataTable
DataTable dataTable = dataSheet.ToDataTable(true);
// Create new summary worksheet
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");
// Get unique product-region combinations
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region);
// Add header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";
// Populate rows with formulas
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;
    // Adjust column references if your Sales column is C (not D)
    summarySheet[$"C{rowIndex}"].Formula =
        $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
    summarySheet[$"D{rowIndex}"].Formula =
        $"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
    rowIndex++;
}
// Optional: add total row
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";
// Save output file
workbook.SaveAs(outputPath);  //filename
// Load the workbook
WorkBook workbook = WorkBook.Load(inputPath);
// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet";
// Convert worksheet to DataTable
DataTable dataTable = dataSheet.ToDataTable(true);
// Create new summary worksheet
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");
// Get unique product-region combinations
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region);
// Add header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";
// Populate rows with formulas
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;
    // Adjust column references if your Sales column is C (not D)
    summarySheet[$"C{rowIndex}"].Formula =
        $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
    summarySheet[$"D{rowIndex}"].Formula =
        $"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
    rowIndex++;
}
// Optional: add total row
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";
// Save output file
workbook.SaveAs(outputPath);  //filename
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Estas fórmulas mantienen conexiones vivas con los datos de origen, actualizando automáticamente cuando cambia la hoja de datos, similar al comportamiento de actualización de tablas dinámicas pero sin dependencias de Interop.

Si aplicamos este código al archivo de ejemplo Excel (XLS / XLSX) del ejemplo anterior, obtendríamos este resultado de campos en la página:

Cómo crear una tabla dinámica de Excel en C#: Figura 2 - Nota: La salida de resúmenes dinámicos de C# se observa en el contexto de ubicación.

Comparación de la interoperabilidad de C# con IronXL para tablas dinámicas

Aspecto

Interoperabilidad de C#

IronXL

Se requiere oficina

Sí - Instalación completa

No - Biblioteca independiente

Soporte de Plataforma

Sólo Windows

Windows, Linux, macOS, Docker

Gestión de Memoria

Se requiere limpieza manual de COM

Recolección automática de basura .NET

Despliegue

Complejo - Licencias de oficina

Simple - DLL única

Actuación

Lento: inicio del proceso de Excel

Rápido - Cálculos en memoria

Compatible con la nube

No - Limitaciones de Azure

Sí - Compatibilidad con Azure Functions

Tablas dinámicas nativas

Sí

No - Alternativas de agregación

Velocidad de desarrollo

Lento - Complejidad COM

API rápida e intuitiva

¿Qué enfoque debería elegir?

Elige Interoperabilidad de C# cuando:

  • Los objetos de tabla dinámica nativos en Excel son absolutamente necesarios
  • Trabajas exclusivamente en Windows con Office instalado en cada máquina objetivo
  • Solo despliegas en sistemas de escritorio que administras
  • Código legado existente depende de Interop
  • Utilizando la versión .NET Framework legada

Elige IronXL cuando:

  • Desplegando en entornos de servidores o en la nube y servicios (Azure, AWS...)
  • Construyendo aplicaciones multiplataforma
  • Requiriendo mejor rendimiento y confiabilidad
  • Evitando costos de licenciamiento de Office
  • Necesitando código más simple y mantenible
  • Soportando Mac, iOS, Android y/o Linux
  • Trabajando en el moderno .NET Framework Core y .NET 5,6,7,8,9,10
  • Deseas acceso completo en tu consola de desarrollo / IDE para configurar las configuraciones de cada campo en la tabla dinámica programáticamente desde tus rangos de datos.

Conclusión

Aunque C# Excel Interop puede desarrollar tablas dinámicas nativas, sus restricciones de implementación y complejidad lo hacen cada vez más impráctico para aplicaciones modernas. IronXL ofrece poderosas alternativas a través de la agregación de datos y resúmenes basados en fórmulas, eliminando las dependencias de Office mientras mantiene capacidades analíticas. Por favor, vota, comenta o suscríbete si esto ha sido útil.

Para los desarrolladores que buscan una opción alternativa para desarrollar tablas dinámicas sin Interop, IronXL ofrece un camino superior que evita las complicaciones COM, funciona en todas las plataformas y simplifica la implementación. La pérdida de no tener objetos dinámicos nativos se compensa con una mayor flexibilidad, mejor rendimiento y eliminación de los requisitos de licenciamiento de Office.

Empiece con IronXL ahora.
green arrow pointer

¿Listo para modernizar tu automatización de Excel y crear tu propio código de tabla dinámica en moderno C#?

IronXL se puede implementar en tus aplicaciones C# en segundos a través del NuGet Package Manager. Prueba la versión de prueba gratuita para eliminar las dependencias Interop en tus aplicaciones de producción.

Preguntas Frecuentes

¿Qué es una tabla dinámica en Excel?

Una tabla dinámica en Excel es una herramienta poderosa usada para resumir, analizar, explorar y presentar datos. Permite a los usuarios transformar columnas en filas y viceversa, posibilitando un análisis de datos dinámico.

¿Por qué usar IronXL para crear tablas dinámicas de Excel en C#?

IronXL permite a los desarrolladores crear tablas dinámicas de Excel en C# sin depender de Office Interop, eliminando la necesidad de instalaciones de Excel y reduciendo dependencias, lo que lo hace una opción moderna y eficiente.

¿Cómo se compara IronXL con C# Interop para operaciones de Excel?

IronXL ofrece un enfoque más simplificado e independiente en comparación con C# Interop, que requiere instalaciones de Office. IronXL simplifica la creación de tablas dinámicas y otras operaciones de Excel sin las complicaciones de Interop.

¿Puedo generar tablas dinámicas sin tener Excel instalado?

Sí, usando IronXL, puedes generar tablas dinámicas en tus aplicaciones de C# sin tener Excel instalado, ya que opera de manera independiente de Microsoft Office.

¿Es IronXL adecuado para grandes conjuntos de datos?

IronXL está diseñado para manejar grandes conjuntos de datos de manera eficiente, por lo que es adecuado para aplicaciones que requieren una manipulación de datos robusta y generación de tablas dinámicas.

¿Cuáles son las ventajas de usar IronXL sobre los métodos tradicionales?

IronXL proporciona una alternativa moderna y sin dependencias a los métodos tradicionales como C# Interop, ofreciendo facilidad de uso, flexibilidad y soporte para operaciones de datos complejas sin la necesidad de instalaciones de Excel.

¿Necesito aprender VBA para usar IronXL en tablas dinámicas?

No, IronXL permite a los desarrolladores trabajar directamente en C# para crear y gestionar tablas dinámicas, eliminando la necesidad de aprender VBA u otros lenguajes de programación específicos de Excel.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Comenzar prueba gratuita