Tworzenie tabeli przestawnej w programie Excel za pomocą języka C# jest proste, jeśli wybierzesz odpowiednią bibliotekę — Interop Excel wymaga zainstalowania pakietu Office na każdym komputerze, natomiast IronXL działa wszędzie tam, gdzie działa platforma .NET. W niniejszym przewodniku omówiono oba podejścia wraz z kompletnymi przykładami kodu, obejmującymi konfigurację, agregację danych, konfigurację pól oraz kwestie związane z wdrażaniem, abyś mógł podjąć właściwą decyzję dotyczącą swojego projektu.
Przed napisaniem choćby jednej linii kodu warto zrozumieć, jak działa każde z tych rozwiązań "pod maską". Interop Excel wykorzystuje COM (Component Object Model) do sterowania programem Microsoft Excel bezpośrednio z języka C#. Proces .NET komunikuje się z uruchomioną instancją programu Excel, co oznacza, że sam program Excel musi być zainstalowany na komputerze. Każdy obiekt, którym operujesz — skoroszyty, arkusze, zakresy, pamięci podręczne tabel przestawnych — jest opakowaniem COM i każdy z nich musi zostać wyraźnie zwolniony, aby uniknąć wycieków procesu.
IronXL idzie zasadniczo inną drogą. Odczytuje i zapisuje pliki w formacie Open XML bezpośrednio, bez uruchamiania programu Excel. W rezultacie otrzymujemy standardową bibliotekę .NET Standard z dobrze znanymi wzorcami obiektowymi, pamięcią z automatycznym czyszczeniem i bez zależności od instalacji lub licencji pakietu Office. Dzięki tej architekturze IronXL nadaje się do obciążeń po stronie serwera, kontenerów Docker, hostów Linux oraz dowolnego środowiska .NET 6, .NET 8 lub .NET 10.
| Kryteria | Interop Excel | IronXL |
|---|---|---|
| Wymagane biuro | Tak | Nie |
| Tylko dla systemu Windows | Tak | Nie — wielopłatformowe |
| Zarządzanie pamięcią | Ręczne wydanie COM | Automatyczne (.NET GC) |
| Wdrożenie na serwerze | Trudne | Proste |
| Natywna tabela przestawna | Pełny interfejs API tabeli przestawnej Excel | Agregacja danych za pomocą LINQ |
| Wymagana licencja | Licencja Office | Tylko licencja IronXL |
Interop Excel jest dostarczany jako pakiet NuGet. W swoim projekcie uruchom jedno z poniższych:
Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.ExcelNależy pamiętać, że sam pakiet nie wystarczy — na komputerze docelowym musi być zainstalowana odpowiednia wersja programu Microsoft Excel z ważną licencją. Ta zależność wyklucza większość scenariuszy związanych z serwerami, kontenerami i chmurą.
Zainstaluj IronXL za pośrednictwem NuGet bez dodatkowych wymagań systemowych:
Po instalacji można od razu rozpocząć odczytywanie i zapisywanie plików Excel na dowolnej platformie obsługującej .NET. Bez licencji Office, bez rejestracji COM, bez konfiguracji serwera. Dodatkowe opcje, w tym instalację offline i konfigurację odwołania do projektu, można znaleźć w instrukcji instalacji IronXL.
Przepływ pracy tabeli przestawnej w Interop wymaga ścisłej sekwencji: utwórz pamięć podręczną przestawną z zakresu źródłowego, następnie zbuduj obiekt PivotTable na osobnym arkuszu, a potem skonfiguruj orientacje pól. Poniższy przykład wykorzystuje instrukcje najwyższego poziomu w języku C# zgodne z platformą .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", "Nierth", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "Nierth", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "Nierth", 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", "Nierth", 1200},
{"Laptop", "South", 1500},
{"Phone", "Nierth", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "Nierth", 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)Każda nakładka COM wymaga odpowiedniego wywołania Marshal.ReleaseComObject. Brak choćby jednego odwołania powoduje, że proces Excelu pozostaje aktywny w tle, zużywając pamięć i uchwyty plików, aż do zakończenia procesu hosta. Obciążenie związane z porządkowaniem danych rośnie wraz ze złożonością operacji wykonywanych w arkuszu kalkulacyjnym.
IronXL nie udostępnia natywnego interfejsu API tabel przestawnych w taki sam sposób jak Interop — format tabel przestawnych Open XML ma setki atrybutów XML, a większość wymagań biznesowych jest spełniana bardziej niezawodnie dzięki jawnej agregacji LINQ napisanej w zwykłym C#. Wynikiem jest przejrzysty arkusz podsumowujący, który ponownie oblicza dane po otwarciu pliku, bez konieczności odświeżania pamięci podręcznej tabeli przestawnej w programie Excel.
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", "Nierth", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "Nierth", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "Nierth", 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", "Nierth", 1200},
{"Laptop", "South", 1500},
{"Phone", "Nierth", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "Nierth", 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")Nie ma żadnych obiektów COM do zwolnienia, żadnego procesu Excel do zakończenia ani żadnej licencji Office do zarządzania. Ten sam kod kompiluje się i działa na systemach Linux, macOS i Windows bez żadnych modyfikacji. Więcej szczegółów na temat API agregacji można znaleźć w dokumentacji IronXL WorkSheet.
Wdrożenie aplikacji opartej na Interop wymaga sprawdzenia, czy środowisko docelowe działa pod kontrolą systemu Windows, ma zainstalowaną odpowiednią wersję pakietu Office oraz czy na serwerze skonfigurowano uprawnienia do automatyzacji COM. Środowiska hostowane w chmurze i obciążenia kontenerowe zazwyczaj nie są w stanie spełnić tych wymagań bez dodania wirtualnej infrastruktury desktopowej Windows, co znacznie zwiększa koszty i złożoność operacyjną.
IronXL nie ma takich ograniczeń. Dodaj pakiet NuGet, ustaw docelową platformę na .NET 6 lub nowszą, a aplikacja zostanie wdrożona na dowolnym hoście — w tym w kontenerach Linux, usłudze Azure App Service na systemie Linux, AWS Lambda oraz lokalnych serwerach Windows. Strona z wymaganiami systemowymi IronXL zawiera pełną tabelę kompatybilności.
Awaria Interop pojawia się jako wyjątki COM (COMException), które są trudne do zmapowania na komunikaty widoczne dla użytkownika. Niezgodności wersji między zainstalowaną wersją pakietu Office a zestawem Interop stanowią kolejny powód niepowodzenia. Debugowanie tych problemów zazwyczaj wymaga odtworzenia dokładnie tej samej wersji pakietu Office na komputerze programisty.
IronXL rzuca standardowe podklasy System.Exception z opisowymi komunikatami. Możesz zawrzeć operacje na plikach w bloku try-catch i uzyskać sensowną informację zwrotną bez konieczności rozumienia kodów błędów COM. Przewodnik rozwiązywania problemów IronXL obejmuje typowe wyjątki i sposoby ich rozwiązywania.
Obiekty COM zajmują pamięć niezarządzaną. Jeśli kod przetwarza wiele arkuszy lub działa w pętli, nieprawidłowe zwolnienie każdego odwołania powoduje z czasem wzrost zużycia pamięci — problem, który trudno wykryć, dopóki nie spowoduje incydentu w środowisku produkcyjnym. Interop jest z natury jednowątkowy, ponieważ obsługuje tylko jedno okno programu Excel.
IronXL wykorzystuje obiekty zarządzane, wspierane przez moduł czyszczący pamięć .NET. Pamięć jest automatycznie odzyskiwana, gdy obiekty wychodzą poza zakres. Równoległe przetwarzanie wielu skoroszytów jest proste, ponieważ nie ma wspólnego stanu COM, który trzeba chronić za pomocą blokad.
Wybór odpowiedniego narzędzia zależy od dwóch czynników: miejsca działania kodu oraz tego, czy wymagany jest natywny XML tabeli przestawnej.
Wybierz Interop Excel, gdy:
Wybierz IronXL, gdy:
W przypadku większości nowych projektów .NET 10 IronXL jest praktycznym wyborem domyślnym. Biblioteka IronXL obejmuje także czytanie plików Excel w C#, tworzenie wykresów, stosowanie stylów komórek, pracę z formułami, oraz eksport danych Excel do DataTable -- zmniejszając potrzebę wielu bibliotek w twoim stacku.
Oprócz podstawowej agregacji, IronXL oferuje kilka funkcji, które wspierają bardziej rozbudowane procesy analizy danych:
Przed sporządzeniem arkusza podsumowującego można posortować zakres w porządku rosnącym lub malejącym. Dzięki temu dane są zawsze prezentowane w spójnej kolejności, co sprawia, że dalsze przetwarzanie jest bardziej przewidywalne. Zobacz dokumentację sortowania IronXL dla opcji sortowania na poziomie zakresu.
Wyróżnij odchylenia lub progi, stosując reguły warunkowego formatowania programowo. Na przykład można pokolorować komórki w arkuszu podsumowującym na czerwono, gdy sprzedaż spadnie poniżej poziomu docelowego, zapewniając przegląd sytuacji na pierwszy rzut oka bez konieczności ręcznego konfigurowania reguł przez użytkowników końcowych.
Jeśli dane źródłowe pochodzą z istniejącego arkusza kalkulacyjnego, a nie z bazy danych, można je załadować bezpośrednio za pomocą 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}")Ten wzorzec działa dla .xlsx, .xls, .csv i innych formatów obsługiwanych przez IronXL. Szczegóły dotyczące obsługiwanych formatów znajdują się w dokumentacji formatu plików IronXL.
Po utworzeniu arkusza podsumowującego można go wyeksportować do formatu CSV dla systemów, które nie obsługują formatu Excel:
workbook.SaveAsCsv(@"C:\output\summary.csv");workbook.SaveAsCsv("C:\output\summary.csv")Jest to szczególnie przydatne w potokach ETL, gdzie końcowym odbiorcą jest narzędzie do importu baz danych lub program do ładowania danych do hurtowni danych.
IronXL jest dostępny w ramach bezpłatnej licencji próbnej, która pozwala na ocenę pełnego zestawu funkcji bez konieczności wykupywania subskrypcji. Wersja próbna umieszcza znak wodny na plikach wyjściowych, który można usunąć po zastosowaniu klucza licencji produkcyjnej.
Aby aktywować klucz licencyjny w kodzie, należy ustawić go przed każdą operacją IronXL:
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"Można również ustawić klucz za pomocą zmiennej środowiskowej (IRONXL_LICENSEKEY) lub poprzez appsettings.json w projektach ASP.NET Core. Strona licencyjna IronXL opisuje wszystkie dostępne poziomy, w tym opcje dla zespołów i organizacji.
Dla wdrożeń produkcyjnych, zapoznaj się z dokumentacją wdrażania IronXL oraz szerszą biblioteką samouczków IronXL dla wzorców obejmujących ASP.NET Core, Azure Functions i Docker.
Tabele przestawne programu Excel w języku C# nie muszą oznaczać zależności od pakietu Office i złożoności interfejsu COM. Dzięki IronXL piszesz zwykły kod .NET, który działa na każdej platformie, automatycznie zarządza pamięcią i naturalnie integruje się z frameworkami do testowania jednostkowego oraz potokami CI/CD.
Pobierz bezpłatną wersję próbną IronXL i uruchom przykłady z tego przewodnika na własnych danych. W razie pytań forum społeczności IronXL oraz portal pomocy technicznej są dostępne zarówno dla użytkowników wersji próbnej, jak i licencjonowanych. Gdy będziesz gotowy do wdrożenia, zapoznaj się z opcjami licencyjnymi, aby znaleźć plan dostosowany do wielkości Twojego zespołu i intensywności użytkowania.
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
