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

Como criar uma tabela dinâmica no Excel usando C#

Jordi Bardia
Jordi Bardia
Atualizado:

Trabalhar programaticamente com uma tabela dinâmica do Excel é um requisito comum em aplicações empresariais que precisam analisar e calcular dados de origem. Embora o Excel Interop da Microsoft tenha sido o método tradicional para criar uma tabela dinâmica em um arquivo Excel, soluções modernas como o IronXL oferecem vantagens significativas. Este guia detalha os dois métodos com exemplos práticos para ajudá-lo a criar uma tabela dinâmica no Excel usando C# Interop ou escolher uma alternativa melhor.

Compreendendo as Duas Abordagens

O que é Excel Interop?

O Excel Interop usa COM (Component Object Model) para controlar diretamente o Microsoft Excel através do C#. Requer que o Office esteja instalado no sistema e essencialmente automatiza o Excel como se um usuário estivesse interagindo com o aplicativo. Cada planilha, pasta de trabalho e célula se torna um objeto que você pode manipular através do código.

O que é IronXL?

IronXL é uma biblioteca .NET independente que pode ler, editar e criar arquivos Excel sem exigir o Microsoft Office. Funciona em Windows, Linux, macOS e contêineres Docker, tornando-o ideal para cenários de implantação modernos. Você pode abrir, salvar e exportar dados sem a sobrecarga do COM interop.

Preparando seu ambiente

Para Excel Interop

Install-Package Microsoft.Office.Interop.Excel

Para IronXL

Install-Package IronXL.Excel

Alternativamente, use a interface do Gerenciador de Pacotes NuGet pesquisando por "IronXL.Excel" e clicando em instalar. Você também pode instalar via .NET CLI com argumentos de comando ou referenciá-lo diretamente do GitHub.

Ambas as bibliotecas estão disponíveis através do NuGet. Observe que o Excel Interop requer uma instalação completa do Microsoft Office, enquanto o IronXL opera de forma independente. Antes de prosseguir, certifique-se de que seu sistema atenda aos requisitos.

Creating an Excel Pivot Table Programmatically with C# Interop

Aqui está um exemplo completo mostrando como criar uma tabela dinâmica programaticamente usando a abordagem tradicional do Interop:

using Excel = Microsoft.Office.Interop.Excel;
class Program
{
    static void Main(string[] args)
    {
        // Create Excel application instance
        var excelApp = new Excel.Application();
        var workbook = excelApp.Workbooks.Add();
                    var dataSheet = (Excel.Worksheet)workbook.Worksheets[1];
            var pivotSheet = (Excel.Worksheet)workbook.Worksheets.Add();
            // Add header row and sample data
            dataSheet.Cells[1, 1] = "Product";
            dataSheet.Cells[1, 2] = "Region";
            dataSheet.Cells[1, 3] = "Sales";
            // ... populate data rows with values
            // Add sample data rows
            dataSheet.Cells[2, 1] = "Laptop";
            dataSheet.Cells[2, 2] = "North";
            dataSheet.Cells[2, 3] = 1200;
            dataSheet.Cells[3, 1] = "Laptop";
            dataSheet.Cells[3, 2] = "South";
            dataSheet.Cells[3, 3] = 1500;
            dataSheet.Cells[4, 1] = "Phone";
            dataSheet.Cells[4, 2] = "North";
            dataSheet.Cells[4, 3] = 800;
            dataSheet.Cells[5, 1] = "Phone";
            dataSheet.Cells[5, 2] = "South";
            dataSheet.Cells[5, 3] = 950;
            dataSheet.Cells[6, 1] = "Tablet";
            dataSheet.Cells[6, 2] = "East";
            dataSheet.Cells[6, 3] = 600;
            dataSheet.Cells[7, 1] = "Tablet";
            dataSheet.Cells[7, 2] = "West";
            dataSheet.Cells[7, 3] = 750;
            dataSheet.Cells[8, 1] = "Monitor";
            dataSheet.Cells[8, 2] = "North";
            dataSheet.Cells[8, 3] = 400;
            dataSheet.Cells[9, 1] = "Monitor";
            dataSheet.Cells[9, 2] = "South";
            dataSheet.Cells[9, 3] = 500;
            dataSheet.Cells[10, 1] = "Keyboard";
            dataSheet.Cells[10, 2] = "East";
            dataSheet.Cells[10, 3] = 300;
            // Create pivot cache from source data range
            Excel.Range dataRange = dataSheet.Range["A1:C10"];
            Excel.PivotCache pivotCache = workbook.PivotCaches().Create(
                Excel.XlPivotTableSourceType.xlDatabase, dataRange);
            // Create PivotTable at specific location
            Excel.PivotTables pivotTables = (Excel.PivotTables)pivotSheet.PivotTables();
            Excel.PivotTable pivotTable = pivotTables.Add(
                pivotCache, pivotSheet.Range["A3"], "SalesPivot");
            // Configure pivot table fields - row and column headers
            ((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;
            // Configure grand totals and formatting
            pivotTable.RowGrand = true;
            pivotTable.ColumnGrand = true;
            // Save the Excel file
            workbook.SaveAs("pivot_interop.xlsx");
            workbook.Close();
            excelApp.Quit();
            // Critical: Release COM objects to avoid errors
            #if WINDOWS
            Marshal.ReleaseComObject(pivotTable);
            Marshal.ReleaseComObject(pivotSheet);
            Marshal.ReleaseComObject(dataSheet);
            Marshal.ReleaseComObject(workbook);
            Marshal.ReleaseComObject(excelApp);
            #endif
    }
}
using Excel = Microsoft.Office.Interop.Excel;
class Program
{
    static void Main(string[] args)
    {
        // Create Excel application instance
        var excelApp = new Excel.Application();
        var workbook = excelApp.Workbooks.Add();
                    var dataSheet = (Excel.Worksheet)workbook.Worksheets[1];
            var pivotSheet = (Excel.Worksheet)workbook.Worksheets.Add();
            // Add header row and sample data
            dataSheet.Cells[1, 1] = "Product";
            dataSheet.Cells[1, 2] = "Region";
            dataSheet.Cells[1, 3] = "Sales";
            // ... populate data rows with values
            // Add sample data rows
            dataSheet.Cells[2, 1] = "Laptop";
            dataSheet.Cells[2, 2] = "North";
            dataSheet.Cells[2, 3] = 1200;
            dataSheet.Cells[3, 1] = "Laptop";
            dataSheet.Cells[3, 2] = "South";
            dataSheet.Cells[3, 3] = 1500;
            dataSheet.Cells[4, 1] = "Phone";
            dataSheet.Cells[4, 2] = "North";
            dataSheet.Cells[4, 3] = 800;
            dataSheet.Cells[5, 1] = "Phone";
            dataSheet.Cells[5, 2] = "South";
            dataSheet.Cells[5, 3] = 950;
            dataSheet.Cells[6, 1] = "Tablet";
            dataSheet.Cells[6, 2] = "East";
            dataSheet.Cells[6, 3] = 600;
            dataSheet.Cells[7, 1] = "Tablet";
            dataSheet.Cells[7, 2] = "West";
            dataSheet.Cells[7, 3] = 750;
            dataSheet.Cells[8, 1] = "Monitor";
            dataSheet.Cells[8, 2] = "North";
            dataSheet.Cells[8, 3] = 400;
            dataSheet.Cells[9, 1] = "Monitor";
            dataSheet.Cells[9, 2] = "South";
            dataSheet.Cells[9, 3] = 500;
            dataSheet.Cells[10, 1] = "Keyboard";
            dataSheet.Cells[10, 2] = "East";
            dataSheet.Cells[10, 3] = 300;
            // Create pivot cache from source data range
            Excel.Range dataRange = dataSheet.Range["A1:C10"];
            Excel.PivotCache pivotCache = workbook.PivotCaches().Create(
                Excel.XlPivotTableSourceType.xlDatabase, dataRange);
            // Create PivotTable at specific location
            Excel.PivotTables pivotTables = (Excel.PivotTables)pivotSheet.PivotTables();
            Excel.PivotTable pivotTable = pivotTables.Add(
                pivotCache, pivotSheet.Range["A3"], "SalesPivot");
            // Configure pivot table fields - row and column headers
            ((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;
            // Configure grand totals and formatting
            pivotTable.RowGrand = true;
            pivotTable.ColumnGrand = true;
            // Save the Excel file
            workbook.SaveAs("pivot_interop.xlsx");
            workbook.Close();
            excelApp.Quit();
            // Critical: Release COM objects to avoid errors
            #if WINDOWS
            Marshal.ReleaseComObject(pivotTable);
            Marshal.ReleaseComObject(pivotSheet);
            Marshal.ReleaseComObject(dataSheet);
            Marshal.ReleaseComObject(workbook);
            Marshal.ReleaseComObject(excelApp);
            #endif
    }
}
Imports Excel = Microsoft.Office.Interop.Excel
Imports System.Runtime.InteropServices

Class Program
    Shared Sub Main(ByVal args() As String)
        ' Create Excel application instance
        Dim excelApp As New Excel.Application()
        Dim workbook As Excel.Workbook = excelApp.Workbooks.Add()
        Dim dataSheet As Excel.Worksheet = CType(workbook.Worksheets(1), Excel.Worksheet)
        Dim pivotSheet As Excel.Worksheet = CType(workbook.Worksheets.Add(), Excel.Worksheet)

        ' Add header row and sample data
        dataSheet.Cells(1, 1) = "Product"
        dataSheet.Cells(1, 2) = "Region"
        dataSheet.Cells(1, 3) = "Sales"
        ' ... populate data rows with values
        ' Add sample data rows
        dataSheet.Cells(2, 1) = "Laptop"
        dataSheet.Cells(2, 2) = "North"
        dataSheet.Cells(2, 3) = 1200
        dataSheet.Cells(3, 1) = "Laptop"
        dataSheet.Cells(3, 2) = "South"
        dataSheet.Cells(3, 3) = 1500
        dataSheet.Cells(4, 1) = "Phone"
        dataSheet.Cells(4, 2) = "North"
        dataSheet.Cells(4, 3) = 800
        dataSheet.Cells(5, 1) = "Phone"
        dataSheet.Cells(5, 2) = "South"
        dataSheet.Cells(5, 3) = 950
        dataSheet.Cells(6, 1) = "Tablet"
        dataSheet.Cells(6, 2) = "East"
        dataSheet.Cells(6, 3) = 600
        dataSheet.Cells(7, 1) = "Tablet"
        dataSheet.Cells(7, 2) = "West"
        dataSheet.Cells(7, 3) = 750
        dataSheet.Cells(8, 1) = "Monitor"
        dataSheet.Cells(8, 2) = "North"
        dataSheet.Cells(8, 3) = 400
        dataSheet.Cells(9, 1) = "Monitor"
        dataSheet.Cells(9, 2) = "South"
        dataSheet.Cells(9, 3) = 500
        dataSheet.Cells(10, 1) = "Keyboard"
        dataSheet.Cells(10, 2) = "East"
        dataSheet.Cells(10, 3) = 300

        ' Create pivot cache from source data range
        Dim dataRange As Excel.Range = dataSheet.Range("A1:C10")
        Dim pivotCache As Excel.PivotCache = workbook.PivotCaches().Create(Excel.XlPivotTableSourceType.xlDatabase, dataRange)

        ' Create PivotTable at specific location
        Dim pivotTables As Excel.PivotTables = CType(pivotSheet.PivotTables(), Excel.PivotTables)
        Dim pivotTable As Excel.PivotTable = pivotTables.Add(pivotCache, pivotSheet.Range("A3"), "SalesPivot")

        ' Configure pivot table fields - row and column headers
        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

        ' Configure grand totals and formatting
        pivotTable.RowGrand = True
        pivotTable.ColumnGrand = True

        ' Save the Excel file
        workbook.SaveAs("pivot_interop.xlsx")
        workbook.Close()
        excelApp.Quit()

        ' Critical: Release COM objects to avoid errors
#If WINDOWS Then
        Marshal.ReleaseComObject(pivotTable)
        Marshal.ReleaseComObject(pivotSheet)
        Marshal.ReleaseComObject(dataSheet)
        Marshal.ReleaseComObject(workbook)
        Marshal.ReleaseComObject(excelApp)
#End If
    End Sub
End Class
$vbLabelText   $csharpLabel

Este código cria uma aplicação Excel, adiciona uma planilha com dados de origem incluindo uma linha de cabeçalho, estabelece um cache de tabela dinâmica, constrói o objeto PivotTable e configura a orientação dos campos. A seção de limpeza é crítica - falhar ao liberar objetos COM causa vazamentos de memória. Cada célula, intervalo e planilha deve ser devidamente descartada para evitar erros em runtime.

A Abordagem Alternativa do IronXL

O IronXL adota uma abordagem diferente trabalhando diretamente com o formato de arquivo do Excel. Veja como obter resultados de análise programaticamente semelhantes:

using IronXL;
using System.Linq;
class Program 
{
    static void Main(string[] args)
    {
        // Create workbook and add worksheet with data
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Data");
        // Add header row to define column structure
        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Region";
        sheet["C1"].Value = "Sales";
        // Add sample data to cells
        sheet["A2"].Value = "Widget";
        sheet["B2"].Value = "North";
        sheet["C2"].Value = 1500;
        // ... continue to add more data rows
        sheet["A3"].Value = "Laptop";
        sheet["B3"].Value = "South";
        sheet["C3"].Value = 1500;
        sheet["A4"].Value = "Phone";
        sheet["B4"].Value = "North";
        sheet["C4"].Value = 800;
        sheet["A5"].Value = "Phone";
        sheet["B5"].Value = "South";
        sheet["C5"].Value = 950;
        sheet["A6"].Value = "Tablet";
        sheet["B6"].Value = "East";
        sheet["C6"].Value = 600;
        sheet["A7"].Value = "Tablet";
        sheet["B7"].Value = "West";
        sheet["C7"].Value = 750;
        sheet["A8"].Value = "Monitor";
        sheet["B8"].Value = "North";
        sheet["C8"].Value = 400;
        sheet["A9"].Value = "Monitor";
        sheet["B9"].Value = "South";
        sheet["C9"].Value = 500;
        sheet["A10"].Value = "Keyboard";
        sheet["B10"].Value = "East";
        sheet["C10"].Value = 300;
        // Create summary analysis worksheet
        var summarySheet = workbook.CreateWorkSheet("Summary");
        // Group and calculate aggregated data
        var data = sheet["A1:C10"].ToDataTable(true);
        var productSummary = data.AsEnumerable()
            .GroupBy(row => row.Field<string>("Product"))
            .Select((group, index) => new {
                Product = group.Key,
                TotalSales = group.Sum(r => Convert.ToDecimal(r["Sales"])),
                Count = group.Count(),
                RowIndex = index + 2
            });
        // Write column headers for summary
        summarySheet["A1"].Value = "Product Summary";
        summarySheet["A2"].Value = "Product";
        summarySheet["B2"].Value = "Total Sales";
        summarySheet["C2"].Value = "Count";
        // Export results to cells
        foreach (var item in productSummary)
        {
            summarySheet[$"A{item.RowIndex + 1}"].Value = item.Product;
            summarySheet[$"B{item.RowIndex + 1}"].Value = item.TotalSales;
            summarySheet[$"C{item.RowIndex + 1}"].Value = item.Count;
        }
        // Apply number formatting and style
        summarySheet["B:B"].FormatString = "$#,##0.00";
        // Save the xlsx file
        workbook.SaveAs("analysis_ironxl.xlsx");
    }
}
using IronXL;
using System.Linq;
class Program 
{
    static void Main(string[] args)
    {
        // Create workbook and add worksheet with data
        WorkBook workbook = WorkBook.Create();
        WorkSheet sheet = workbook.CreateWorkSheet("Data");
        // Add header row to define column structure
        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Region";
        sheet["C1"].Value = "Sales";
        // Add sample data to cells
        sheet["A2"].Value = "Widget";
        sheet["B2"].Value = "North";
        sheet["C2"].Value = 1500;
        // ... continue to add more data rows
        sheet["A3"].Value = "Laptop";
        sheet["B3"].Value = "South";
        sheet["C3"].Value = 1500;
        sheet["A4"].Value = "Phone";
        sheet["B4"].Value = "North";
        sheet["C4"].Value = 800;
        sheet["A5"].Value = "Phone";
        sheet["B5"].Value = "South";
        sheet["C5"].Value = 950;
        sheet["A6"].Value = "Tablet";
        sheet["B6"].Value = "East";
        sheet["C6"].Value = 600;
        sheet["A7"].Value = "Tablet";
        sheet["B7"].Value = "West";
        sheet["C7"].Value = 750;
        sheet["A8"].Value = "Monitor";
        sheet["B8"].Value = "North";
        sheet["C8"].Value = 400;
        sheet["A9"].Value = "Monitor";
        sheet["B9"].Value = "South";
        sheet["C9"].Value = 500;
        sheet["A10"].Value = "Keyboard";
        sheet["B10"].Value = "East";
        sheet["C10"].Value = 300;
        // Create summary analysis worksheet
        var summarySheet = workbook.CreateWorkSheet("Summary");
        // Group and calculate aggregated data
        var data = sheet["A1:C10"].ToDataTable(true);
        var productSummary = data.AsEnumerable()
            .GroupBy(row => row.Field<string>("Product"))
            .Select((group, index) => new {
                Product = group.Key,
                TotalSales = group.Sum(r => Convert.ToDecimal(r["Sales"])),
                Count = group.Count(),
                RowIndex = index + 2
            });
        // Write column headers for summary
        summarySheet["A1"].Value = "Product Summary";
        summarySheet["A2"].Value = "Product";
        summarySheet["B2"].Value = "Total Sales";
        summarySheet["C2"].Value = "Count";
        // Export results to cells
        foreach (var item in productSummary)
        {
            summarySheet[$"A{item.RowIndex + 1}"].Value = item.Product;
            summarySheet[$"B{item.RowIndex + 1}"].Value = item.TotalSales;
            summarySheet[$"C{item.RowIndex + 1}"].Value = item.Count;
        }
        // Apply number formatting and style
        summarySheet["B:B"].FormatString = "$#,##0.00";
        // Save the xlsx file
        workbook.SaveAs("analysis_ironxl.xlsx");
    }
}
Imports IronXL
Imports System.Linq

Class Program
    Shared Sub Main(args As String())
        ' Create workbook and add worksheet with data
        Dim workbook As WorkBook = WorkBook.Create()
        Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
        ' Add header row to define column structure
        sheet("A1").Value = "Product"
        sheet("B1").Value = "Region"
        sheet("C1").Value = "Sales"
        ' Add sample data to cells
        sheet("A2").Value = "Widget"
        sheet("B2").Value = "North"
        sheet("C2").Value = 1500
        ' ... continue to add more data rows
        sheet("A3").Value = "Laptop"
        sheet("B3").Value = "South"
        sheet("C3").Value = 1500
        sheet("A4").Value = "Phone"
        sheet("B4").Value = "North"
        sheet("C4").Value = 800
        sheet("A5").Value = "Phone"
        sheet("B5").Value = "South"
        sheet("C5").Value = 950
        sheet("A6").Value = "Tablet"
        sheet("B6").Value = "East"
        sheet("C6").Value = 600
        sheet("A7").Value = "Tablet"
        sheet("B7").Value = "West"
        sheet("C7").Value = 750
        sheet("A8").Value = "Monitor"
        sheet("B8").Value = "North"
        sheet("C8").Value = 400
        sheet("A9").Value = "Monitor"
        sheet("B9").Value = "South"
        sheet("C9").Value = 500
        sheet("A10").Value = "Keyboard"
        sheet("B10").Value = "East"
        sheet("C10").Value = 300
        ' Create summary analysis worksheet
        Dim summarySheet = workbook.CreateWorkSheet("Summary")
        ' Group and calculate aggregated data
        Dim data = sheet("A1:C10").ToDataTable(True)
        Dim productSummary = data.AsEnumerable() _
            .GroupBy(Function(row) row.Field(Of String)("Product")) _
            .Select(Function(group, index) New With {
                .Product = group.Key,
                .TotalSales = group.Sum(Function(r) Convert.ToDecimal(r("Sales"))),
                .Count = group.Count(),
                .RowIndex = index + 2
            })
        ' Write column headers for summary
        summarySheet("A1").Value = "Product Summary"
        summarySheet("A2").Value = "Product"
        summarySheet("B2").Value = "Total Sales"
        summarySheet("C2").Value = "Count"
        ' Export results to cells
        For Each item In productSummary
            summarySheet($"A{item.RowIndex + 1}").Value = item.Product
            summarySheet($"B{item.RowIndex + 1}").Value = item.TotalSales
            summarySheet($"C{item.RowIndex + 1}").Value = item.Count
        Next
        ' Apply number formatting and style
        summarySheet("B:B").FormatString = "$#,##0.00"
        ' Save the xlsx file
        workbook.SaveAs("analysis_ironxl.xlsx")
    End Sub
End Class
$vbLabelText   $csharpLabel

Este exemplo do IronXL demonstra como criar uma pasta de trabalho, adicionar planilhas, preencher células com dados e realizar análise de agregação. O código agrupa dados por produto e calcula totais e contagens, criando um relatório resumido. Não há necessidade de gerenciamento de objetos COM, e os métodos são coleções .NET diretas que automaticamente cuidam da memória.

Saída

Como Criar uma Tabela Dinâmica do Excel em C#: Figura 6 - Saída IronXL

Como Criar uma Tabela Dinâmica do Excel em C#: Figura 7 - Resumo de Saída

Diferenças e Considerações Chave

Requisitos de Implantação

Excel Interop requer:

  • Instalação do Microsoft Excel com uma licença válida
  • Sistema operacional Windows
  • Permissões e configurações COM adequadas

  • Configuração do servidor para automação do Office IronXL requer:

  • Apenas o pacote de biblioteca IronXL
  • Funciona em qualquer plataforma que suporte .NET
  • Nenhuma instalação ou licença do Office necessária
  • Processo de implantação simplificado

Como Criar uma Tabela Dinâmica do Excel em C#: Figura 8 - Funcionalidades

Qualidade de Código e Manutenção

Interop envolve gerenciar objetos COM cuidadosamente para evitar vazamentos de memória e erros. Todo objeto Excel criado deve ser liberado explicitamente usando os métodos corretos. IronXL usa objetos padrão do .NET com coleta automática de lixo, reduzindo o risco de problemas de recursos.

Tratamento de erros

Com Interop, erros geralmente estão relacionados à disponibilidade do Excel, diferenças de versão ou falhas COM. Erros do IronXL são exceções padrão do .NET, facilitando a depuração. Você pode contar com padrões familiares de try-catch sem se preocupar com problemas específicos de COM.

Melhores Práticas e Recomendações

Escolha Excel Interop quando:

  • Precisar de recursos exatos de tabelas dinâmicas do Excel com todas as opções de formatação
  • O Excel está garantido para estar disponível no sistema
  • Trabalhando apenas em aplicativos de desktop do Windows

  • Requisitos de código legado Escolha IronXL quando:

  • Construindo aplicativos de servidor ou soluções web
  • Exigindo compatibilidade multiplataforma
  • Precisar de desempenho confiável sem overhead COM
  • Implantando em contêineres ou ambientes de nuvem

Visite a documentação do IronXL para aprender mais detalhes sobre a implementação. Para perguntas ou suporte, entre em contato com a equipe da Iron Software.

Conclusão

Embora o C# Interop forneça acesso direto para criar tabelas dinâmicas no Excel, ele vem com limitações de implantação e complexidade. IronXL oferece uma alternativa moderna que simplifica a manipulação de arquivos Excel enquanto proporciona a flexibilidade de ser executado em qualquer lugar que o .NET seja suportado.

Para desenvolvedores que estão criando novos aplicativos ou modernizando soluções existentes, a abordagem do IronXL elimina o overhead do COM Interop enquanto oferece poderosas capacidades de manipulação de dados. Seja para ler, editar ou exportar dados do Excel, o IronXL oferece uma solução mais limpa.

Comece com a versão de teste gratuita do IronXL para experimentar a diferença, ou explore tutoriais para ver mais exemplos. Pronto para implantar? Veja as opções de licenciamento para escolher o pacote certo para sua tarefa.

Como Criar uma Tabela Dinâmica do Excel em C#: Figura 9 - Licenciamento

Perguntas frequentes

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

O IronXL oferece vantagens significativas em relação ao Excel Interop, incluindo facilidade de uso, melhor desempenho e a capacidade de criar tabelas dinâmicas sem a necessidade de instalar o Excel no servidor.

Posso criar uma tabela dinâmica do Excel em C# sem usar o Excel Interop?

Sim, você pode criar uma tabela dinâmica do Excel em C# usando o IronXL, que oferece uma alternativa moderna e eficiente ao Excel Interop.

É necessário ter o Microsoft Excel instalado para usar o IronXL?

Não, o IronXL não exige que o Microsoft Excel esteja instalado no seu sistema, o que o torna uma solução flexível para criar e gerenciar arquivos do Excel.

Quais são os passos para criar uma tabela dinâmica no Excel usando o IronXL?

Para criar uma tabela dinâmica usando o IronXL, primeiro carregue seu arquivo Excel, especifique o intervalo de dados, defina os campos da tabela dinâmica e, em seguida, gere a tabela dinâmica. A API abrangente do IronXL torna esse processo simples.

O IronXL suporta outras funcionalidades do Excel além de tabelas dinâmicas?

Sim, o IronXL suporta uma ampla gama de funcionalidades do Excel, incluindo leitura e gravação de arquivos do Excel, formatação de células e realização de cálculos, entre outras.

Como o IronXL lida com grandes conjuntos de dados ao criar tabelas dinâmicas?

O IronXL foi projetado para lidar com grandes conjuntos de dados de forma eficiente, garantindo a criação rápida e confiável de tabelas dinâmicas, mesmo com grandes volumes de dados.

O IronXL pode ser usado em aplicações baseadas em nuvem?

Sim, o IronXL pode ser integrado a aplicativos baseados em nuvem, oferecendo uma solução perfeita para gerenciar arquivos do Excel na nuvem.

Quais linguagens de programação são suportadas pelo IronXL para a criação de tabelas dinâmicas?

O IronXL oferece suporte principalmente a C#, facilitando a criação de tabelas dinâmicas e a execução de outras operações do Excel em aplicativos .NET.

Existe algum tutorial disponível para aprender a usar o IronXL?

Sim, a Iron Software oferece documentação e tutoriais completos em seu site para ajudar os usuários a aprenderem como usar o IronXL de forma eficaz.

Quais são as opções de licenciamento disponíveis para o IronXL?

A IronXL oferece diversas opções de licenciamento, incluindo planos gratuitos e pagos, para atender às diferentes necessidades e escalas de projetos.

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