Criar uma tabela dinâmica no Excel com C# é simples quando você escolhe a biblioteca certa -- Interoperabilidade do Excel requer Office em cada máquina, enquanto o IronXL funciona em qualquer lugar onde .NET esteja em execução. Este guia aborda ambos os métodos com exemplos completos de código, cobrindo configuração, agregação de dados, configuração de campos e considerações de implantação para que você possa tomar a decisão certa para seu projeto.
Antes de escrever uma única linha de código, ajuda entender o que cada abordagem faz por trás das cenas. Interoperabilidade do Excel usa COM (Component Object Model) para controlar diretamente o Microsoft Excel a partir do C#. O processo .NET se comunica com uma instância do Excel em execução, o que significa que o próprio Excel deve estar instalado na máquina. Cada objeto que você manipula - pastas de trabalho, planilhas, intervalos, caches de tabela dinâmica - é uma embalagem COM, e cada um deve ser liberado explicitamente para evitar vazamentos de processo.
IronXL segue um caminho fundamentalmente diferente. Ele lê e escreve o formato de arquivo Open XML diretamente, sem lançar o Excel. O resultado é uma biblioteca padrão do .NET com padrões de objetos familiares, memória coletada por lixo e sem dependência de instalação ou licenciamento do Office. Essa arquitetura torna o IronXL adequado para trabalhos em servidor, contêineres Docker, hosts Linux e qualquer ambiente .NET 6, .NET 8 ou .NET 10.
| Critérios | Interoperabilidade do Excel | IronXL |
|---|---|---|
| Office necessário | Sim | Não |
| Somente para Windows | Sim | Não -- multiplataforma |
| Gerenciamento de memória | Liberação manual de COM | Automático (GC do .NET) |
| Implantação em servidor | Difícil | Simples |
| Tabela dinâmica nativa | API completa de tabela dinâmica Excel | Agregação de dados via LINQ |
| Licença necessária | Licença de escritório | Somente licença IronXL |
Interoperabilidade do Excel é distribuído como um pacote NuGet. Execute qualquer um dos seguintes em seu projeto:
Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.ExcelNãote que o pacote por si só não é suficiente -- a máquina de destino deve ter uma versão correspondente do Microsoft Excel instalada e devidamente licenciada. Essa dependência elimina a maioria dos cenários de servidor, contêiner e nuvem.
Instale IronXL através do NuGet sem requisitos adicionais do sistema:
Após a instalação, você pode começar a ler e escrever arquivos Excel imediatamente em qualquer plataforma que suporte .NET. Sem licença do Office, sem registro COM, sem configuração de servidor. Consulte o guia de instalação do IronXL para obter opções adicionais, incluindo instalação offline e configuração de referência de projeto.
O fluxo de trabalho da tabela dinâmica Interop segue uma sequência rígida: criar um cache de pivô a partir de um intervalo de origem, depois construir um objeto PivotTable em uma planilha separada e, em seguida, configurar as orientações dos campos. O exemplo abaixo usa declarações de nível superior em C# compatíveis com .NET 10:
using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
// Launch Excel and set up workbooks
var excelApp = new Excel.Application();
excelApp.Visible = false;
var workbook = excelApp.Workbooks.Add();
var dataSheet = (Excel.Worksheet)workbook.Worksheets[1];
dataSheet.Name = "SalesData";
var pivotSheet = (Excel.Worksheet)workbook.Worksheets.Add();
pivotSheet.Name = "Pivot";
// Populate header row
dataSheet.Cells[1, 1] = "Product";
dataSheet.Cells[1, 2] = "Region";
dataSheet.Cells[1, 3] = "Sales";
// Add sample data rows
object[,] rows = {
{ "Laptop", "Nãorth", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "Nãorth", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "Nãorth", 400 },
{ "Monitor", "South", 500 },
{ "Keyboard", "East", 300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
dataSheet.Cells[i + 2, 1] = rows[i, 0];
dataSheet.Cells[i + 2, 2] = rows[i, 1];
dataSheet.Cells[i + 2, 3] = rows[i, 2];
}
// Build pivot cache from source range
Excel.Range dataRange = dataSheet.Range["A1:C10"];
Excel.PivotCache pivotCache = workbook.PivotCaches().Create(
Excel.XlPivotTableSourceType.xlDatabase, dataRange);
// Create the PivotTable on the pivot sheet
Excel.PivotTables pivotTables = (Excel.PivotTables)pivotSheet.PivotTables();
Excel.PivotTable pivotTable = pivotTables.Add(
pivotCache, pivotSheet.Range["A3"], "SalesPivot");
// Assign field orientations
((Excel.PivotField)pivotTable.PivotFields("Product")).Orientation =
Excel.XlPivotFieldOrientation.xlRowField;
((Excel.PivotField)pivotTable.PivotFields("Region")).Orientation =
Excel.XlPivotFieldOrientation.xlColumnField;
((Excel.PivotField)pivotTable.PivotFields("Sales")).Orientation =
Excel.XlPivotFieldOrientation.xlDataField;
// Enable grand totals
pivotTable.RowGrand = true;
pivotTable.ColumnGrand = true;
// Save and close
workbook.SaveAs(@"C:\output\pivot_interop.xlsx");
workbook.Close(false);
excelApp.Quit();
// Release every COM object -- skipping any of these causes Excel to stay in memory
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotTables);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(dataRange);
Marshal.ReleaseComObject(pivotSheet);
Marshal.ReleaseComObject(dataSheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);Imports Excel = Microsoft.Office.Interop.Excel
Imports System.Runtime.InteropServices
' Launch Excel and set up workbooks
Dim excelApp As New Excel.Application()
excelApp.Visible = False
Dim workbook As Excel.Workbook = excelApp.Workbooks.Add()
Dim dataSheet As Excel.Worksheet = CType(workbook.Worksheets(1), Excel.Worksheet)
dataSheet.Name = "SalesData"
Dim pivotSheet As Excel.Worksheet = CType(workbook.Worksheets.Add(), Excel.Worksheet)
pivotSheet.Name = "Pivot"
' Populate header row
dataSheet.Cells(1, 1) = "Product"
dataSheet.Cells(1, 2) = "Region"
dataSheet.Cells(1, 3) = "Sales"
' Add sample data rows
Dim rows As Object(,) = {
{"Laptop", "Nãorth", 1200},
{"Laptop", "South", 1500},
{"Phone", "Nãorth", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "Nãorth", 400},
{"Monitor", "South", 500},
{"Keyboard", "East", 300}
}
For i As Integer = 0 To rows.GetLength(0) - 1
dataSheet.Cells(i + 2, 1) = rows(i, 0)
dataSheet.Cells(i + 2, 2) = rows(i, 1)
dataSheet.Cells(i + 2, 3) = rows(i, 2)
Next
' Build pivot cache from source range
Dim dataRange As Excel.Range = dataSheet.Range("A1:C10")
Dim pivotCache As Excel.PivotCache = workbook.PivotCaches().Create(Excel.XlPivotTableSourceType.xlDatabase, dataRange)
' Create the PivotTable on the pivot sheet
Dim pivotTables As Excel.PivotTables = CType(pivotSheet.PivotTables(), Excel.PivotTables)
Dim pivotTable As Excel.PivotTable = pivotTables.Add(pivotCache, pivotSheet.Range("A3"), "SalesPivot")
' Assign field orientations
CType(pivotTable.PivotFields("Product"), Excel.PivotField).Orientation = Excel.XlPivotFieldOrientation.xlRowField
CType(pivotTable.PivotFields("Region"), Excel.PivotField).Orientation = Excel.XlPivotFieldOrientation.xlColumnField
CType(pivotTable.PivotFields("Sales"), Excel.PivotField).Orientation = Excel.XlPivotFieldOrientation.xlDataField
' Enable grand totals
pivotTable.RowGrand = True
pivotTable.ColumnGrand = True
' Save and close
workbook.SaveAs("C:\output\pivot_interop.xlsx")
workbook.Close(False)
excelApp.Quit()
' Release every COM object -- skipping any of these causes Excel to stay in memory
Marshal.ReleaseComObject(pivotTable)
Marshal.ReleaseComObject(pivotTables)
Marshal.ReleaseComObject(pivotCache)
Marshal.ReleaseComObject(dataRange)
Marshal.ReleaseComObject(pivotSheet)
Marshal.ReleaseComObject(dataSheet)
Marshal.ReleaseComObject(workbook)
Marshal.ReleaseComObject(excelApp)Cada wrapper COM requer uma chamada Marshal.ReleaseComObject correspondente. Faltando mesmo uma referência, o processo Excel persiste em segundo plano, consumindo memória e manipuladores de arquivos até que o processo host termine. Essa carga de limpeza escala com a complexidade das suas operações de planilha.
IronXL não expõe uma API nativa de tabela dinâmica da mesma forma que Interop -- o formato de pivô Open XML possui centenas de atributos XML, e a maioria dos requisitos de negócios são atendidos de forma mais confiável com agregação explícita LINQ escrita em C# simples. A saída é uma planilha de resumo limpa que calcula corretamente quando o arquivo é aberto, sem depender do Excel para atualizar um cache de pivô.
using IronXL;
using System.Data;
// Create workbook and populate source data
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet dataSheet = workbook.CreateWorkSheet("SalesData");
dataSheet["A1"].Value = "Product";
dataSheet["B1"].Value = "Region";
dataSheet["C1"].Value = "Sales";
object[,] rows = {
{ "Laptop", "Nãorth", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "Nãorth", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "Nãorth", 400 },
{ "Monitor", "South", 500 },
{ "Keyboard", "East", 300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
dataSheet[$"A{i + 2}"].Value = rows[i, 0];
dataSheet[$"B{i + 2}"].Value = rows[i, 1];
dataSheet[$"C{i + 2}"].Value = rows[i, 2];
}
// Aggregate data with LINQ -- equivalent to a pivot table row/column/value layout
DataTable table = dataSheet["A1:C10"].ToDataTable(true);
var summary = table.AsEnumerable()
.GroupBy(row => row.Field<string>("Product"))
.Select((group, idx) => new
{
Product = group.Key,
TotalSales = group.Sum(r => Convert.ToDecimal(r["Sales"])),
RegionCount = group.Select(r => r.Field<string>("Region")).Distinct().Count(),
RowIndex = idx + 2
})
.OrderByDescending(x => x.TotalSales);
// Write the summary sheet
WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Total Sales";
summarySheet["C1"].Value = "Regions";
foreach (var item in summary)
{
summarySheet[$"A{item.RowIndex}"].Value = item.Product;
summarySheet[$"B{item.RowIndex}"].Value = (double)item.TotalSales;
summarySheet[$"C{item.RowIndex}"].Value = item.RegionCount;
}
// Apply currency format to the sales column
summarySheet["B:B"].FormatString = "$#,##0.00";
// Bold the header row
summarySheet["A1:C1"].Style.Font.Bold = true;
// Save -- no COM cleanup needed
workbook.SaveAs(@"C:\output\analysis_ironxl.xlsx");Imports IronXL
Imports System.Data
Imports System.Linq
' Create workbook and populate source data
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim dataSheet As WorkSheet = workbook.CreateWorkSheet("SalesData")
dataSheet("A1").Value = "Product"
dataSheet("B1").Value = "Region"
dataSheet("C1").Value = "Sales"
Dim rows As Object(,) = {
{"Laptop", "Nãorth", 1200},
{"Laptop", "South", 1500},
{"Phone", "Nãorth", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "Nãorth", 400},
{"Monitor", "South", 500},
{"Keyboard", "East", 300}
}
For i As Integer = 0 To rows.GetLength(0) - 1
dataSheet($"A{i + 2}").Value = rows(i, 0)
dataSheet($"B{i + 2}").Value = rows(i, 1)
dataSheet($"C{i + 2}").Value = rows(i, 2)
Next
' Aggregate data with LINQ -- equivalent to a pivot table row/column/value layout
Dim table As DataTable = dataSheet("A1:C10").ToDataTable(True)
Dim summary = table.AsEnumerable() _
.GroupBy(Function(row) row.Field(Of String)("Product")) _
.Select(Function(group, idx) New With {
.Product = group.Key,
.TotalSales = group.Sum(Function(r) Convert.ToDecimal(r("Sales"))),
.RegionCount = group.Select(Function(r) r.Field(Of String)("Region")).Distinct().Count(),
.RowIndex = idx + 2
}) _
.OrderByDescending(Function(x) x.TotalSales)
' Write the summary sheet
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("Summary")
summarySheet("A1").Value = "Product"
summarySheet("B1").Value = "Total Sales"
summarySheet("C1").Value = "Regions"
For Each item In summary
summarySheet($"A{item.RowIndex}").Value = item.Product
summarySheet($"B{item.RowIndex}").Value = CDbl(item.TotalSales)
summarySheet($"C{item.RowIndex}").Value = item.RegionCount
Next
' Apply currency format to the sales column
summarySheet("B:B").FormatString = "$#,##0.00"
' Bold the header row
summarySheet("A1:C1").Style.Font.Bold = True
' Save -- no COM cleanup needed
workbook.SaveAs("C:\output\analysis_ironxl.xlsx")Não há objetos COM para liberar, nenhum processo Excel para encerrar e nenhuma licença do Office para gerenciar. O mesmo código compila e executa em Linux, macOS e Windows sem modificação. Para mais detalhes sobre a API de agregação, visite a documentação do IronXL WorkSheet.
Implantar um aplicativo baseado em Interop envolve verificar se o ambiente alvo executa Windows, tem a versão correta do Office instalada, e possui permissões de automação COM configuradas no servidor. Ambientes hospedados em nuvem e workloads containerizados geralmente não conseguem atender a esses requisitos sem adicionar infraestrutura de desktop Windows virtualizada, o que aumenta significativamente o custo e a complexidade operacional.
IronXL não possui tais restrições. Adicione o pacote NuGet, configure seu framework de destino para .NET 6 ou posterior, e o aplicativo é implantado em qualquer host -- incluindo contêineres Linux, Azure App Service em Linux, AWS Lambda, e servidores Windows locais. A página de requisitos de sistema do IronXL lista a matriz de compatibilidade completa.
Falhas no Interop surgem como exceções COM (COMException) que são difíceis de mapear para mensagens visíveis pelo usuário. Desajustes de versão entre a versão do Office instalada e o assembly Interop adicionam outro modo de falha. Depurar esses problemas geralmente requer reproduzir a versão exata do Office em uma máquina de desenvolvimento.
O IronXL lança subclasses padrão de System.Exception com mensagens descritivas. Você pode encapsular operações de arquivo em um bloco try-catch e apresentar um feedback significativo sem entender códigos de erro COM. O guia de solução de problemas do IronXL cobre exceções comuns e suas resoluções.
Objetos COM mantêm memória não gerenciada. Se seu código processa muitas planilhas ou é executado em um loop, falhar em liberar corretamente cada referência provoca crescimento de memória ao longo do tempo -- um problema difícil de detectar até que cause um incidente de produção. Interop também é inerentemente single-threaded porque controla uma única janela do Excel.
IronXL usa objetos gerenciados apoiados pelo coletor de lixo .NET. A memória é recuperada automaticamente quando os objetos saem de escopo. Processar vários workbooks em paralelo é direto porque não há estado COM compartilhado para proteger com locks.
A ferramenta certa depende de duas restrições: onde o código é executado e se o XML de tabela dinâmica nativo é necessário.
Escolha Interoperabilidade do Excel quando:
Escolha IronXL quando:
Para a maioria dos novos projetos .NET 10, IronXL é o padrão prático. A biblioteca IronXL também cobre leitura de arquivos Excel em C#, criação de gráficos, aplicação de estilos a células, trabalho com fórmulas, e exportação de dados Excel para DataTable -- reduzindo a necessidade de múltiplas bibliotecas em sua pilha.
Além da agregação básica, IronXL fornece vários recursos que suportam fluxos de trabalho de análise de dados mais ricos:
Você pode ordenar um intervalo em ordem crescente ou decrescente antes de escrever uma folha de resumo. Isso garante que a saída sempre apresente os dados em uma ordem consistente, tornando o processamento a jusante mais previsível. Consulte a documentação de ordenação do IronXL para opções de ordenação em nível de alcance.
Destaque outliers ou limiares aplicando regras regras de formatação condicional programaticamente. Por exemplo, você pode colorir células na folha de resumo de vermelho quando as vendas ficam abaixo de uma meta, proporcionando uma visão instantânea sem exigir que os usuários finais configurem as regras manualmente.
Se os dados de origem vierem de uma planilha existente em vez de um banco de dados, você pode carregá-los diretamente com WorkBook.Load:
using IronXL;
WorkBook existing = WorkBook.Load(@"C:\data\sales_report.xlsx");
WorkSheet sheet = existing.WorkSheets[0];
// Read column C starting at row 2
var salesValues = sheet["C2:C100"]
.Where(cell => cell.Value != null && cell.Value.ToString() != string.Empty)
.Select(cell => cell.DecimalValue)
.ToList();
decimal total = salesValues.Sum();
Console.WriteLine($"Total sales from file: {total:C}");Imports IronXL
Dim existing As WorkBook = WorkBook.Load("C:\data\sales_report.xlsx")
Dim sheet As WorkSheet = existing.WorkSheets(0)
' Read column C starting at row 2
Dim salesValues = sheet("C2:C100") _
.Where(Function(cell) cell.Value IsNot Nothing AndAlso cell.Value.ToString() <> String.Empty) _
.Select(Function(cell) cell.DecimalValue) _
.ToList()
Dim total As Decimal = salesValues.Sum()
Console.WriteLine($"Total sales from file: {total:C}")Este padrão funciona para .xlsx, .xls, .csv, e outros formatos suportados pelo IronXL. Detalhes sobre os formatos suportados podem ser encontrados na documentação de formatos de arquivo do IronXL .
Após produzir uma planilha de resumo, você pode exportá-la para CSV para sistemas a jusante que não aceitam Excel:
workbook.SaveAsCsv(@"C:\output\summary.csv");workbook.SaveAsCsv("C:\output\summary.csv")Isso é particularmente útil em pipelines ETL onde o consumidor final é uma ferramenta de importação de banco de dados ou um carregador de data warehouse.
IronXL está disponível sob uma licença de avaliação gratuita que permite avaliar o conjunto completo de recursos sem comprometer-se com uma assinatura. A avaliação coloca uma marca d'água nos arquivos de saída, que você remove ao aplicar uma chave de licença de produção.
Para ativar uma chave de licença no código, defina-a antes de qualquer operação IronXL:
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"Você também pode definir a chave por meio de uma variável de ambiente (IRONXL_LICENSEKEY) ou através de appsettings.json em projetos ASP.NET Core. A página de licenciamento do IronXL descreve todos os níveis disponíveis, incluindo opções para equipe e organização.
Para implantações em produção, reveja a documentação de implantação do IronXL e a biblioteca de tutoriais do IronXL para padrões que abrangem ASP.NET Core, Azure Functions e Docker.
Tabelas dinâmicas do Excel em C# não precisam significar dependência do Office e complexidade COM. Com IronXL, você escreve código .NET simples que executa em qualquer plataforma, gerencia memória automaticamente e integra-se naturalmente com frameworks de teste de unidade e pipelines CI/CD.
Baixe a versão de avaliação gratuita do IronXL e execute os exemplos deste guia com seus próprios dados. Se você encontrar dúvidas, o fórum da comunidade IronXL e o portal de suporte estão disponíveis para usuários em avaliação e licenciados. Quando estiver pronto para implantar, revise as opções de licenciamento para encontrar o plano que se encaixa no tamanho da sua equipe e no volume de uso.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronXL faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
A API do Excel que você precisa, sem as complicações do Office Interop.
