Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. Criar tabela dinâmica no Excel usando interoperabilidade com C#
USANDO O IRONXL

Como criar tabelas dinâmicas no Excel com C# sem interoperabilidade

Jordi Bardia
Jordi Bardia
Atualizado:

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.

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 1 - IronXL

Qual é a Diferença Entre Interoperabilidade do Excel e IronXL?

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.

Interoperabilidade do Excel vs IronXL -- em uma olhada
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

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 2 - Multiplataforma

Como instalar cada biblioteca?

Configurando o Interoperabilidade do Excel

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.Excel
Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.Excel
SHELL

Nã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.

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 3 - Instalação do Interoperabilidade do Excel

Configurando o IronXL

Instale IronXL através do NuGet sem requisitos adicionais do sistema:

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

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.

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 4 - Instalação

Como criar uma tabela dinâmica no Excel com Interop C#?

O fluxo de trabalho da tabela dinâmica Interop segue uma sequência estrita: criar um cache dinâmico 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);
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)
$vbLabelText   $csharpLabel

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.

Como alcançar o mesmo resultado com IronXL?

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

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.

Saída

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 6 - Saída do IronXL

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 7 - Resumo da saída

Quais são as principais diferenças na implantação e manutenção?

Requisitos de Implantação

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.

Tratamento de erros e depuração

Falhas de interoperabilidade surgem como exceções COM (COMException) que são difíceis de mapear para mensagens visíveis ao 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.

IronXL lança erros padrão System.Exception em subclasses 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.

Memória e desempenho

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.

Como escolher entre as duas abordagens?

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:

  • A carga de trabalho é executada apenas em máquinas desktop Windows onde o Office já está instalado
  • Formatação exata de tabela dinâmica nativa (segmentadores, campos de data agrupados, itens calculados) é necessária no arquivo de saída
  • Você mantém uma base de código Interop existente e uma reescrita completa não é justificada

Escolha IronXL quando:

  • A aplicação é executada em um servidor, contêiner ou função em nuvem
  • Implantação em várias plataformas ou Linux é necessária
  • Você deseja uma lógica de agregação de dados que seja testável com testes de unidade, não dependente de um processo do Excel
  • Você precisa processar arquivos Excel em grande escala ou em paralelo

Para a maioria dos novos projetos .NET 10, IronXL é o padrão prático. A biblioteca IronXL também abrange ler arquivos Excel em C#, criar gráficos, aplicar estilos de célula, trabalhar com fórmulas e exportar dados do Excel para DataTable -- reduzindo a necessidade de várias bibliotecas na sua pilha.

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 8 - Recursos

Quais Recursos Adicionais do IronXL Suportam Análise de Dados?

Além da agregação básica, IronXL fornece vários recursos que suportam fluxos de trabalho de análise de dados mais ricos:

Ordenação e Filtragem de Dados

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. Veja a documentação de ordenação do IronXL para opções de ordenação no nível do intervalo.

Aplicando Formatação Condicional

Destaque valores atípicos ou limiares aplicando 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.

Lendo Arquivos Excel Existentes

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

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 .

Exportando para CSV

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");
workbook.SaveAsCsv("C:\output\summary.csv")
$vbLabelText   $csharpLabel

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.

Como Começar com IronXL Gratuitamente?

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";
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
$vbLabelText   $csharpLabel

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 de produção, revise a documentação de implantação do IronXL e a ampla biblioteca de tutoriais do IronXL para padrões abrangendo ASP.NET Core, Azure Functions e Docker.

Como criar uma tabela dinâmica no Excel usando C# Interop vs IronXL: Imagem 9 - Licenciamento

Como Dar o Próximo Passo?

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.

Perguntas frequentes

Qual a vantagem de usar o IronXL em vez do Excel Interop para criar tabelas dinâmicas?

O IronXL oferece uma maneira mais moderna e eficiente de criar tabelas dinâmicas em arquivos do Excel em comparação com a interoperabilidade tradicional do Excel. Ele simplifica o processo e reduz a quantidade de código repetitivo necessário.

Posso criar uma tabela dinâmica no Excel usando C# com IronXL?

Sim, o IronXL oferece um método simples para criar tabelas dinâmicas no Excel usando C#. Ele permite que os desenvolvedores manipulem arquivos do Excel facilmente, sem precisar depender da interoperabilidade do Excel.

O IronXL é compatível com aplicações .NET?

O IronXL é totalmente compatível com aplicações .NET, tornando-se uma excelente escolha para desenvolvedores que desejam integrar funcionalidades do Excel em seus projetos C#.

O IronXL exige que o Excel esteja instalado no sistema?

Não, o IronXL não exige que o Microsoft Excel esteja instalado no sistema. Ele opera de forma independente, o que representa uma vantagem significativa em relação ao Excel Interop, que exige a instalação do Excel.

Como o IronXL simplifica o processo de criação de tabelas dinâmicas?

IronXL simplifica o processo ao fornecer uma API amigável que reduz a necessidade de código repetitivo extenso, tornando o processo de desenvolvimento mais rápido e eficiente.

Quais são os requisitos de sistema para usar o IronXL?

O IronXL requer um ambiente compatível com o framework .NET, mas não precisa que o Microsoft Excel esteja instalado, o que simplifica a implantação e reduz as dependências.

O IronXL consegue lidar com arquivos grandes do Excel de forma eficiente?

Sim, o IronXL foi projetado para lidar com arquivos grandes do Excel de forma eficiente, tornando-o adequado para aplicações comerciais que exigem o processamento de grandes quantidades de dados.

Existe alguma curva de aprendizado para usar o IronXL em comparação com o Excel Interop?

O IronXL foi projetado para ser intuitivo e fácil de aprender, com documentação e exemplos abrangentes, o que facilita sua adoção em comparação com a interoperabilidade com o Excel, que é mais complexa.

Além de criar tabelas dinâmicas, que tipos de operações do Excel o IronXL pode executar?

O IronXL pode executar uma ampla gama de operações no Excel, incluindo leitura e gravação de arquivos do Excel, formatação de células e aplicação de fórmulas, entre outras.

O IronXL consegue exportar tabelas dinâmicas para formatos diferentes do Excel?

Embora o IronXL seja focado principalmente em operações com o Excel, ele também oferece suporte à exportação de dados para outros formatos, como CSV e PDF, dependendo dos requisitos do seu projeto.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim