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ę — 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.
Jaka jest różnica między Interop Excel a IronXL?
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 |
Jak zainstalować każdą z bibliotek?
Konfiguracja interoperacyjności z programem Excel
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.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ń systemowych:
Install-Package IronXL.Excel
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.
Jak stworzyć tabelę przestawną Excel z C# Interop?
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);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 systemowymi IronXL zawiera pełną tabelę kompatybilności.
Obsługa błędów i debugowanie
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.
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 wymagany jest natywny XML tabeli przestawnej.
Wybierz Interop Excel, gdy:
- Aplikacja działa wyłącznie na komputerach stacjonarnych z systemem Windows, na których zainstalowano już pakiet Office
- W pliku wyjściowym wymagane 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 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.
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. Zobacz dokumentację sortowania IronXL dla opcji sortowania na poziomie zakresu.
Stosowanie formatowania warunkowego
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.
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 i 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"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.
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
