Gerar tabelas dinâmicas programaticamente no Excel requer Interop C# com suas dependências do Office ou uma biblioteca moderna como IronXL que funciona de forma independente -- este tutorial demonstra ambas as abordagens e mostra exatamente por que o caminho moderno é a melhor escolha.
Construir relatórios estilo tabela dinâmica em código .NET do lado do servidor ou multiplataforma historicamente tem sido doloroso. A rota tradicional do COM Interop amarra você a uma máquina Windows com uma instalação completa do Office, gera vazamentos de memória se você perder uma única chamada de limpeza COM e desmorona no momento em que você tenta implantar em Linux ou um contêiner Docker. A alternativa moderna -- escrever lógica de agregação com IronXL e LINQ -- executa em qualquer lugar onde o .NET é executado, não requer licença do Office, e oferece código limpo e legível.
Este guia percorre ambas as técnicas em detalhes. Você verá a abordagem de Interop bruto, entenderá exatamente o que a torna frágil, e então construirá a mesma planilha de resumo estilo tabela dinâmica usando IronXL em C#. Você também verá como usar fórmulas Excel para resumos ao vivo e de atualização automática que se comportam como uma atualização real de tabela dinâmica.
Uma tabela dinâmica é uma das ferramentas analíticas mais poderosas em software de planilhas. Ele 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:
Ambas as opções produzem uma saída útil. Mas apenas um deles funciona de maneira confiável em ambientes de implantação modernos.
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 linhas, campos de colunas 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);Imports Excel = Microsoft.Office.Interop.Excel
Imports System.Runtime.InteropServices
' Create Excel application instance
Dim xlApp As New Excel.Application()
Dim xlWorkbook As Excel.Workbook = xlApp.Workbooks.Open("C:\Data\SalesData.xlsx")
Dim xlSheet As Excel.Worksheet = CType(xlWorkbook.Sheets(1), Excel.Worksheet)
Dim xlPivotSheet As Excel.Worksheet = CType(xlWorkbook.Sheets.Add(), Excel.Worksheet)
' Define data range for pivot table
Dim dataRange As Excel.Range = xlSheet.UsedRange
' Create pivot cache and pivot table
Dim pivotCache As Excel.PivotCache = xlWorkbook.PivotCaches().Create(Excel.XlPivotTableSourceType.xlDatabase, dataRange, Type.Missing)
Dim pivotTable As Excel.PivotTable = pivotCache.CreatePivotTable(xlPivotSheet.Cells(3, 1), "SalesPivot", Type.Missing, Type.Missing)
' Configure pivot table fields
Dim productField As Excel.PivotField = CType(pivotTable.PivotFields("Product"), Excel.PivotField)
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField
productField.Position = 1
Dim regionField As Excel.PivotField = CType(pivotTable.PivotFields("Region"), Excel.PivotField)
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField
regionField.Position = 1
Dim salesField As Excel.PivotField = CType(pivotTable.PivotFields("Sales"), Excel.PivotField)
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)Este exemplo de Interop cria uma tabela de pivot nativa do Excel com Produto como linhas, Região como colunas e Vendas somadas na área de dados. Embora produza um objeto real de tabela dinâmica dentro do arquivo XLSX, requer a instalação do Microsoft Office e exige uma gestão cuidadosa de objetos COM. Perca uma única chamada Marshal.ReleaseComObject e você encontrará processos do Excel obsoletos se acumulando no Gerenciador de Tarefas.
Antes de pular para a abordagem do IronXL, instale a biblioteca através do Gerenciador de Pacotes NuGet:
Não é necessário instalar o Office no servidor, contêiner ou máquina de desenvolvimento. O IronXL lê e escreve arquivos XLSX, XLS e CSV inteiramente em memória gerenciada do .NET.
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.
O fardo do gerenciamento de memória -- Objetos COM devem ser explicitamente liberados 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.
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.
O exemplo a seguir carrega uma planilha de dados de vendas, calcula uma tabela cruzada produto-por-região, e escreve o resumo em uma nova planilha -- tudo sem qualquer dependência do 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");Imports IronXL
Imports System.Linq
Imports System.Data
' Load Excel file -- no Office installation required
Dim workbook As WorkBook = WorkBook.Load("SalesData.xlsx")
Dim dataSheet As WorkSheet = workbook.WorkSheets(0)
' Convert to DataTable for flexible LINQ manipulation
Dim dataTable As DataTable = dataSheet.ToDataTable(True) ' True = first row as column headers
' Build pivot-style aggregation using LINQ grouping
Dim pivotData = dataTable.AsEnumerable() _
.GroupBy(Function(row) New With {
Key .Product = row("Product").ToString(),
Key .Region = row("Region").ToString()
}) _
.Select(Function(g) New With {
Key .Product = g.Key.Product,
Key .Region = g.Key.Region,
Key .TotalSales = g.Sum(Function(row) Convert.ToDecimal(row("Sales"))),
Key .AverageSale = g.Average(Function(row) Convert.ToDecimal(row("Sales"))),
Key .Count = g.Count()
})
' Create the pivot report worksheet
Dim pivotSheet As WorkSheet = workbook.CreateWorkSheet("PivotReport")
' Get distinct row and column values
Dim products = pivotData.Select(Function(p) p.Product).Distinct().OrderBy(Function(p) p).ToList()
Dim regions = pivotData.Select(Function(p) p.Region).Distinct().OrderBy(Function(r) r).ToList()
' Write column headers
pivotSheet("A1").Value = "Product / Region"
For c As Integer = 0 To regions.Count - 1
pivotSheet($"{ChrW(AscW("B"c) + c)}1").Value = regions(c)
Next
' Populate data rows
For r As Integer = 0 To products.Count - 1
pivotSheet($"A{r + 2}").Value = products(r)
For c As Integer = 0 To regions.Count - 1
Dim sales = pivotData _
.Where(Function(p) p.Product = products(r) AndAlso p.Region = regions(c)) _
.Select(Function(p) p.TotalSales) _
.FirstOrDefault()
pivotSheet($"{ChrW(AscW("B"c) + c)}{r + 2}").Value = sales
Next
Next
' Add a totals row using Excel SUM formulas
Dim totalRow As Integer = products.Count + 2
pivotSheet($"A{totalRow}").Value = "Total"
For c As Integer = 0 To regions.Count - 1
Dim col As Char = ChrW(AscW("B"c) + c)
pivotSheet($"{col}{totalRow}").Formula = $"=SUM({col}2:{col}{totalRow - 1})"
Next
' Apply currency formatting to the data range
Dim dataRange = pivotSheet($"B2:{ChrW(AscW("B"c) + regions.Count - 1)}{totalRow}")
dataRange.FormatString = "$#,##0.00"
workbook.SaveAs("PivotReport.xlsx")Isso produz o mesmo resumo tabulado cruzado que você obteria de uma tabela dinâmica nativa do Excel. Você tem controle programático completo sobre cada célula, fórmula e string de formato -- e nenhum objeto COM para limpar.
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 dá a você um comportamento semelhante ao auto-atualizar da tabela dinâmica, sem nenhuma dependência do Interop.
As principais funções aqui são SUMIFS e COUNTIFS. SUMIFS soma um intervalo com base em condições de múltiplas colunas de 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);Imports IronXL
Imports System.Data
Imports System.Linq
Dim inputPath As String = "SalesData.xlsx"
Dim outputPath As String = "DynamicSummary.xlsx"
Dim workbook As WorkBook = WorkBook.Load(inputPath)
Dim dataSheet As WorkSheet = workbook.WorkSheets(0)
' Name the data sheet so formula references are stable
dataSheet.Name = "DataSheet"
' Convert to DataTable to enumerate unique product/region combinations
Dim dataTable As DataTable = dataSheet.ToDataTable(True)
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("DynamicSummary")
' Get unique product-region pairs
Dim uniqueCombos = dataTable.AsEnumerable() _
.Select(Function(row) New With {
.Product = row("Product").ToString(),
.Region = row("Region").ToString()
}) _
.Distinct() _
.OrderBy(Function(x) x.Product) _
.ThenBy(Function(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 i As Integer = 0 To uniqueCombos.Count - 1
Dim rowIndex As Integer = i + 2
Dim 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}"")"
Next
' Grand total row
Dim totalRow As Integer = 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)Essas fórmulas mantêm conexões ativas com os dados de origem. Quando alguém atualiza um valor em DataSheet, o Excel recalcula o resumo automaticamente na próxima abertura ou atualização – dando a você o mesmo comportamento de um ciclo de atualização de tabela dinâmica nativa, sem exigir automação COM.
Quando você aplica isso à mesma planilha de dados de vendas usada no exemplo anterior, a saída se parece com isso:
Essa abordagem baseada em fórmulas também lhe dá a capacidade de adicionar formatação condicional, barras de dados ou conjuntos de ícones às células de resumo usando a API de formatação de células do IronXL, tornando seus relatórios visualmente claros sem qualquer trabalho manual na interface do Excel.
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:
| Aspecto | Interop C# | IronXL |
|---|---|---|
| Office necessário | Sim -- instalação completa em cada máquina | Não -- pacote NuGet autônomo |
| Suporte de plataforma | Somente para Windows | Windows, Linux, macOS, Docker |
| Gerenciamento de memória | Limpeza manual de COM necessária | Coleta automática de lixo do .NET |
| Complexidade de implantação | Alto -- licenciamento + instalação do Office | Baixo -- referência única de DLL |
| Desempenho | Lento -- sobrecarga de inicialização do processo Excel | Rápido -- cálculos na memória |
| Compatível com a nuvem | Não -- bloqueado em Azure Functions, AWS Lambda | Sim -- roda em qualquer plataforma de nuvem |
| Objeto nativo de tabela dinâmica | Sim -- tabela dinâmica completa do Excel | Não -- equivalente baseado em agregação |
| Velocidade de desenvolvimento | Lento -- complexidade do COM | Rápido -- API gerida fluente |
| Suporte ao .NET 10 | Limitado -- problemas de vinculação COM | Completo -- mira no .NET moderno |
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.
A escolha certa depende do seu ambiente de implantação e das necessidades dos seus usuários.
Escolha Interop C# apenas quando:
Escolha o IronXL quando:
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.
A biblioteca do IronXL está disponível no NuGet e leva menos de um minuto para ser adicionada a qualquer projeto .NET:
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 obter a documentação completa da API, consulte o guia de introdução ao IronXL , o guia de migração de interoperabilidade com o Excel em C# 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.
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.
