Das Erstellen von Pivot-Tabellen in Excel mit C# ist unkompliziert, wenn Sie die richtige Bibliothek wählen: Excel-Interop benötigt Office auf jedem Rechner, während IronXL überall dort funktioniert, wo .NET ausgeführt wird. Dieser Leitfaden erläutert beide Ansätze anhand vollständiger Codebeispiele und behandelt Einrichtung, Datenaggregation, Feldkonfiguration und Bereitstellungsaspekte, damit Sie die optimale Lösung für Ihr Projekt finden.
Bevor man auch nur eine Zeile Code schreibt, ist es hilfreich zu verstehen, was die einzelnen Ansätze im Detail bewirken. Excel-Interop verwendet COM (Component Object Model), um Microsoft Excel direkt von C# aus zu steuern. Der .NET Prozess kommuniziert mit einer laufenden Excel-Instanz, weshalb Excel selbst auf dem Rechner installiert sein muss. Jedes Objekt, das Sie bearbeiten – Arbeitsmappen, Tabellenblätter, Bereiche, Pivot-Tabellen – ist ein COM-Wrapper und muss explizit freigegeben werden, um Speicherlecks zu vermeiden.
IronXL verfolgt einen grundlegend anderen Ansatz. Es liest und schreibt das Open XML-Dateiformat direkt, ohne Excel überhaupt zu starten. Das Ergebnis ist eine standardmäßige .NET Bibliothek mit vertrauten Objektmustern, automatischer Speicherbereinigung und ohne Abhängigkeit von der Office-Installation oder -Lizenzierung. Dank dieser Architektur eignet sich IronXL für serverseitige Workloads , Docker-Container, Linux-Hosts und jede .NET 6-, .NET 8- oder .NET 10-Umgebung.
| Kriterien | Excel-Interop | IronXL |
|---|---|---|
| Büro erforderlich | Ja | Nein |
| Nur für Windows | Ja | Nein – plattformübergreifend |
| Speicherverwaltung | Manuelle COM-Freigabe | Automatische (.NET GC) |
| Serverbereitstellung | Schwierig | Einfach |
| Native Pivot-Tabelle | Vollständige Excel-Pivot-API | Datenaggregation über LINQ |
| Lizenz erforderlich | Bürolizenz | IronXL Lizenz |
Excel-Interop wird als NuGet Paket ausgeliefert. Führen Sie eine der folgenden Optionen in Ihrem Projekt aus:
Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.ExcelBeachten Sie, dass das Paket allein nicht ausreicht – auf dem Zielrechner muss eine passende Version von Microsoft Excel installiert und ordnungsgemäß lizenziert sein. Diese Abhängigkeit schließt die meisten Server-, Container- und Cloud-Szenarien aus.
Installieren Sie IronXL über NuGet ohne zusätzliche Systemvoraussetzungen:
Nach der Installation können Sie sofort auf jeder Plattform, die .NET unterstützt, mit dem Lesen und Schreiben von Excel-Dateien beginnen. Keine Office-Lizenz, keine COM-Registrierung, keine Serverkonfiguration. Weitere Optionen, einschließlich der Offline-Installation und der Einrichtung von Projektreferenzen, finden Sie im IronXL-Installationshandbuch.
Der Interop-Pivot-Tabellen-Workflow folgt einer strikten Abfolge: Erstellen Sie einen Pivot-Cache aus einem Quellbereich, erstellen Sie dann ein PivotTable Objekt auf einem separaten Arbeitsblatt und konfigurieren Sie die Feldorientierungen. Das folgende Beispiel verwendet C#-Anweisungen auf oberster Ebene, die mit .NET 10 kompatibel sind:
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", "North", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "North", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "North", 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", "North", 1200},
{"Laptop", "South", 1500},
{"Phone", "North", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "North", 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)Jeder COM-Wrapper erfordert einen passenden Marshal.ReleaseComObject-Aufruf. Fehlt auch nur eine einzige Referenz, bleibt der Excel-Prozess im Hintergrund aktiv und verbraucht Speicher und Dateihandles, bis der Hostprozess beendet wird. Dieser Aufräumaufwand skaliert mit der Komplexität Ihrer Tabellenkalkulationsvorgänge.
IronXL stellt keine native Pivot-Tabellen-API wie Interop bereit – das Open XML Pivot-Format verfügt über Hunderte von XML-Attributen, und die meisten Geschäftsanforderungen werden zuverlässiger mit expliziter LINQ-Aggregation in reinem C# erfüllt. Das Ergebnis ist ein übersichtliches Übersichtsblatt, das beim Öffnen der Datei korrekt neu berechnet wird, ohne dass Excel einen Pivot-Cache aktualisieren muss.
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", "North", 1200 },
{ "Laptop", "South", 1500 },
{ "Phone", "North", 800 },
{ "Phone", "South", 950 },
{ "Tablet", "East", 600 },
{ "Tablet", "West", 750 },
{ "Monitor", "North", 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", "North", 1200},
{"Laptop", "South", 1500},
{"Phone", "North", 800},
{"Phone", "South", 950},
{"Tablet", "East", 600},
{"Tablet", "West", 750},
{"Monitor", "North", 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")Es müssen keine COM-Objekte freigegeben, kein Excel-Prozess beendet und keine Office-Lizenz verwaltet werden. Derselbe Code lässt sich ohne Änderungen unter Linux, macOS und Windows kompilieren und ausführen. Weitere Details zur Aggregations-API finden Sie in der IronXL WorkSheet-Dokumentation .
Die Bereitstellung einer Interop-basierten Anwendung erfordert die Überprüfung, ob in der Zielumgebung Windows ausgeführt wird, die richtige Office-Version installiert ist und auf dem Server COM-Automatisierungsberechtigungen konfiguriert sind. Cloud-basierte Umgebungen und containerisierte Workloads können diese Anforderungen in der Regel nicht erfüllen, ohne eine virtualisierte Windows-Desktop-Infrastruktur hinzuzufügen, was die Kosten und die betriebliche Komplexität erheblich erhöht.
IronXL unterliegt keinen solchen Einschränkungen. Fügen Sie das NuGet Paket hinzu, legen Sie Ihr Zielframework auf .NET 6 oder höher fest, und die Anwendung lässt sich auf jedem Host bereitstellen – einschließlich Linux-Containern, Azure App Service unter Linux, AWS Lambda und lokalen Windows-Servern. Auf der Seite mit den Systemanforderungen von IronXL finden Sie die vollständige Kompatibilitätsmatrix.
Interop-Fehler manifestieren sich als COM-Ausnahmen (COMException), die schwer in benutzerfreundliche Nachrichten umzuwandeln sind. Versionskonflikte zwischen der installierten Office-Version und der Interop-Assembly stellen eine weitere Fehlerquelle dar. Die Behebung dieser Probleme erfordert in der Regel die Reproduktion der exakten Office-Version auf einem Entwicklungsrechner.
IronXL wirft Standard-System.Exception-Unterklassen mit beschreibenden Nachrichten aus. Sie können Dateivorgänge in einen try-catch-Block einbetten und aussagekräftiges Feedback liefern, ohne die COM-Fehlercodes verstehen zu müssen. Der IronXL Leitfaden zur Fehlerbehebung behandelt häufige Ausnahmen und deren Lösungen.
COM-Objekte belegen nicht verwalteten Speicher. Wenn Ihr Code viele Arbeitsblätter verarbeitet oder in einer Schleife läuft, führt das Versäumnis, jede Referenz korrekt freizugeben, zu einem mit der Zeit zunehmenden Speicherverbrauch – ein Problem, das schwer zu erkennen ist, bis es zu einem Produktionsvorfall führt. Interop ist zudem von Natur aus Single-Threaded, da es nur ein einziges Excel-Fenster steuert.
IronXL verwendet verwaltete Objekte, die vom .NET Garbage-Collector unterstützt werden. Der Speicher wird automatisch freigegeben, wenn Objekte ihren Gültigkeitsbereich verlassen. Die parallele Verarbeitung mehrerer Arbeitsmappen ist unkompliziert, da kein gemeinsamer COM-Zustand mit Sperren geschützt werden muss.
Das richtige Tool hängt von zwei Bedingungen ab: wo der Code ausgeführt wird und ob natives Pivot-Tabellen-XML erforderlich ist.
Wählen Sie Excel-Interop, wenn:
Die Arbeitslast wird nur auf Windows-Desktop-Rechnern ausgeführt, auf denen Office bereits installiert ist.
Wählen Sie IronXL, wenn:
Die Anwendung läuft auf einem Server, in einem Container oder in einer Cloud-Funktion.
Für die meisten neuen .NET 10-Projekte ist IronXL die praktische Standardlösung. Die IronXL-Bibliothek deckt auch das Lesen von Excel-Dateien in C#, das Erstellen von Diagrammen, das Anwenden von Zellenstilen, die Arbeit mit Formeln und das Exportieren von Excel-Daten in DataTable ab, wodurch der Bedarf an mehreren Bibliotheken in Ihrem Stack verringert wird.
Über die grundlegende Aggregation hinaus bietet IronXL verschiedene Funktionen, die komplexere Datenanalyse-Workflows unterstützen:
Sie können einen Bereich vor dem Erstellen eines Zusammenfassungsblatts in aufsteigender oder absteigender Reihenfolge sortieren. Dadurch wird sichergestellt, dass die Ausgabe die Daten stets in einer konsistenten Reihenfolge präsentiert, was die nachfolgende Verarbeitung besser vorhersehbar macht. Sehen Sie sich die IronXL-Sortierdokumentation für Auswahlmöglichkeiten auf Bereichsebene an.
Heben Sie Ausreißer oder Schwellenwerte hervor, indem Sie bedingte Formatierungsregeln programmgesteuert anwenden. Beispielsweise können Sie Zellen im Übersichtsblatt rot einfärben, wenn die Umsätze unter ein Ziel fallen. So erhalten Sie einen schnellen Überblick, ohne dass die Endbenutzer Regeln manuell konfigurieren müssen.
Wenn die Quelldaten aus einer bestehenden Tabelle anstelle einer Datenbank stammen, können Sie sie direkt mit WorkBook.Load laden:
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}")Dieses Muster funktioniert für .xlsx, .xls, .csv und andere von IronXL unterstützte Formate. Einzelheiten zu den unterstützten Formaten finden Sie in der Dokumentation zum IronXL-Dateiformat.
Nachdem Sie ein zusammenfassendes Arbeitsblatt erstellt haben, können Sie es für nachgelagerte Systeme, die Excel nicht akzeptieren, im CSV-Format exportieren:
workbook.SaveAsCsv(@"C:\output\summary.csv");workbook.SaveAsCsv("C:\output\summary.csv")Dies ist besonders nützlich in ETL-Pipelines, bei denen der Endverbraucher ein Datenbankimporttool oder ein Data-Warehouse-Loader ist.
IronXL ist als kostenlose Testlizenz erhältlich, mit der Sie den vollen Funktionsumfang testen können, ohne ein Abonnement abzuschließen. Die Testversion fügt den Ausgabedateien ein Wasserzeichen hinzu, das Sie beim Anwenden eines Produktionslizenzschlüssels entfernen.
Um einen Lizenzschlüssel im Code zu aktivieren, muss dieser vor jeder IronXL Operation festgelegt werden:
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"Sie können den Schlüssel auch über eine Umgebungsvariable (IRONXL_LICENSEKEY) oder über appsettings.json in ASP.NET Core-Projekten festlegen. Auf der IronXL Lizenzseite werden alle verfügbaren Stufen beschrieben, einschließlich Team- und Organisationsoptionen.
Für Produktionsbereitstellungen lesen Sie die IronXL-Bereitstellungsdokumentation und die umfangreichere IronXL-Tutorial-Bibliothek für Muster, die ASP.NET Core, Azure Functions und Docker betreffen.
Excel-Pivot-Tabellen in C# müssen nicht zwangsläufig Office-Abhängigkeit und COM-Komplexität bedeuten. Mit IronXL schreiben Sie einfachen .NET Code, der auf jeder Plattform läuft, die Speicherverwaltung automatisch übernimmt und sich nahtlos in Unit-Testing-Frameworks und CI/CD-Pipelines integriert.
Laden Sie die kostenlose Testversion von IronXL herunter und führen Sie die Beispiele aus diesem Leitfaden mit Ihren eigenen Daten aus. Bei Fragen stehen Ihnen das IronXL -Community-Forum und das Support-Portal sowohl für Test- als auch für Lizenznutzer zur Verfügung. Sobald Sie bereit für die Bereitstellung sind, prüfen Sie die Lizenzoptionen , um den Plan zu finden, der zu Ihrer Teamgröße und Ihrem Nutzungsvolumen passt.
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronXL ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Das Excel-API, das Sie brauchen, ohne den Office Interop Aufwand.
