Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Blog de Excel sobre cómo crear una tabla dinámica
USANDO IRONXL

Cómo crear tablas dinámicas en Excel con C# usando IronXL

Jordi Bardia
Jordi Bardia
Actualizado:

Para generar tablas dinámicas mediante programación en Excel se necesita interoperabilidad con C# y sus dependencias de Office o una biblioteca moderna como IronXL que funciona de forma independiente: este tutorial demuestra ambos enfoques y le muestra exactamente por qué la ruta moderna es la mejor opción.

Históricamente, crear informes de estilo dinámico en código .NET del lado del servidor o multiplataforma ha sido una tarea ardua. La ruta de interoperabilidad COM tradicional lo vincula a una máquina Windows con una instalación completa de Office, genera pérdidas de memoria si pierde una sola llamada de limpieza COM y se desmorona en el momento en que intenta implementar en Linux o en un contenedor Docker. La alternativa moderna (escribir lógica de agregación con IronXL y LINQ) se ejecuta en cualquier lugar donde se ejecute .NET , no requiere licencia de Office y le brinda un código limpio y legible.

Esta guía explica ambas técnicas en detalle. Verá el enfoque de interoperabilidad sin procesar, comprenderá exactamente qué lo hace frágil y luego creará la misma hoja de resumen de estilo pivote usando IronXL en C#. También verá cómo utilizar fórmulas de Excel para obtener resúmenes en vivo y con actualización automática que se comportan como una actualización de tabla dinámica real.

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

Una tabla dinámica es una de las herramientas analíticas más poderosas en el software de hojas de cálculo. Resume grandes conjuntos de datos agrupando filas, agregando valores y proyectando resultados en un diseño de tabulación cruzada, todo ello sin necesidad de escribir una sola fórmula manualmente. La documentación oficial de la tabla dinámica de Microsoft proporciona una descripción detallada de lo que hace la función dentro de Excel.

Las tablas dinámicas aparecen en Microsoft Excel, Google Sheets, Apple Numbers y la mayoría de las demás herramientas de hojas de cálculo. El concepto central es siempre el mismo: usted define campos de fila, campos de columna y campos de valor, y la herramienta crea una matriz de resumen para usted. Cuando cambian los datos subyacentes, se actualiza la tabla dinámica y el resumen se actualiza automáticamente.

En el código del lado del servidor de C#, tienes dos opciones amplias:

  • Interoperabilidad de C# : automatiza un proceso de Excel en ejecución a través de COM para crear un objeto de tabla dinámica nativo genuino dentro de un archivo XLSX
  • IronXL con agregación LINQ : lee el libro de trabajo en la memoria, calcula el mismo resumen en código .NET administrado y escribe el resultado en una nueva hoja de trabajo

Ambas opciones producen un resultado útil. Pero sólo uno de ellos funciona de manera confiable en entornos de implementación modernos.

¿Cómo se crea una tabla dinámica utilizando la interoperabilidad de C#?

C# Excel Interop le brinda acceso directo a la funcionalidad de tabla dinámica nativa de Excel a través de la automatización COM. Crea un objeto Excel.Application, abre un libro de trabajo, define un caché dinámico que apunta a un rango de datos y luego configura campos de fila, campos de columna y campos de datos.

Cómo configurar el código de la tabla dinámica de interoperabilidad

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;

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

// 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;

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

// 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);
$vbLabelText   $csharpLabel

Este ejemplo de Interop crea una tabla dinámica nativa de Excel con Producto como filas, Región como columnas y Ventas sumadas en el área de datos. Si bien produce un objeto de tabla dinámica real dentro del archivo XLSX, requiere que esté instalado Microsoft Office y exige una gestión cuidadosa de los objetos COM. Si pierde una sola llamada Marshal.ReleaseComObject, encontrará procesos obsoletos de Excel acumulándose en el Administrador de tareas.

Cómo instalar IronXL antes de escribir cualquier código

Antes de pasar al enfoque IronXL , instale la biblioteca a través del Administrador de paquetes NuGet :

Install-Package IronXl.Excel
dotnet add package IronXl.Excel
Install-Package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

No se requiere la instalación de Office en el servidor, el contenedor ni la máquina de desarrollo. IronXL lee y escribe archivos XLSX, XLS y CSV completamente en la memoria .NET administrada.

¿Qué problemas crea Interoperabilidad de C#?

El enfoque de interoperabilidad presenta varios desafíos importantes que se agravan rápidamente en la implementación en el mundo real. Stack Overflow y otros recursos de programación continúan recomendándolo porque muchos hilos se escribieron a principios de la década de 2000 y desde entonces han sido bloqueados, por lo que el consejo está congelado en el tiempo.

Dependencias de implementación : cada máquina que ejecuta su código debe tener una copia con licencia de Microsoft Office instalada, incluidos los servidores de producción y los agentes de compilación CI/CD. Esto agrega costos de licencia y complejidad de implementación que son totalmente evitables con alternativas modernas.

Carga de gestión de memoria : los objetos COM deben liberarse explícitamente utilizando Marshal.ReleaseComObject(). La falta de un solo objeto hace que los procesos de Excel se cuelguen en la memoria indefinidamente, como está ampliamente documentado en Stack Overflow . En un servicio de larga duración o en una aplicación web ASP.NET , esto se convierte en una pérdida crítica de recursos.

Restricciones de plataforma : Interop solo funciona en Windows con Office instalado. No se puede ejecutar en Linux, macOS, en contenedores Docker o en plataformas sin servidor como Azure Functions o AWS Lambda. Esto le impide acceder por completo a las arquitecturas nativas de la nube modernas.

Cuellos de botella en el rendimiento : iniciar una instancia de Excel es lento y consume muchos recursos. Para el procesamiento por lotes del lado del servidor, donde podría ser necesario generar docenas o cientos de informes, esta sobrecarga inicial se convierte en una importante limitación del rendimiento.

Fragilidad de compatibilidad de versiones : las diferentes versiones de Office exponen interfaces COM ligeramente diferentes. El código que funciona con Office 2019 puede comportarse de manera diferente con Office 2016 o Microsoft 365, y no hay forma de anclar la versión en una implementación. La documentación de Microsoft sobre ensamblados de interoperabilidad de Office señala estas restricciones de versiones como una limitación conocida.

Incompatibilidad CI/CD : la mayoría de los entornos de integración continua no tienen Office instalado. Para probar el código de generación de su tabla dinámica es necesario simular toda la capa COM o mantener un agente especial de Windows con una instalación de Office con licencia.

Para cualquier aplicación .NET nueva que tenga como destino .NET 6 o posterior (incluido .NET 10), estas restricciones hacen que Interop sea una opción poco práctica.

¿Cómo crea IronXL tablas dinámicas sin interoperabilidad?

IronXL aborda la creación de tablas dinámicas de manera diferente. En lugar de controlar un proceso externo de Excel a través de COM, IronXL lee su libro de trabajo en la memoria .NET administrada, lo que le brinda acceso directo a los valores de las celdas, las fórmulas y la estructura de la hoja de trabajo. Luego, crea agregaciones de estilo pivote utilizando consultas LINQ estándar y escribe los resultados en una nueva hoja de cálculo.

Cómo crear un resumen de tabulación cruzada con IronXL y LINQ

El siguiente ejemplo carga un libro de datos de ventas, calcula una tabulación cruzada de producto por región y escribe el resumen en una nueva hoja de cálculo, todo sin ninguna dependencia de Office:

using IronXL;
using System.Linq;
using System.Data;

// Load Excel file -- no Office installation required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];

// Convert to DataTable for flexible LINQ manipulation
var dataTable = dataSheet.ToDataTable(true); // true = first row as column headers

// Build pivot-style aggregation using LINQ grouping
var pivotData = dataTable.AsEnumerable()
    .GroupBy(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .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 the pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

// Get distinct row and column values
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p).ToList();
var regions  = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r).ToList();

// Write column headers
pivotSheet["A1"].Value = "Product / Region";
for (int c = 0; c < regions.Count; c++)
{
    pivotSheet[$"{(char)('B' + c)}1"].Value = regions[c];
}

// Populate data rows
for (int r = 0; r < products.Count; r++)
{
    pivotSheet[$"A{r + 2}"].Value = products[r];
    for (int c = 0; c < regions.Count; c++)
    {
        var sales = pivotData
            .Where(p => p.Product == products[r] && p.Region == regions[c])
            .Select(p => p.TotalSales)
            .FirstOrDefault();
        pivotSheet[$"{(char)('B' + c)}{r + 2}"].Value = sales;
    }
}

// Add a totals row using Excel SUM formulas
int totalRow = products.Count + 2;
pivotSheet[$"A{totalRow}"].Value = "Total";
for (int c = 0; c < regions.Count; c++)
{
    char col = (char)('B' + c);
    pivotSheet[$"{col}{totalRow}"].Formula = $"=SUM({col}2:{col}{totalRow - 1})";
}

// Apply currency formatting to the data range
var dataRange = pivotSheet[$"B2:{(char)('B' + regions.Count - 1)}{totalRow}"];
dataRange.FormatString = "$#,##0.00";

workbook.SaveAs("PivotReport.xlsx");
using IronXL;
using System.Linq;
using System.Data;

// Load Excel file -- no Office installation required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];

// Convert to DataTable for flexible LINQ manipulation
var dataTable = dataSheet.ToDataTable(true); // true = first row as column headers

// Build pivot-style aggregation using LINQ grouping
var pivotData = dataTable.AsEnumerable()
    .GroupBy(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .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 the pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

// Get distinct row and column values
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p).ToList();
var regions  = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r).ToList();

// Write column headers
pivotSheet["A1"].Value = "Product / Region";
for (int c = 0; c < regions.Count; c++)
{
    pivotSheet[$"{(char)('B' + c)}1"].Value = regions[c];
}

// Populate data rows
for (int r = 0; r < products.Count; r++)
{
    pivotSheet[$"A{r + 2}"].Value = products[r];
    for (int c = 0; c < regions.Count; c++)
    {
        var sales = pivotData
            .Where(p => p.Product == products[r] && p.Region == regions[c])
            .Select(p => p.TotalSales)
            .FirstOrDefault();
        pivotSheet[$"{(char)('B' + c)}{r + 2}"].Value = sales;
    }
}

// Add a totals row using Excel SUM formulas
int totalRow = products.Count + 2;
pivotSheet[$"A{totalRow}"].Value = "Total";
for (int c = 0; c < regions.Count; c++)
{
    char col = (char)('B' + c);
    pivotSheet[$"{col}{totalRow}"].Formula = $"=SUM({col}2:{col}{totalRow - 1})";
}

// Apply currency formatting to the data range
var dataRange = pivotSheet[$"B2:{(char)('B' + regions.Count - 1)}{totalRow}"];
dataRange.FormatString = "$#,##0.00";

workbook.SaveAs("PivotReport.xlsx");
$vbLabelText   $csharpLabel

Esto produce el mismo resumen tabulado cruzado que obtendría de una tabla dinámica nativa de Excel. Tiene control programático total sobre cada celda, fórmula y cadena de formato, y no hay objetos COM que limpiar.

Cómo crear una tabla dinámica en Excel usando Interoperabilidad de C# vs IronXL: Imagen 1: El archivo Excel original vs. la tabla dinámica creada que muestra las celdas.

Empiece con IronXL ahora.
green arrow pointer

¿Cómo crear resúmenes dinámicos utilizando fórmulas de Excel?

Para los escenarios en los que desea que la hoja de resumen permanezca activa (recalculándose automáticamente cada vez que cambian los datos de origen), IronXL le permite escribir cadenas de fórmulas de Excel directamente en las celdas. Esto le proporciona un comportamiento similar a la actualización automática de una tabla dinámica, sin ninguna dependencia de interoperabilidad.

Las funciones clave aquí son SUMIFS y COUNTIFS. SUMIFS suma un rango en función de múltiples condiciones de columna de criterios; COUNTIFS cuenta las filas coincidentes. Ambos aceptan referencias a hojas de trabajo con nombre, por lo que puede apuntar su hoja de resumen directamente a la hoja de datos de origen por nombre.

Cómo escribir agregaciones basadas en fórmulas con IronXL

using IronXL;
using System.Data;

string inputPath  = "SalesData.xlsx";
string outputPath = "DynamicSummary.xlsx";

WorkBook workbook  = WorkBook.Load(inputPath);
WorkSheet dataSheet = workbook.WorkSheets[0];

// Name the data sheet so formula references are stable
dataSheet.Name = "DataSheet";

// Convert to DataTable to enumerate unique product/region combinations
DataTable dataTable = dataSheet.ToDataTable(true);

WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region pairs
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region  = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region)
    .ToList();

// Header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with live SUMIFS / COUNTIFS formulas
for (int i = 0; i < uniqueCombos.Count; i++)
{
    int rowIndex = i + 2;
    var combo = uniqueCombos[i];

    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

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

// Grand total row
int totalRow = uniqueCombos.Count + 2;
summarySheet[$"A{totalRow}"].Value = "Total";
summarySheet[$"C{totalRow}"].Formula = $"=SUM(C2:C{totalRow - 1})";
summarySheet[$"D{totalRow}"].Formula = $"=SUM(D2:D{totalRow - 1})";

workbook.SaveAs(outputPath);
using IronXL;
using System.Data;

string inputPath  = "SalesData.xlsx";
string outputPath = "DynamicSummary.xlsx";

WorkBook workbook  = WorkBook.Load(inputPath);
WorkSheet dataSheet = workbook.WorkSheets[0];

// Name the data sheet so formula references are stable
dataSheet.Name = "DataSheet";

// Convert to DataTable to enumerate unique product/region combinations
DataTable dataTable = dataSheet.ToDataTable(true);

WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region pairs
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region  = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region)
    .ToList();

// Header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with live SUMIFS / COUNTIFS formulas
for (int i = 0; i < uniqueCombos.Count; i++)
{
    int rowIndex = i + 2;
    var combo = uniqueCombos[i];

    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

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

// Grand total row
int totalRow = uniqueCombos.Count + 2;
summarySheet[$"A{totalRow}"].Value = "Total";
summarySheet[$"C{totalRow}"].Formula = $"=SUM(C2:C{totalRow - 1})";
summarySheet[$"D{totalRow}"].Formula = $"=SUM(D2:D{totalRow - 1})";

workbook.SaveAs(outputPath);
$vbLabelText   $csharpLabel

Estas fórmulas mantienen conexiones en vivo con los datos de origen. Cuando alguien actualiza un valor en DataSheet, Excel recalcula el resumen automáticamente en la próxima apertura o actualización, lo que le brinda el mismo comportamiento que el ciclo de actualización de una tabla dinámica nativa, sin necesidad de automatización COM.

Cuando aplica esto al mismo libro de datos de ventas utilizado en el ejemplo anterior, el resultado se ve así:

Cómo crear una tabla dinámica en Excel usando interoperabilidad de C# frente a IronXL: Imagen 2: salida de resúmenes dinámicos de C# mostrada en contexto.

Este enfoque basado en fórmulas también le brinda la posibilidad de agregar formato condicional, barras de datos o conjuntos de íconos a las celdas de resumen utilizando la API de formato de celda de IronXL , lo que hace que sus informes sean visualmente claros sin ningún trabajo manual en la interfaz de usuario de Excel.

¿Cómo se comparan los dos enfoques?

Antes de elegir un enfoque, conviene analizar las ventajas y desventajas. La siguiente tabla describe las dimensiones más importantes para el desarrollo de .NET en producción:

Interoperabilidad de C# vs. IronXL para la generación de tablas dinámicas
Aspecto Interoperabilidad de C# IronXL
Se requiere oficina Sí, instalación completa en cada máquina No: paquete NuGet independiente
Soporte de plataforma Sólo Windows Windows, Linux, macOS, Docker
Gestión de la memoria Se requiere limpieza manual de COM Recolección automática de basura .NET
Complejidad de implementación Alto - Licenciamiento de oficina + instalación Bajo: referencia de DLL única
Actuación Lento: sobrecarga al iniciar el proceso de Excel Rápido: cálculos en memoria
Compatible con la nube No: bloqueado en Azure Functions, AWS Lambda Sí, funciona en cualquier plataforma en la nube
Objeto de tabla dinámica nativo Sí: tabla dinámica completa de Excel No - equivalente basado en agregación
Velocidad de desarrollo Lento - complejidad COM API administrada rápida y fluida
Compatibilidad .NET 10 Limitado: problemas de enlace COM Completo: se dirige a .NET moderno

El único escenario en el que Interop tiene una clara ventaja es cuando se necesita específicamente el objeto de tabla dinámica nativo de Excel integrado en el archivo XLSX; por ejemplo, si los usuarios posteriores deben interactuar con él usando la interfaz de usuario de tabla dinámica integrada de Excel (exploración en profundidad, filtrado, cambio de funciones de agregación de forma interactiva). En cualquier otro escenario, el enfoque de IronXL es más rápido de escribir, más fácil de implementar y mucho más portable.

¿Qué enfoque debería elegir?

La elección correcta depende de su entorno de implementación y de las necesidades de sus usuarios.

Elija Interoperabilidad de C# solo cuando:

  • Sus usuarios necesitan objetos de tabla dinámica nativos de Excel que puedan manipular de forma interactiva dentro de la interfaz de usuario de Excel.
  • Su objetivo es un entorno de escritorio de Windows cerrado donde se garantiza que Office se instalará en todas las máquinas.
  • Está manteniendo un código heredado de .NET Framework que ya depende de Interop y actualmente no se justifica una reescritura.

Elige IronXL cuando:

  • Está implementando en un servidor, un contenedor o cualquier entorno de nube (Azure, AWS, GCP)
  • Necesita soporte multiplataforma para compilaciones basadas en Linux, macOS o Docker
  • Quiere un código limpio y mantenible sin gestión del ciclo de vida COM
  • Su objetivo es .NET 5, 6, 7, 8, 9 o 10
  • Desea evitar las tarifas de licencia de Microsoft Office en la infraestructura del servidor
  • Necesita un procesamiento por lotes rápido de muchos libros de trabajo sin iniciar el proceso de Excel por archivo

Para la gran mayoría de las aplicaciones .NET modernas, IronXL es la opción más práctica. La salida basada en agregación cumple con todos los requisitos de generación de informes y, a cambio, ofrece portabilidad total.

Puede explorar más capacidades, incluido el formato de celdas, la evaluación de fórmulas, la validación de datos y la generación de gráficos, en la documentación de IronXL y la biblioteca de ejemplos de IronXL .

¿Cómo empezar a utilizar IronXL hoy mismo?

La biblioteca IronXL está disponible en NuGet y se agrega a cualquier proyecto .NET en menos de un minuto:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel
Install-Package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

Una vez instalado, puede cargar un libro existente o crear uno nuevo, leer y escribir valores de celdas, aplicar fórmulas, establecer cadenas de formato y guardar en XLSX, todo con una API limpia y bien documentada. No hay COM, ni dependencia de Office, ni se requiere ninguna configuración de servidor especial.

Para obtener la documentación completa de la API, consulte la guía de introducción a IronXL , la guía de migración de interoperabilidad de C# a Excel y los ejemplos de código de IronXL . También puede comparar IronXL con otras bibliotecas de Excel en los artículos de comparación de IronXL .

Una licencia de prueba gratuita le permite probar la funcionalidad completa en su propio proyecto antes de comprometerse. Cuando esté listo para implementar en producción, una licencia comercial IronXL elimina la marca de agua de prueba e incluye soporte prioritario. Comience con la prueba gratuita y vea cuánto más sencilla puede ser la automatización de Excel multiplataforma.

Preguntas Frecuentes

¿Cómo puedo crear tablas dinámicas en Excel usando C# sin interoperabilidad?

Puede crear tablas dinámicas en Excel usando C# sin interoperabilidad mediante IronXL, que ofrece potentes capacidades de manipulación de datos independientemente de las dependencias de Office.

¿Cuáles son las ventajas de utilizar IronXL para generar tablas dinámicas?

IronXL permite a los desarrolladores generar tablas dinámicas sin depender de Excel Interop, eliminando la necesidad de instalaciones de Office y reduciendo la complejidad en la implementación.

¿Es IronXL compatible con las aplicaciones .NET?

Sí, IronXL es totalmente compatible con aplicaciones .NET y proporciona una API fácil de usar para operaciones de Excel, incluida la creación de tablas dinámicas.

¿ IronXL requiere que Excel esté instalado en el servidor?

No, IronXL no requiere la instalación de Excel en el servidor. Funciona de forma independiente, lo que permite una integración perfecta con las aplicaciones del servidor.

¿Puedo manipular datos en Excel usando IronXL?

Sí, IronXL ofrece sólidas funciones de manipulación de datos, lo que permite a los desarrolladores crear, modificar y analizar datos de Excel, incluida la creación de tablas dinámicas.

¿Por qué los desarrolladores podrían preferir IronXL a los métodos de interoperabilidad tradicionales?

Los desarrolladores pueden preferir IronXL a los métodos de interoperabilidad tradicionales debido a su falta de dependencias de Office, su implementación más sencilla y su funcionalidad integral para las operaciones de Excel.

¿Qué características proporciona IronXL para la manipulación de datos de Excel?

IronXL proporciona funciones como leer y escribir archivos Excel, crear y editar hojas de cálculo y generar tablas dinámicas, todo ello sin necesidad de interoperabilidad 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. Prueba gratis

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me