Jak stworzyć tabelę przestawną w Excel z C# bez Interop
Tworzenie tabeli przestawnej w programie Excel za pomocą języka C# jest proste, jeśli wybierzesz odpowiednią bibliotekę — Excel Interop 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.
Jaka jest różnica między Excel Interop a IronXL?
Przed napisaniem choćby jednej linii kodu warto zrozumieć, jak działa każde z tych rozwiązań "pod maską". Excel Interop 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 | Excel Interop | 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 |
Jak zainstalować każdą z bibliotek?
Konfiguracja interoperacyjności z programem Excel
Excel Interop 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.ExcelInstall-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ą.
Konfiguracja IronXL
Zainstaluj IronXL za pośrednictwem NuGet bez dodatkowych wymagań systemówych:
Install-Package IronXl.Excel
dotnet add package IronXl.ExcelInstall-Package IronXl.Excel
dotnet add package IronXl.ExcelPo 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.
!{--01001100010010010100001001010010010000010101001001011001010111110100011101000101010101000101111101010011010101000100000101010010010101000100010101000100010111110101011101001001010100010010000101111101010000010100100100111101000100010101010100001101010100010111110101010001010010010010010100000101001100010111110100001001001100010011110100001101001011--}
Jak utworzyć tabelę przestawną w Excelu za pomocą C# Interop?
Przepływ pracy z tabelą przestawną Interop przebiega według ścisłej sekwencji: utwórz pamięć podręczną tabeli przestawnej z zakresu źródłowego, następnie zbuduj obiekt PivotTable w osobnym arkuszu, a na koniec skonfiguruj orientację 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);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.
Jak osiągnąć ten sam rezultat z IronXL?
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");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.
Wynik
Jakie są kluczowe różnice w zakresie wdrażania i utrzymania?
Wymagania dotyczące wdrożenia
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 systemówymi IronXL zawiera pełną tabelę kompatybilności.
Obsługa błędów i debugowanie
Błędy interoperacyjności pojawiają się jako wyjątki COM (COMException), które trudno jest odwzorować 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 generuje 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.
Pamięć i wydajność
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.
Jak wybrać między tymi dwoma podejściami?
Wybór odpowiedniego narzędzia zależy od dwóch czynników: miejsca działania kodu oraz tego, czy wymagańy jest natywny XML tabeli przestawnej.
Wybierz Excel Interop, gdy:
- Aplikacja działa wyłącznie na komputerach stacjonarnych z systemem Windows, na których zainstalowano już pakiet Office
- W pliku wyjściowym wymagańe jest dokładne formatowanie tabel przestawnych (segmentatory, zgrupowane pola daty, elementy obliczeniowe)
- Utrzymujesz istniejącą bazę kodu Interop i nie ma uzasadnienia dla całkowitego przepisania kodu
Wybierz IronXL, gdy:
- Aplikacja działa na serwerze, w kontenerze lub w funkcji chmurowej
- Wymagane jest wdrożenie na wielu platformach lub w systemie Linux
- Potrzebujesz logiki agregacji danych, którą można przetestować za pomocą testów jednostkowych, a nie zależnej od procesu w Excelu
- Musisz przetwarzać pliki Excel na dużą skalę lub równolegle
W przypadku większości nowych projektów .NET 10 IronXL jest praktycznym wyborem domyślnym. Biblioteka IronXL obsługuje również odczyt plików Excel w języku C#, tworzenie wykresów, stosowanie stylów komórek, pracę z formułami oraz eksportowanie danych z Excela do DataTable — co zmniejsza potrzebę korzystania z wielu bibliotek w stosie.
Jakie dodatkowe funkcje IronXL wspierają analizę danych?
Oprócz podstawowej agregacji, IronXL oferuje kilka funkcji, które wspierają bardziej rozbudowane procesy analizy danych:
Sortowanie i filtrowanie 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. Opcje sortowania na poziomie zakresu można znaleźć w dokumentacji sortowania IronXL.
Stosowanie formatowania warunkówego
Wyróżnij wartości odstające lub progi, stosując programowo reguły formatowania warunkówego. 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.
Odczytywanie istniejących plików Excel
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}");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 oraz innych formatów obsługiwanych przez IronXL. Szczegóły dotyczące obsługiwanych formatów znajdują się w dokumentacji formatu plików IronXL.
Eksport do pliku CSV
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");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.
Jak bezpłatnie rozpocząć korzystanie z IronXL?
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";IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXl
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"Klucz można również ustawić za pomocą zmiennej środowiskowej (IRONXL_LICENSEKEY) lub poprzez appsettings.json w projektach .NET Core. Strona licencyjna IronXL opisuje wszystkie dostępne poziomy, w tym opcje dla zespołów i organizacji.
W przypadku wdrożeń produkcyjnych zapoznaj się z dokumentacją wdrożeniową IronXL oraz obszerną biblioteką samouczków IronXL, zawierającą wzorce dotyczące ASP.NET Core, Azure Functions i Docker.
Jak wykonać kolejny krok?
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.
Często Zadawane Pytania
Jaka jest zaleta korzystania z IronXL zamiast Excel Interop do tworzenia tabel przestawnych?
IronXL oferuje bardziej nowoczesny i wydajny sposób tworzenia tabel przestawnych w plikach Excel w porównaniu z tradycyjnym interfejsem Excel Interop. Upraszcza proces i zmniejsza ilość potrzebnego kodu szablonowego.
Czy mogę utworzyć tabelę przestawną w programie Excel przy użyciu języka C# i biblioteki IronXL?
Tak, IronXL zapewnia prostą metodę tworzenia tabel przestawnych w Excelu przy użyciu języka C#. Pozwala to programistom na łatwą manipulację plikami Excel bez konieczności korzystania z interfejsu Excel Interop.
Czy IronXL jest kompatybilny z aplikacjami .NET?
IronXL jest w pełni kompatybilny z aplikacjami .NET, co czyni go doskonałym wyborem dla programistów pragnących zintegrować funkcje Excela ze swoimi projektami w języku C#.
Czy IronXL wymaga zainstalowania programu Excel w systemie?
Nie, IronXL nie wymaga zainstalowania programu Microsoft Excel w systemie. Działa niezależnie, co stanowi znaczną przewagę nad Excel Interop, który wymaga zainstalowania programu Excel.
W jaki sposób IronXL upraszcza proces tworzenia tabel przestawnych?
IronXL upraszcza ten proces, udostępniając przyjazny dla użytkownika interfejs API, który ogranicza potrzebę stosowania rozbudowanego kodu szablonowego, dzięki czemu proces tworzenia oprogramowania przebiega szybciej i wydajniej.
Jakie są wymagania systemowe dotyczące korzystania z IronXL?
IronXL wymaga środowiska zgodnego z .NET Framework, ale nie wymaga instalacji programu Microsoft Excel, co upraszcza wdrożenie i zmniejsza liczbę zależności.
Czy IronXL może efektywnie obsługiwać duże pliki Excel?
Tak, IronXL został zaprojektowany do wydajnej obsługi dużych plików Excel, dzięki czemu nadaje się do zastosowań biznesowych wymagających przetwarzania znacznych ilości danych.
Czy korzystanie z IronXL wymaga dłuższego okresu nauki w porównaniu z Excel Interop?
IronXL został zaprojektowany tak, aby był intuicyjny i łatwy do opanowania, z obszerną dokumentacją i przykładami, co ułatwia jego wdrożenie w porównaniu z bardziej złożonym Excel Interop.
Jakie operacje w programie Excel może wykonywać IronXL oprócz tworzenia tabel przestawnych?
IronXL może wykonywać szeroki zakres operacji w programie Excel, w tym między innymi odczytywanie i zapisywanie plików Excel, formatowanie komórek oraz stosowanie formuł.
Czy IronXL może eksportować tabele przestawne do formatów innych niż Excel?
Chociaż IronXL koncentruje się przede wszystkim na operacjach w programie Excel, obsługuje również eksport danych do innych formatów, takich jak CSV i PDF, w zależności od wymagań projektu.
Rozpocznij za DARMO
Rozpocznij za DARMO
Zarezerwuj darmowe Demo na żywo
Nie wymaga karty kredytowej ani tworzenia konta
