Wie erstellt man eine Pivot-Tabelle in Excel mit C# Interop vs IronXL

Was ist eine Excel-Pivot-Tabelle?

Ein Pivot-Typ ist eines der leistungsfähigsten Werkzeuge, die man in Excel hinzufügen kann. Eine einfache Methode zur Zusammenfassung großer Datensätze. Dementsprechend ermöglichen Pivot-Tabellen Ihnen, numerische Daten einfach anzuzeigen, zu verstehen und zu analysieren. Pivot-Tabellen sind nicht nur in Excel verfügbar, sondern auch in anderen Programmen wie Google Sheets, Apple Numbers und CSV-Exports. Es bietet eine Lösung, um die Daten in einer Übersicht zu sehen - es fungiert als Datenkonsole, um den Menschen zu ermöglichen, ihre Informationen auf bedeutungsvolle Weise anzuzeigen - eine Verbindung zur Realität herzustellen.

Lassen Sie uns eine Pivot-Tabelle auf die falsche Art und dann richtig in C# erstellen:

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

C# Excel Interop bietet direkten Zugriff auf die Pivot-Tabellen-Funktionalität von Excel durch COM-Automatisierung. Hier ist der traditionelle Ansatz, den viele Entwickler finden, wenn sie nach einem Tool zur Erstellung einer Pivot-Tabelle in C# suchen: (Veraltet)

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;
// Row area and column area
// 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); // fields by field
// 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;
// Row area and column area
// 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); // fields by field
// 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);

Welche Probleme erzeugt C# Interop?

Der Interop-Ansatz stellt mehrere erhebliche Herausforderungen dar:

Leider empfehlen Stack Overflow und andere Programmierwebseiten es weiterhin, weil sie in der Zeit stehen geblieben sind und Threads aus den frühen 2000er Jahren verwenden, die auf Ideen basieren.

Bereitstellungsabhängigkeiten: Erfordert die Installation von Microsoft Office auf jeder Maschine, die den Quellcode ausführt, einschließlich der Produktionsserver. Dies fügt Lizenzkosten und Bereitstellungskomplexität hinzu.

Speicherverwaltung: COM-Objekte müssen explizit mit Marshal.ReleaseComObject() freigegeben werden. Schon das Fehlen eines einzigen Objekts führt dazu, dass Excel-Prozesse im Speicher hängen bleiben, wie ausführlich auf Stack Overflow dokumentiert. Betrachten Sie den Pivot-Cache.

Details zur Plattformbeschränkung: Diese altmodische Lösung funktioniert nur auf Windows mit installiertem Office. Und kann unglaublich langsam sein - verwirrend für den Benutzer und kann zu Speicherlecks führen. Keine Unterstützung für Linux, macOS, Docker-Container oder Cloud-Plattformen wie Azure Functions.

Leistungsprobleme: Das Starten von Excel-Anwendungsinstanzen ist langsam und ressourcenintensiv, insbesondere für serverseitige Verarbeitung.

Version-Kompatibilität: Unterschiedliche Office-Versionen können unterschiedliche COM-Schnittstellen haben, was zu Kompatibilitätsproblemen zwischen Umgebungen führen kann.

Wie erstellt IronXLprogrammgesteuert eine Pivot-Tabelle ohne Interop?

IronXL geht die Erstellung von Pivot-Tabellen anders an, indem es verwalteten Code ohne COM-Abhängigkeiten verwendet. Während es keine nativen Excel-Pivot-Tabellen erstellt, bietet es leistungsstarke Aggregationsfähigkeiten:

Wie man auf moderne Weise programmgesteuert eine XLSX- oder XLS-Pivottabelle erstellt:

using IronXL;
using System.Linq;
using System.Data; // Keep this namespace
using static System.Data.DataTableExtensions; // Use 'using static' for DataTableExtensions
class Program
{
    static void Main(string[] args)
    {
        // Load Excel file - no Office required
        WorkBook workbook = WorkBook.Load("SalesData.xlsx");
        WorkSheet dataSheet = workbook.WorkSheets[0];
        // Convert to DataTable for powerful manipulation
        var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers
        // Create pivot-style aggregation using LINQ
        var pivotData = dataTable.AsEnumerable()
            .GroupBy(row => new {
                Product = row["Product"].ToString(),
                Region = row["Region"].ToString()
            }) //range
            .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 pivot report worksheet
        WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");
        // Build cross-tabulation structure
        var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
        var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);
        // Create headers
        pivotSheet["A1"].Value = "Product/Region";
        int col = 2;
        foreach (var region in regions)
        {
            pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // string
            col++;
        }
        // Populate pivot data
        int row = 2;
        foreach (var product in products)
        {
            pivotSheet[$"A{row}"].Value = product;
            col = 2;
            foreach (var region in regions)
            {
                var sales = pivotData
                    .Where(p => p.Product == product && p.Region == region)
                    .Select(p => p.TotalSales)
                    .FirstOrDefault();
                pivotSheet[$"{(char)('A' + col - 1)}{row}"].Value = sales;
                col++;
            }
            row++;
        }
        // Add totals using Excel formulas
        pivotSheet[$"A{row}"].Value = "Total"; // grand totals
        for (int c = 2; c <= regions.Count() + 1; c++)
        {
            pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
        }
        // Proceeding to apply formatting
        var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
        dataRange.FormatString = "$#,##0.00";
        workbook.SaveAs("PivotReport.xlsx");
    }
}

using IronXL;
using System.Linq;
using System.Data; // Keep this namespace
using static System.Data.DataTableExtensions; // Use 'using static' for DataTableExtensions
class Program
{
    static void Main(string[] args)
    {
        // Load Excel file - no Office required
        WorkBook workbook = WorkBook.Load("SalesData.xlsx");
        WorkSheet dataSheet = workbook.WorkSheets[0];
        // Convert to DataTable for powerful manipulation
        var dataTable = dataSheet.ToDataTable(true); // true = use first row as column headers
        // Create pivot-style aggregation using LINQ
        var pivotData = dataTable.AsEnumerable()
            .GroupBy(row => new {
                Product = row["Product"].ToString(),
                Region = row["Region"].ToString()
            }) //range
            .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 pivot report worksheet
        WorkSheet pivotSheet = workbook.CreateWorkSheet("PivotReport");
        // Build cross-tabulation structure
        var products = pivotData.Select(p => p.Product).Distinct().OrderBy(p => p);
        var regions = pivotData.Select(p => p.Region).Distinct().OrderBy(r => r);
        // Create headers
        pivotSheet["A1"].Value = "Product/Region";
        int col = 2;
        foreach (var region in regions)
        {
            pivotSheet[$"{(char)('A' + col - 1)}1"].Value = region; // string
            col++;
        }
        // Populate pivot data
        int row = 2;
        foreach (var product in products)
        {
            pivotSheet[$"A{row}"].Value = product;
            col = 2;
            foreach (var region in regions)
            {
                var sales = pivotData
                    .Where(p => p.Product == product && p.Region == region)
                    .Select(p => p.TotalSales)
                    .FirstOrDefault();
                pivotSheet[$"{(char)('A' + col - 1)}{row}"].Value = sales;
                col++;
            }
            row++;
        }
        // Add totals using Excel formulas
        pivotSheet[$"A{row}"].Value = "Total"; // grand totals
        for (int c = 2; c <= regions.Count() + 1; c++)
        {
            pivotSheet[$"{(char)('A' + c - 1)}{row}"].Formula = $"=SUM({(char)('A' + c - 1)}2:{(char)('A' + c - 1)}{row - 1})";
        }
        // Proceeding to apply formatting
        var dataRange = pivotSheet[$"B2:{(char)('A' + regions.Count())}{row}"];
        dataRange.FormatString = "$#,##0.00";
        workbook.SaveAs("PivotReport.xlsx");
    }
}

So erstellt man 2025 Pivot-Tabellen.

Wie erstellt man dynamische Zusammenfassungen mit IronXL-Formeln?

Für Szenarien, die dynamische Aktualisierungen erfordern, ähnlich wie das Erstellen einer Pivot-Tabelle, die Berechnung von Pivot-Tabellen-Aktualisierungsfunktionen, kann IronXLauf die integrierten Formeln von Excel zurückgreifen, um Ihre Antworten zu erhalten. Im Allgemeinen ist dies der vorherigen Antwort vorzuziehen - Ihr Datensatz wird auf viel modernere und elegantere Weise gehandhabt, mit Code, den eine Person leicht verstehen kann. Einfach einzurichten, ohne die Notwendigkeit, den Support zu kontaktieren oder ein Handbuch zu lesen.

// Load the workbook
WorkBook workbook = WorkBook.Load(inputPath);
// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet";
// Convert worksheet to DataTable
DataTable dataTable = dataSheet.ToDataTable(true);
// Create new summary worksheet
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");
// Get unique product-region combinations
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region);
// Add header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";
// Populate rows with formulas
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;
    // Adjust column references if your Sales column is C (not D)
    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}\")";
    rowIndex++;
}
// Optional: add total row
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";
// Save output file
workbook.SaveAs(outputPath);  //filename

// Load the workbook
WorkBook workbook = WorkBook.Load(inputPath);
// Rename the first worksheet so formulas reference correctly
WorkSheet dataSheet = workbook.WorkSheets[0];
dataSheet.Name = "DataSheet";
// Convert worksheet to DataTable
DataTable dataTable = dataSheet.ToDataTable(true);
// Create new summary worksheet
WorkSheet summarySheet = workbook.CreateWorkSheet("DynamicSummary");
// Get unique product-region combinations
var uniqueCombos = dataTable.AsEnumerable()
    .Select(row => new {
        Product = row["Product"].ToString(),
        Region = row["Region"].ToString()
    })
    .Distinct()
    .OrderBy(x => x.Product)
    .ThenBy(x => x.Region);
// Add header row
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Region";
summarySheet["C1"].Value = "Total Sales";
summarySheet["D1"].Value = "Count";
// Populate rows with formulas
int rowIndex = 2;
foreach (var combo in uniqueCombos)
{
    summarySheet[$"A{rowIndex}"].Value = combo.Product;
    summarySheet[$"B{rowIndex}"].Value = combo.Region;
    // Adjust column references if your Sales column is C (not D)
    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}\")";
    rowIndex++;
}
// Optional: add total row
summarySheet[$"A{rowIndex}"].Value = "Total";
summarySheet[$"C{rowIndex}"].Formula = $"=SUM(C2:C{rowIndex - 1})";
summarySheet[$"D{rowIndex}"].Formula = $"=SUM(D2:D{rowIndex - 1})";
// Save output file
workbook.SaveAs(outputPath);  //filename

Diese Formeln halten Live-Verbindungen zu Quelldaten aufrecht und aktualisieren sich automatisch, wenn sich das Datenblatt ändert - ähnlich wie das Verhalten bei der Aktualisierung von Pivot-Tabellen, jedoch ohne Interop-Abhängigkeiten.

Wenn wir diesen Code auf die Beispiel-Excel-Datei (XLS / XLSX) aus dem vorherigen Beispiel anwenden, erhalten wir diese Ausgabe von Feldern auf die Seite:

! So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs IronXL: Bild 2 - Hinweis: Die Ausgabe dynamischer Zusammenfassungen in C# scheint im Kontext des Standorts zu erfolgen.

Vergleich von C# Interop vs. IronXLfür Pivot-Tabellen

| Aspekt| C# Interop | IronXL| | ---| ---| ---| | Büro erforderlich | Ja – vollständige Installation | Nein – eigenständige Bibliothek | | Plattform-Unterstützung| Nur für Windows| Windows, Linux, macOS, Docker| | Speicherverwaltung| Manuelle COM-Bereinigung erforderlich | Automatische .NET-Speicherbereinigung | | Bereitstellung| Komplex – Bürolizenzierung | Einfach – Einzelne DLL | | Leistung| Langsamer Excel-Prozessstart | Schnell – Berechnungen im Arbeitsspeicher | | Cloud-kompatibel | Nein – Azure-Beschränkungen | Ja – Azure Functions-Unterstützung | | Native Pivot-Tabellen | Ja | Nein – Aggregationsalternativen | | Entwicklungsgeschwindigkeit | Langsam - COM-Komplexität | Schnelle, intuitive API |

Welchen Ansatz sollten Sie wählen?

Wählen Sie C# Interop, wenn:

• Native Excel-Pivot-Tabellenobjekte unbedingt erforderlich sind
• Ausschließlich auf Windows gearbeitet wird, mit Office auf jedem Zielcomputer installiert
• Nur auf Desktop-Systemen bereitgestellt wird, die Sie verwalten
• Bereits vorhandener Legacy-Code von Interop abhängt
• Verwendung der Legacy .NET Framework-Version

Wählen Sie IronXL, wenn:

• Bereitstellung auf Servern oder Cloud-Umgebungen und -Diensten (Azure, AWS ...)
• Erstellung plattformübergreifender Anwendungen
• Bessere Leistung und Zuverlässigkeit erforderlich sind
• Vermeidung von Office-Lizenzierungskosten
• Einfacheren, wartbaren Code benötigen
• Unterstützung für Mac, iOS, Android und/oder Linux-Systeme
• Arbeiten in modernem .NET Framework Core und .NET 5,6,7,8,9,10
• Sie vollen Zugriff auf Ihre Entwicklungs-Konsole/IDE haben möchten, um die Einstellungen für jedes Feld in der Pivot-Tabelle programmgesteuert aus Ihren Datenbereichen zu konfigurieren.

Abschluss

Während C# Excel Interop native Pivot-Tabellen entwickeln kann, machen seine Bereitstellungsbeschränkungen und Komplexität es zunehmend unpraktisch für moderne Anwendungen. IronXL bietet leistungsstarke Alternativen durch Datenaggregation und Formelsummen, die von Office-Abhängigkeiten befreit und dennoch analytische Fähigkeiten beibehalten. Bitte stimmen Sie ab, kommentieren oder abonnieren Sie, wenn dies hilfreich war.

Für Entwickler, die nach einer alternativen Option zur Entwicklung von Pivot-Tabellen ohne Interop suchen, bietet IronXLeinen überlegenen Weg, der COM-Komplikationen vermeidet, auf allen Plattformen funktioniert und die Bereitstellung vereinfacht. Der Kompromiss, keine nativen Pivot-Objekte zu haben, wird durch größere Flexibilität, bessere Leistung und die Eliminierung von Office-Lizenzierungsanforderungen ausgeglichen.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten

Bereit, Ihre Excel-Automatisierung zu modernisieren und Ihren eigenen Pivot-Tabellencode in modernem C# zu erstellen?

IronXL kann in Ihren C#-Anwendungen innerhalb von Sekunden über den NuGet Package Manager implementiert werden. Testen Sie die kostenlose Testversion oder erwerben Sie eine IronXL-Lizenz , um Interop-Abhängigkeiten in Ihren Produktionsanwendungen zu eliminieren.