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

Was ist eine Excel-Pivot-Tabelle?

Eine Pivot-Tabelle ist eines der leistungsfähigsten Tools, die Sie in Excel hinzufügen können. 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, sondern auch in anderen Programmen wie Google Sheets, Apple Numbers und CSV-Exporten verfügbar. Sie bietet eine Lösung, um die Daten im Überblick zu sehen - sie fungiert als Datenkonsole, die es den Menschen ermöglicht, ihre Informationen auf sinnvolle Art und Weise zu sehen - mit einem Bezug zur Realität.

Lassen Sie uns eine Pivot-Tabelle auf die falsche Art und Weise erstellen und dann lernen, wie man sie auf die richtige Art in C# erstellt:

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

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;

// 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);

IRON VB CONVERTER ERROR developers@ironsoftware.com

Welche Probleme entstehen durch C# Interop?

Der Interop-Ansatz stellt mehrere erhebliche Herausforderungen dar:

Leider empfehlen Stack Overflow und andere Programmier-Websites es weiterhin, weil sie in der Zeit verhaftet sind, mit Threads, die für Ideen aus den frühen 2000er Jahren gesperrt sind.

Abhängigkeiten bei der Bereitstellung: Erfordert die Installation von Microsoft Office auf jedem Rechner, auf dem der Quellcode ausgeführt wird, einschließlich Produktionsservern. Dies fügt Lizenzkosten und Bereitstellungskomplexität hinzu.

Speichermanagement: 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.

Details zur Plattformbeschränkung: Diese altmodische Lösung funktioniert nur unter Windows mit installiertem Office und kann unglaublich langsam und verwirrend für den Benutzer sein und 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 IronXL eine Pivot-Tabelle programmatisch ohne Interop?

IronXL geht bei der Erstellung von Pivot-Tabellen anders vor und verwendet verwalteten Code ohne COM-Abhängigkeiten. Obwohl es keine nativen Excel-Pivot-Tabellen erstellt, bietet es leistungsstarke Aggregationsfunktionen.

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");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Wie erstellt man dynamische Zusammenfassungen mit IronXL-Formeln?

Für Szenarien, die dynamische Aktualisierungen wie die Erstellung einer Pivot-Tabelle erfordern, kann IronXL die in Excel integrierten Formeln nutzen, um Ihre Antworten zu erhalten. Im Allgemeinen ist dies der vorangegangenen Antwort vorzuziehen - Ihr Datensatz wird auf eine viel modernere und elegantere Weise behandelt, mit Code, den eine Person leicht verstehen kann. Einfach einzurichten, ohne dass der Support kontaktiert oder ein Handbuch gelesen werden muss.

// 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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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 Excel-Beispieldatei (XLS / XLSX) aus dem vorherigen Beispiel anwenden, erhalten wir diese Ausgabe von Feldern auf der Seite:

Vergleich C# Interop vs IronXL für Pivot-Tabellen

Welchen Ansatz sollten Sie wählen?

Wählen Sie C# Interop, wenn:

• Native Excel-Pivot-Table-Objekte sind unbedingt erforderlich
• Arbeitet ausschließlich unter Windows und hat Office auf jedem Zielrechner installiert
• Einsatz nur auf von Ihnen verwalteten Desktop-Systemen
• Bestehender Legacy-Code hängt von Interop ab
• Verwendung einer älteren .NET Framework-Version

Wählen Sie IronXL, wenn:

• Bereitstellung auf Servern oder in Cloud-Umgebungen und -Diensten (Azure, AWS ...)
• Erstellung plattformübergreifender Anwendungen
• Bessere Leistung und Zuverlässigkeit erforderlich
• Vermeiden von Office-Lizenzierungskosten
• Einfacherer, wartbarer Code wird benötigt
• Unterstützung von Mac-, iOS-, Android- und/oder Linux-Systemen
• Arbeiten im modernen .NET Framework Core und .NET 5,6,7,8,9,10
• Sie wollen vollen Zugriff auf Ihre Entwicklungskonsole/IDE, um die Einstellungen für jedes Feld in der Pivot-Tabelle programmatisch 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 formelbasierte Zusammenfassungen, die Office-Abhängigkeiten beseitigen und gleichzeitig analytische Fähigkeiten beibehalten. Bitte stimmen Sie ab, kommentieren Sie oder abonnieren Sie, wenn dies hilfreich war.

Für Entwickler, die nach einer alternativen Option für die Entwicklung von Pivot-Tabellen ohne Interop suchen, bietet IronXL einen überlegenen Weg, der COM-Komplikationen vermeidet, plattformübergreifend 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 über den NuGet Package Manager in Sekundenschnelle in Ihre C#-Anwendungen implementiert werden. Testen Sie die kostenlose Testversion oder Erwerben Sie eine IronXL-Lizenz, um Interop-Abhängigkeiten in Ihren Produktionsanwendungen zu beseitigen.