Como criar tabelas dinâmicas no Excel com C# usando IronXL

O que é uma Tabela Dinâmica do Excel?

Uma tabela dinâmica é uma das ferramentas analíticas mais poderosas em software de planilhas. Ela resume grandes conjuntos de dados agrupando linhas, agregando valores e projetando resultados em um layout de tabela cruzada -- tudo sem exigir que você escreva uma única fórmula manualmente. A documentação oficial da Microsoft sobre tabela dinâmica fornece uma visão geral completa do que o recurso faz dentro do Excel em si.

Tabelas dinâmicas aparecem no Microsoft Excel, Google Sheets, Apple Numbers, e na maioria das outras ferramentas de planilha. O conceito central é sempre o mesmo: você define campos de linha, campos de coluna, e campos de valor, e a ferramenta constrói uma matriz de resumo para você. Quando os dados subjacentes mudam, você atualiza a tabela dinâmica e o resumo é atualizado automaticamente.

No código C# do lado do servidor, você tem duas opções amplas:

• Interop C# -- automatiza um processo Excel em execução através de COM para criar um objeto de tabela dinâmica genuíno dentro de um arquivo XLSX
• IronXL com agregação LINQ -- lê a pasta de trabalho na memória, computa o mesmo resumo em código .NET gerenciado, e escreve o resultado em uma nova planilha

Ambas as opções produzem uma saída útil. Mas apenas um deles funciona de maneira confiável em ambientes de implantação modernos.

Como Criar uma Tabela Dinâmica Usando Interop C#?

A Interop do C# Excel fornece acesso direto à funcionalidade nativa de tabela dinâmica do Excel por meio da automação COM. Você cria um objeto Excel.Application, abre uma planilha, define um cache de tabela dinâmica apontando para um intervalo de dados e, em seguida, configura campos de linha, campos de coluna e campos de dados.

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

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

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

Quais problemas o Interop C# cria?

A abordagem Interop apresenta vários desafios significativos que se acumulam rapidamente na implantação do mundo real. O Stack Overflow e outros recursos de programação continuam a recomendá-lo porque muitos tópicos foram escritos no início dos anos 2000 e desde então foram bloqueados -- então o conselho está congelado no tempo.

Dependências de implantação -- cada máquina que executa seu código deve ter uma cópia licenciada do Microsoft Office instalada, incluindo servidores de produção e agentes de construção CI/CD. Isso adiciona tanto custo de licenciamento quanto complexidade de implantação que é totalmente evitável com alternativas modernas.

Encargo de gerenciamento de memória -- Objetos COM devem ser liberados explicitamente usando Marshal.ReleaseComObject(). Perder mesmo um objeto faz com que os processos do Excel fiquem presos na memória indefinidamente, conforme extensivamente documentado no Stack Overflow. Em um serviço de longa duração ou em um aplicativo web ASP.NET, isso se torna um vazamento crítico de recursos.

Restrições de plataforma -- Interop só funciona no Windows com o Office instalado. Você não pode executá-lo no Linux, macOS, em contêineres Docker, ou em plataformas sem servidor como Azure Functions ou AWS Lambda. Isso bloqueia você de arquiteturas modernas nativas da nuvem completamente.

Gargalos de desempenho -- iniciar uma instância de aplicativo Excel é lento e consome muitos recursos. Para processamento em lote no lado do servidor, onde você pode precisar gerar dezenas ou centenas de relatórios, essa sobrecarga de inicialização se torna uma séria restrição de processamento.

Fragilidade de compatibilidade de versão -- diferentes versões do Office expõem interfaces COM ligeiramente diferentes. Código que funciona contra o Office 2019 pode se comportar de forma diferente contra o Office 2016 ou Microsoft 365, e você não tem como fixar a versão em uma implantação. A documentação da Microsoft sobre assemblies Interop do Office observa essas limitações de versionamento como uma limitação conhecida.

Incompatibilidade com CI/CD -- a maioria dos ambientes de integração contínua não tem o Office instalado. Testar seu código de geração de tabela dinâmica requer ou simular toda a camada COM ou manter um agente Windows especial com uma instalação licenciada do Office.

Para qualquer novo aplicativo .NET direcionado ao .NET 6 ou posterior -- incluindo o .NET 10 -- essas restrições tornam o Interop uma escolha impraticável.

Como o IronXL Cria Tabelas Dinâmicas Sem Interop?

IronXL aborda a criação de tabela dinâmica de maneira diferente. Em vez de controlar um processo Excel externo por meio do COM, o IronXL lê sua planilha em memória gerenciada do .NET, dando-lhe acesso direto aos valores das células, fórmulas e estrutura da planilha. Você então constrói agregações ao estilo pivot usando consultas LINQ padrão e escreve os resultados de volta para uma nova planilha.

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

Como Criar Resumos Dinâmicos Usando Fórmulas do Excel?

Para cenários onde você quer que a folha de resumo se mantenha ativa -- recalculando automaticamente sempre que os dados de origem mudarem -- o IronXL permite que você escreva strings de fórmulas do Excel diretamente nas células. Isso lhe dá um comportamento semelhante ao auto-refresco de uma tabela dinâmica, sem qualquer dependência de Interop.

As funções principais aqui são SUMIFS e COUNTIFS. SUMIFS soma um intervalo com base em condições de coluna de múltiplos critérios; COUNTIFS conta linhas correspondentes. Ambas aceitam referências a planilhas nomeadas, para que você possa apontar sua folha de resumo diretamente para a folha de dados de origem pelo nome.

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

Como se comparam as duas abordagens?

Antes de escolher uma abordagem, é útil ver as compensações lado a lado. A tabela abaixo cobre as dimensões mais importantes para o desenvolvimento em .NET de produção:

O único cenário onde o Interop tem uma vantagem clara é quando você precisa especificamente do objeto nativo da tabela dinâmica do Excel embutido no arquivo XLSX -- por exemplo, se os usuários a jusante devem interagir com ele usando a interface da tabela dinâmica do Excel (aprofundando, filtrando, alterando funções de agregação de forma interativa). Em todos os outros cenários, a abordagem do IronXL é mais rápida de escrever, mais fácil de implantar e muito mais portátil.

Qual abordagem você deve escolher?

A escolha certa depende do seu ambiente de implantação e das necessidades dos seus usuários.

Escolha Interop C# apenas quando:

• Seus usuários exigem objetos nativos de tabela dinâmica do Excel que podem manipular interativamente dentro da interface do Excel
• Você está visando um ambiente de desktop Windows fechado onde o Office é garantido para estar instalado em cada máquina
• Você está mantendo código legado do .NET Framework que já depende do Interop e uma reescrita não é justificada no momento

Escolha o IronXL quando:

• Você está implantando em um servidor, um contêiner ou qualquer ambiente de nuvem (Azure, AWS, GCP)
• Você precisa de suporte multiplataforma para builds baseados em Linux, macOS ou Docker
• Você deseja código limpo e fácil de manter sem o gerenciamento de ciclo de vida do COM
• Você está mirando no .NET 5, 6, 7, 8, 9 ou 10
• Você quer evitar taxas de licenciamento do Microsoft Office em infraestrutura de servidor
• Você precisa de processamento em lote rápido de muitos livros de trabalho sem inicialização de processo do Excel por arquivo

Para a grande maioria dos aplicativos modernos .NET, o IronXL é a escolha prática. A saída baseada em agregação atende a todos os requisitos reais de relatórios, e você ganha total portabilidade em troca.

Você pode explorar mais capacidades -- incluindo formatação de células, avaliação de fórmulas, validação de dados e geração de gráficos -- na documentação do IronXL e na biblioteca de exemplos do IronXL.

Como começar a usar o IronXL hoje?

A biblioteca do IronXL está disponível no NuGet e leva menos de um minuto para ser adicionada a qualquer projeto .NET:

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

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

Uma vez instalada, você pode carregar um livro de trabalho existente ou criar um novo, ler e escrever valores de células, aplicar fórmulas, definir strings de formato e salvar em XLSX -- tudo com uma API limpa e bem documentada. Não há COM, nenhuma dependência do Office, e nenhuma configuração especial de servidor necessária.

Para documentação completa da API, veja o guia de introdução ao IronXL, o guia de migração do C# Excel Interop e os exemplos de código do IronXL. Você também pode compará-lo contra outras bibliotecas de Excel nos artigos de comparação do IronXL.

Uma licença de teste gratuita permite que você teste a funcionalidade completa em seu próprio projeto antes de se comprometer. Quando você estiver pronto para implantar em produção, uma licença comercial do IronXL remove a marca d'água de teste e inclui suporte prioritário. Comece com o teste gratuito e veja o quanto a automação de Excel multiplataforma pode ser mais simples.