Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. Iron Software
  2. IronXL Blog
  3. IronXL verwenden
  4. Blogbeitrag zum Erstellen von Pivot-Tabellen in Excel
IRONXL VERWENDEN

Wie man mit IronXL in C# Pivot-Tabellen in Excel erstellt

Jordi Bardia
Jordi Bardia
Aktualisiert:

Um Pivot-Tabellen in Excel programmatisch zu erstellen, benötigt man entweder C# Interop mit seinen Office-Abhängigkeiten oder eine moderne Bibliothek wie IronXL , die unabhängig funktioniert – dieses Tutorial demonstriert beide Ansätze und zeigt Ihnen genau, warum der moderne Weg die bessere Wahl ist.

Das Erstellen von Pivot-Berichten in serverseitigem oder plattformübergreifendem .NET -Code war in der Vergangenheit mühsam. Der traditionelle COM-Interop-Ansatz bindet Sie an einen Windows-Rechner mit einer vollständigen Office-Installation, erzeugt Speicherlecks, wenn Sie einen einzigen COM-Bereinigungsaufruf verpassen, und versagt sofort, wenn Sie versuchen, auf Linux oder in einem Docker-Container bereitzustellen. Die moderne Alternative – das Schreiben von Aggregationslogik mit IronXL und LINQ – läuft überall dort, wo .NET läuft, benötigt keine Office-Lizenz und liefert sauberen, lesbaren Code.

Dieser Leitfaden erläutert beide Techniken im Detail. Sie werden den ursprünglichen Interop-Ansatz kennenlernen, genau verstehen, was ihn so anfällig macht, und dann mit IronXL in C# die gleiche Pivot-Tabelle erstellen. Sie erfahren außerdem, wie Sie Excel-Formeln für Live-Zusammenfassungen verwenden, die sich automatisch aktualisieren und sich wie eine echte Pivot-Tabellenaktualisierung verhalten.

Was ist eine Excel-Pivot-Tabelle?

Eine Pivot-Tabelle ist eines der leistungsstärksten Analysewerkzeuge in Tabellenkalkulationsprogrammen. Es fasst große Datensätze zusammen, indem es Zeilen gruppiert, Werte aggregiert und die Ergebnisse in einem Kreuztabellenlayout darstellt – und das alles, ohne dass Sie eine einzige Formel manuell schreiben müssen. Die offizielle Pivot-Tabellen-Dokumentation von Microsoft bietet einen umfassenden Überblick über die Funktionsweise dieser Funktion innerhalb von Excel selbst.

Pivot-Tabellen sind in Microsoft Excel, Google Sheets, Apple Numbers und den meisten anderen Tabellenkalkulationsprogrammen verfügbar. Das Grundkonzept ist immer dasselbe: Sie definieren Zeilenfelder, Spaltenfelder und Wertfelder, und das Tool erstellt daraus eine Zusammenfassungsmatrix. Wenn sich die zugrunde liegenden Daten ändern, aktualisieren Sie die Pivot-Tabelle und die Zusammenfassung wird automatisch aktualisiert.

Im serverseitigen C#-Code haben Sie im Wesentlichen zwei Möglichkeiten:

  • C# Interop – automatisiert einen laufenden Excel-Prozess über COM, um ein natives PivotTable-Objekt in einer XLSX-Datei zu erstellen.
  • IronXL mit LINQ-Aggregation – liest die Arbeitsmappe in den Speicher, berechnet dieselbe Zusammenfassung in verwaltetem .NET -Code und schreibt das Ergebnis in ein neues Arbeitsblatt.

Beide Optionen liefern ein brauchbares Ergebnis. Aber nur eine davon funktioniert in modernen Einsatzumgebungen zuverlässig.

Wie erstellt man eine Pivot-Tabelle mit C# Interop?

C# Excel Interop ermöglicht Ihnen den direkten Zugriff auf die native Pivot-Tabellen-Funktionalität von Excel über COM-Automatisierung. Sie erstellen ein Excel.Application-Objekt, öffnen eine Arbeitsmappe, definieren einen Pivot-Cache, der auf einen Datenbereich verweist, und konfigurieren dann Zeilenfelder, Spaltenfelder und Datenfelder.

So richten Sie den Interop-PivotTable-Code ein

using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;

// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();

// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;

// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase,
    dataRange,
    Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
    xlPivotSheet.Cells[3, 1],
    "SalesPivot",
    Type.Missing,
    Type.Missing);

// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;

Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;

Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);

// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();

// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);
using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;

// Create Excel application instance
Excel.Application xlApp = new Excel.Application();
Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(@"C:\Data\SalesData.xlsx");
Excel.Worksheet xlSheet = (Excel.Worksheet)xlWorkbook.Sheets[1];
Excel.Worksheet xlPivotSheet = (Excel.Worksheet)xlWorkbook.Sheets.Add();

// Define data range for pivot table
Excel.Range dataRange = xlSheet.UsedRange;

// Create pivot cache and pivot table
Excel.PivotCache pivotCache = xlWorkbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase,
    dataRange,
    Type.Missing);
Excel.PivotTable pivotTable = pivotCache.CreatePivotTable(
    xlPivotSheet.Cells[3, 1],
    "SalesPivot",
    Type.Missing,
    Type.Missing);

// Configure pivot table fields
Excel.PivotField productField = (Excel.PivotField)pivotTable.PivotFields("Product");
productField.Orientation = Excel.XlPivotFieldOrientation.xlRowField;
productField.Position = 1;

Excel.PivotField regionField = (Excel.PivotField)pivotTable.PivotFields("Region");
regionField.Orientation = Excel.XlPivotFieldOrientation.xlColumnField;
regionField.Position = 1;

Excel.PivotField salesField = (Excel.PivotField)pivotTable.PivotFields("Sales");
pivotTable.AddDataField(salesField, "Sum of Sales", Excel.XlConsolidationFunction.xlSum);

// Save and cleanup
xlWorkbook.SaveAs(@"C:\Data\PivotReport.xlsx");
xlWorkbook.Close();
xlApp.Quit();

// Release COM objects to prevent memory leaks
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(xlPivotSheet);
Marshal.ReleaseComObject(xlSheet);
Marshal.ReleaseComObject(xlWorkbook);
Marshal.ReleaseComObject(xlApp);
$vbLabelText   $csharpLabel

Dieses Interop-Beispiel erstellt eine native Excel-Pivot-Tabelle mit Produkt als Zeilen, Region als Spalten und Umsatz als Summe im Datenbereich. Es erzeugt zwar ein echtes Pivot-Tabellenobjekt innerhalb der XLSX-Datei, setzt aber die Installation von Microsoft Office voraus und erfordert eine sorgfältige Verwaltung der COM-Objekte. Verpassen Sie auch nur einen einzigen Marshal.ReleaseComObject-Aufruf, werden Sie feststellen, dass sich veraltete Excel-Prozesse im Task-Manager ansammeln.

Wie man IronXL installiert, bevor man Code schreibt

Bevor Sie mit IronXL arbeiten, installieren Sie die Bibliothek über den NuGet Paketmanager:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel
Install-Package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

Auf dem Server, im Container oder auf dem Entwicklungsrechner ist keine Office-Installation erforderlich. IronXL liest und schreibt XLSX-, XLS- und CSV-Dateien vollständig im verwalteten .NET Speicher.

Welche Probleme entstehen durch C# Interop?

Der Interop-Ansatz birgt mehrere bedeutende Herausforderungen, die sich bei der praktischen Anwendung schnell verstärken. Stack Overflow und andere Programmierressourcen empfehlen es weiterhin, weil viele Threads Anfang der 2000er Jahre geschrieben wurden und seitdem gesperrt sind – der Rat ist also eingefroren.

Bereitstellungsabhängigkeiten – auf jedem Rechner, auf dem Ihr Code ausgeführt wird, muss eine lizenzierte Kopie von Microsoft Office installiert sein, einschließlich Produktionsserver und CI/CD-Build-Agenten. Dies führt zu zusätzlichen Lizenzkosten und einer erhöhten Komplexität bei der Bereitstellung, die mit modernen Alternativen vollständig vermeidbar sind.

Speicherverwaltungsaufwand -- COM-Objekte müssen explizit mit Marshal.ReleaseComObject() freigegeben werden. Fehlt auch nur ein einziges Objekt, so führt dies dazu, dass Excel-Prozesse unbegrenzt im Speicher hängen bleiben, wie auf Stack Overflow ausführlich dokumentiert wurde . Bei einem langlaufenden Dienst oder einer ASP.NET Webanwendung wird dies zu einem kritischen Ressourcenleck.

Plattformbeschränkungen -- Interop funktioniert nur unter Windows mit installiertem Office. Sie können es nicht unter Linux, macOS, in Docker-Containern oder auf serverlosen Plattformen wie Azure Functions oder AWS Lambda ausführen. Das verschließt Ihnen den Zugang zu modernen Cloud-nativen Architekturen vollständig.

Leistungsengpässe – das Starten einer Excel-Anwendung ist langsam und ressourcenintensiv. Bei der serverseitigen Stapelverarbeitung, bei der Dutzende oder Hunderte von Berichten generiert werden müssen, stellt dieser Startaufwand eine ernsthafte Durchsatzbeschränkung dar.

Inkompatibilität der Versionen – verschiedene Office-Versionen bieten leicht unterschiedliche COM-Schnittstellen. Code, der mit Office 2019 funktioniert, kann sich unter Umständen anders verhalten als unter Office 2016 oder Microsoft 365, und es gibt keine Möglichkeit, die Version bei einer Bereitstellung festzulegen. In der Microsoft-Dokumentation zu Office Interop-Assemblies werden diese Versionsbeschränkungen als bekannte Einschränkung aufgeführt.

CI/CD-Inkompatibilität – in den meisten Continuous-Integration-Umgebungen ist Office nicht installiert. Für das Testen Ihres Pivot-Tabellen-Generierungscodes ist entweder das Simulieren der gesamten COM-Schicht oder die Wartung eines speziellen Windows-Agenten mit einer lizenzierten Office-Installation erforderlich.

Für jede neue .NET Anwendung, die auf .NET 6 oder höher abzielt – einschließlich .NET 10 –, machen diese Einschränkungen Interop zu einer unpraktischen Wahl.

Wie erstellt IronXL Pivot-Tabellen ohne Interop?

IronXL geht bei der Erstellung von Pivot-Tabellen anders vor. Anstatt einen externen Excel-Prozess über COM zu steuern, liest IronXL Ihre Arbeitsmappe in den verwalteten .NET -Speicher ein und ermöglicht Ihnen so den direkten Zugriff auf Zellwerte, Formeln und die Struktur des Arbeitsblatts. Anschließend erstellen Sie Pivot-artige Aggregationen mithilfe von Standard-LINQ-Abfragen und schreiben die Ergebnisse zurück in ein neues Arbeitsblatt.

Wie man mit IronXL und LINQ eine Kreuztabellenübersicht erstellt

Das folgende Beispiel lädt eine Verkaufsdaten-Arbeitsmappe, berechnet eine Kreuztabelle nach Produkt und Region und schreibt die Zusammenfassung in ein neues Arbeitsblatt – alles ohne Office-Abhängigkeit:

using IronXL;
using System.Linq;
using System.Data;

// Load Excel file -- no Office installation required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];

// Convert to DataTable for flexible LINQ manipulation
var dataTable = dataSheet.ToDataTable(true); // true = first row as column headers

// Build pivot-style aggregation using LINQ grouping
var pivotData = dataTable.AsEnumerable()
    .GroupBy(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Select(g => new {
        Product = g.Key.Product,
        Region = g.Key.Region,
        TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
        AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
        Count = g.Count()
    });

// Create the pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

// Get distinct row and column values
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p).ToList();
var regions  = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r).ToList();

// Write column headers
pivotSheet["A1"].Value = "Product / Region";
for (int c = 0; c < regions.Count; c++)
{
    pivotSheet[$"{(char)('B' + c)}1"].Value = regions[c];
}

// Populate data rows
for (int r = 0; r < products.Count; r++)
{
    pivotSheet[$"A{r + 2}"].Value = products[r];
    for (int c = 0; c < regions.Count; c++)
    {
        var sales = pivotData
            .Where(p => p.Product == products[r] && p.Region == regions[c])
            .Select(p => p.TotalSales)
            .FirstOrDefault();
        pivotSheet[$"{(char)('B' + c)}{r + 2}"].Value = sales;
    }
}

// Add a totals row using Excel SUM formulas
int totalRow = products.Count + 2;
pivotSheet[$"A{totalRow}"].Value = "Total";
for (int c = 0; c < regions.Count; c++)
{
    char col = (char)('B' + c);
    pivotSheet[$"{col}{totalRow}"].Formula = $"=SUM({col}2:{col}{totalRow - 1})";
}

// Apply currency formatting to the data range
var dataRange = pivotSheet[$"B2:{(char)('B' + regions.Count - 1)}{totalRow}"];
dataRange.FormatString = "$#,##0.00";

workbook.SaveAs("PivotReport.xlsx");
using IronXL;
using System.Linq;
using System.Data;

// Load Excel file -- no Office installation required
WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet dataSheet = workbook.WorkSheets[0];

// Convert to DataTable for flexible LINQ manipulation
var dataTable = dataSheet.ToDataTable(true); // true = first row as column headers

// Build pivot-style aggregation using LINQ grouping
var pivotData = dataTable.AsEnumerable()
    .GroupBy(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Select(g => new {
        Product = g.Key.Product,
        Region = g.Key.Region,
        TotalSales = g.Sum(row => Convert.ToDecimal(row["Sales"])),
        AverageSale = g.Average(row => Convert.ToDecimal(row["Sales"])),
        Count = g.Count()
    });

// Create the pivot report worksheet
WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");

// Get distinct row and column values
var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p).ToList();
var regions  = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r).ToList();

// Write column headers
pivotSheet["A1"].Value = "Product / Region";
for (int c = 0; c < regions.Count; c++)
{
    pivotSheet[$"{(char)('B' + c)}1"].Value = regions[c];
}

// Populate data rows
for (int r = 0; r < products.Count; r++)
{
    pivotSheet[$"A{r + 2}"].Value = products[r];
    for (int c = 0; c < regions.Count; c++)
    {
        var sales = pivotData
            .Where(p => p.Product == products[r] && p.Region == regions[c])
            .Select(p => p.TotalSales)
            .FirstOrDefault();
        pivotSheet[$"{(char)('B' + c)}{r + 2}"].Value = sales;
    }
}

// Add a totals row using Excel SUM formulas
int totalRow = products.Count + 2;
pivotSheet[$"A{totalRow}"].Value = "Total";
for (int c = 0; c < regions.Count; c++)
{
    char col = (char)('B' + c);
    pivotSheet[$"{col}{totalRow}"].Formula = $"=SUM({col}2:{col}{totalRow - 1})";
}

// Apply currency formatting to the data range
var dataRange = pivotSheet[$"B2:{(char)('B' + regions.Count - 1)}{totalRow}"];
dataRange.FormatString = "$#,##0.00";

workbook.SaveAs("PivotReport.xlsx");
$vbLabelText   $csharpLabel

Dadurch wird die gleiche Kreuztabellenübersicht erzeugt, die man auch mit einer nativen Excel-Pivot-Tabelle erhalten würde. Sie haben die volle programmatische Kontrolle über jede Zelle, Formel und Formatzeichenfolge – und es müssen keine COM-Objekte bereinigt werden.

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 1 – Die originale Excel-Datei im Vergleich zur erstellten Pivot-Tabelle mit den Zellen.

Starten Sie jetzt mit IronXL.
green arrow pointer

Wie erstellt man dynamische Zusammenfassungen mithilfe von Excel-Formeln?

Für Szenarien, in denen das Übersichtsblatt aktiv bleiben soll – also automatisch neu berechnet werden soll, sobald sich die Quelldaten ändern – ermöglicht IronXL das direkte Schreiben von Excel-Formelzeichenfolgen in Zellen. Dies bietet ein ähnliches Verhalten wie die automatische Aktualisierung einer Pivot-Tabelle, jedoch ohne Interop-Abhängigkeit.

Die wichtigsten Funktionen hier sind SUMIFS und COUNTIFS. SUMIFS summiert einen Bereich basierend auf mehreren Kriterienspaltenbedingungen; COUNTIFS zählt übereinstimmende Zeilen. Beide Formate akzeptieren Verweise auf benannte Arbeitsblätter, sodass Sie Ihr Zusammenfassungsblatt direkt namentlich auf das Quelldatenblatt verweisen können.

Wie man formelbasierte Aggregationen mit IronXL schreibt

using IronXL;
using System.Data;

string inputPath  = "SalesData.xlsx";
string outputPath = "DynamicSummary.xlsx";

WorkBook workbook  = WorkBook.Load(inputPath);
WorkSheet dataSheet = workbook.WorkSheets[0];

// Name the data sheet so formula references are stable
dataSheet.Name = "DataSheet";

// Convert to DataTable to enumerate unique product/region combinations
DataTable dataTable = dataSheet.ToDataTable(true);

WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region pairs
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region  = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region)
    .ToList();

// Header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with live SUMIFS / COUNTIFS formulas
for (int i = 0; i < uniqueCombos.Count; i++)
{
    int rowIndex = i + 2;
    var combo = uniqueCombos[i];

    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

    summarySheet[$"C{rowIndex}"].Formula =
        $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";

    summarySheet[$"D{rowIndex}"].Formula =
        $"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
}

// Grand total row
int totalRow = uniqueCombos.Count + 2;
summarySheet[$"A{totalRow}"].Value = "Total";
summarySheet[$"C{totalRow}"].Formula = $"=SUM(C2:C{totalRow - 1})";
summarySheet[$"D{totalRow}"].Formula = $"=SUM(D2:D{totalRow - 1})";

workbook.SaveAs(outputPath);
using IronXL;
using System.Data;

string inputPath  = "SalesData.xlsx";
string outputPath = "DynamicSummary.xlsx";

WorkBook workbook  = WorkBook.Load(inputPath);
WorkSheet dataSheet = workbook.WorkSheets[0];

// Name the data sheet so formula references are stable
dataSheet.Name = "DataSheet";

// Convert to DataTable to enumerate unique product/region combinations
DataTable dataTable = dataSheet.ToDataTable(true);

WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");

// Get unique product-region pairs
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region  = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region)
    .ToList();

// Header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";

// Populate rows with live SUMIFS / COUNTIFS formulas
for (int i = 0; i < uniqueCombos.Count; i++)
{
    int rowIndex = i + 2;
    var combo = uniqueCombos[i];

    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;

    summarySheet[$"C{rowIndex}"].Formula =
        $"=SUMIFS(DataSheet!C:C,DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";

    summarySheet[$"D{rowIndex}"].Formula =
        $"=COUNTIFS(DataSheet!A:A,\"{combo.Product}\",DataSheet!B:B,\"{combo.Region}\")";
}

// Grand total row
int totalRow = uniqueCombos.Count + 2;
summarySheet[$"A{totalRow}"].Value = "Total";
summarySheet[$"C{totalRow}"].Formula = $"=SUM(C2:C{totalRow - 1})";
summarySheet[$"D{totalRow}"].Formula = $"=SUM(D2:D{totalRow - 1})";

workbook.SaveAs(outputPath);
$vbLabelText   $csharpLabel

Diese Formeln halten die Verbindung zu den Quelldaten aufrecht. Wenn jemand einen Wert in DataSheet aktualisiert, berechnet Excel die Zusammenfassung beim nächsten Öffnen oder Aktualisieren automatisch neu – das entspricht dem Aktualisierungszyklus einer nativen Pivot-Tabelle, ohne dass eine COM-Automatisierung erforderlich ist.

Wenn Sie dies auf dieselbe Verkaufsdaten-Arbeitsmappe anwenden, die im vorherigen Beispiel verwendet wurde, sieht die Ausgabe wie folgt aus:

Erstellung von Pivot-Tabellen in Excel mit C# Interop vs. IronXL: Bild 2 – Ausgabe dynamischer Zusammenfassungen in C# im Kontext.

Dieser formelbasierte Ansatz ermöglicht es Ihnen außerdem, mithilfe der Zellformatierungs-API von IronXL bedingte Formatierungen, Datenbalken oder Symbolgruppen zu den Zusammenfassungszellen hinzuzufügen, wodurch Ihre Berichte ohne manuelle Eingriffe in der Excel-Benutzeroberfläche visuell übersichtlich werden.

Wie lassen sich die beiden Ansätze vergleichen?

Bevor man sich für einen Ansatz entscheidet, ist es hilfreich, die jeweiligen Vor- und Nachteile gegenüberzustellen. Die folgende Tabelle behandelt die wichtigsten Dimensionen für die produktive .NET -Entwicklung:

C# Interop vs. IronXL für die Pivot-Tabellengenerierung
Aspekt C# Interop IronXL
Büro erforderlich Ja – vollständige Installation auf jedem Gerät Nein – eigenständiges NuGet Paket
Plattformunterstützung Nur für Windows Windows, Linux, macOS, Docker
Speicherverwaltung Manuelle COM-Bereinigung erforderlich Automatische .NET-Garbage-Collection
Bereitstellungskomplexität Hochwertig – Bürolizenzierung + Installation Niedrig – einzelne DLL-Referenz
Leistung Langsam – Hoher Aufwand beim Start des Excel-Prozesses Schnell – Berechnungen im Arbeitsspeicher
Cloud-kompatibel Nein – blockiert für Azure Functions und AWS Lambda Ja – läuft auf jeder Cloud-Plattform.
Natives Pivot-Tabellenobjekt Ja – vollständige Excel-Pivot-Tabelle Nein – Äquivalent auf Basis von Aggregation
Entwicklungsgeschwindigkeit Langsam -- COM-Komplexität Schnelle und reibungslos verwaltete API
.NET 10 support Eingeschränkt -- COM-Bindungsprobleme Vollständig – zielt auf moderne .NET Versionen ab.

Der einzige Fall, in dem Interop einen klaren Vorteil bietet, ist, wenn Sie das native Excel-PivotTable-Objekt unbedingt in die XLSX-Datei eingebettet benötigen – beispielsweise, wenn nachgelagerte Benutzer mit der integrierten PivotTable-Benutzeroberfläche von Excel interagieren müssen (Drilldown, Filtern, interaktives Ändern von Aggregationsfunktionen). In allen anderen Fällen ist der Ansatz von IronXL schneller zu entwickeln, einfacher einzusetzen und weitaus portabler.

Welchen Ansatz sollten Sie wählen?

Die richtige Wahl hängt von Ihrer Einsatzumgebung und den Bedürfnissen Ihrer Benutzer ab.

Wählen Sie C# Interop nur dann, wenn:

Ihre Benutzer benötigen native Excel-Pivot-Tabellenobjekte, die sie interaktiv in der Excel-Benutzeroberfläche bearbeiten können.

  • Sie zielen auf eine geschlossene Windows-Desktopumgebung ab, in der Office garantiert auf jedem Rechner installiert ist. Sie pflegen veralteten .NET Framework -Code, der bereits von Interop abhängt, und eine Neuentwicklung ist derzeit nicht gerechtfertigt.

Wählen Sie IronXL, wenn:

  • Sie stellen die Anwendung auf einem Server, in einem Container oder in einer beliebigen Cloud-Umgebung (Azure, AWS, GCP) bereit.
  • Sie benötigen plattformübergreifende Unterstützung für Linux-, macOS- oder Docker-basierte Builds.
  • Sie möchten sauberen, wartbaren Code ohne COM-Lebenszyklusmanagement.
  • Sie zielen auf .NET 5, 6, 7, 8, 9 oder 10 ab.
  • Sie möchten die Microsoft Office-Lizenzgebühren auf der Serverinfrastruktur vermeiden. Sie benötigen eine schnelle Stapelverarbeitung vieler Arbeitsmappen ohne separaten Excel-Prozessstart für jede Datei.

Für die überwiegende Mehrheit moderner .NET Anwendungen ist IronXL die optimale Lösung. Die auf Aggregation basierende Ausgabe erfüllt alle gängigen Berichtsanforderungen, und Sie erhalten im Gegenzug volle Portabilität.

Weitere Funktionen – darunter Zellformatierung, Formelauswertung, Datenvalidierung und Diagrammerstellung – können Sie in der IronXL -Dokumentation und der IronXL -Beispielbibliothek erkunden.

Wie können Sie heute mit IronXL beginnen?

Die IronXL Bibliothek ist auf NuGet verfügbar und lässt sich in weniger als einer Minute zu jedem .NET Projekt hinzufügen:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel
Install-Package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

Nach der Installation können Sie eine bestehende Arbeitsmappe laden oder eine neue erstellen, Zellwerte lesen und schreiben, Formeln anwenden, Formatierungszeichenfolgen festlegen und im XLSX-Format speichern – alles mit einer übersichtlichen und gut dokumentierten API. Es gibt kein COM, keine Office-Abhängigkeit und keine spezielle Serverkonfiguration ist erforderlich.

Die vollständige API-Dokumentation finden Sie im IronXL -Leitfaden für Einsteiger , im C# Excel Interop-Migrationsleitfaden und in den IronXL -Codebeispielen . Sie können IronXL auch mit anderen Excel-Bibliotheken in den IronXL Vergleichsartikeln vergleichen.

Mit einer kostenlosen Testlizenz können Sie den vollen Funktionsumfang in Ihrem eigenen Projekt testen, bevor Sie sich endgültig entscheiden. Wenn Sie bereit sind, in der Produktion zu operieren, entfernt eine kommerzielle IronXL Lizenz das Testwasserzeichen und beinhaltet priorisierten Support. Starten Sie mit der kostenlosen Testversion und sehen Sie selbst, wie viel einfacher die plattformübergreifende Excel-Automatisierung sein kann.

Häufig gestellte Fragen

Wie kann ich in Excel mit C# ohne Interop Pivot-Tabellen erstellen?

Mit IronXL können Sie in Excel mithilfe von C# ohne Interop Pivot-Tabellen erstellen. IronXL bietet leistungsstarke Datenmanipulationsfunktionen, die unabhängig von Office-Abhängigkeiten sind.

Welche Vorteile bietet die Verwendung von IronXL zur Erstellung von Pivot-Tabellen?

IronXL ermöglicht es Entwicklern, Pivot-Tabellen zu erstellen, ohne auf Excel Interop angewiesen zu sein. Dadurch entfällt die Notwendigkeit von Office-Installationen und die Komplexität der Bereitstellung wird reduziert.

Ist IronXL mit .NET-Anwendungen kompatibel?

Ja, IronXL ist vollständig kompatibel mit .NET Anwendungen und bietet eine benutzerfreundliche API für Excel-Operationen, einschließlich der Erstellung von Pivot-Tabellen.

Benötigt IronXL die Installation von Excel auf dem Server?

Nein, IronXL benötigt keine Installation von Excel auf dem Server. Es funktioniert unabhängig und ermöglicht so eine nahtlose Integration in serverseitige Anwendungen.

Kann ich Daten in Excel mit IronXL bearbeiten?

Ja, IronXL bietet leistungsstarke Datenmanipulationsfunktionen, die es Entwicklern ermöglichen, Excel-Daten zu erstellen, zu modifizieren und zu analysieren, einschließlich der Erstellung von Pivot-Tabellen.

Warum könnten Entwickler IronXL gegenüber herkömmlichen Interop-Methoden bevorzugen?

Entwickler könnten IronXL gegenüber herkömmlichen Interop-Methoden bevorzugen, da es keine Office-Abhängigkeiten aufweist, einfacher zu implementieren ist und einen umfassenden Funktionsumfang für Excel-Operationen bietet.

Welche Funktionen bietet IronXL zur Excel-Datenmanipulation?

IronXL bietet Funktionen wie das Lesen und Schreiben von Excel-Dateien, das Erstellen und Bearbeiten von Tabellenkalkulationen und das Generieren von Pivot-Tabellen, alles ohne dass Excel Interop erforderlich ist.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me