Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronXL
  2. IronXL Blog
  3. IronXL verwenden
  4. Erstellen Sie ein Excel-Pivot in C#
IRONXL VERWENDEN

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

Jordi Bardia
Jordi Bardia
Aktualisiert:

Das Erstellen von Excel-Pivot-Tabellen in C# funktioniert entweder mit Office Interop (was die Installation von Microsoft Office erfordert) oder mit modernen Bibliotheken wie IronXL, die unabhängig funktionieren. IronXL bietet dabei eine überlegene Flexibilität bei der Bereitstellung und plattformübergreifende Unterstützung für DevOps Umgebungen.

Die programmatische Erstellung von Pivot-Tabellen erfordert entweder C# Interop mit seinen Office-Abhängigkeiten oder moderne Bibliotheken wie IronXL , die unabhängig funktionieren. Dieses Tutorial demonstriert beide Ansätze und verdeutlicht, warum Entwickler zunehmend IronXL gegenüber traditionellen Interop-Methoden bevorzugen, insbesondere beim Bereitstellung in Docker-Containern oder Cloud-Umgebungen wie Azure und AWS .

In diesem Artikel lernen wir, wie man Pivot-Tabellen und -Gruppen mit automatischer Analyse und Fehlerbehandlung bearbeitet, erstellt, entwirft und berechnet – und das alles bei gleichzeitiger Beibehaltung der DevOps -Ingenieuren geforderten Bereitstellungseinfachheit.

Was ist eine Excel-Pivot-Tabelle?

Eine Pivot-Tabelle ist eines der leistungsstärksten Werkzeuge von Excel. Es ist eine einfache Möglichkeit, große Datensätze zusammenzufassen, was es für die Datenanalyse in .NET-Anwendungen unentbehrlich macht. Pivot-Tabellen ermöglichen es Ihnen, numerische Daten einfach darzustellen, zu verstehen und zu analysieren. Sie sind nicht nur in Excel, sondern auch in anderen Programmen wie Google Sheets, Apple Numbers und CSV-Exporten verfügbar. Sie bieten eine Lösung zur Übersicht über Daten – sie fungieren als Datenkonsole, die es den Nutzern ermöglicht, ihre Informationen auf sinnvolle Weise zu betrachten.

Bei containerisierten Anwendungen entfällt durch die programmatische Erstellung von Pivot-Tabellen die Notwendigkeit von Excel-Installationen in Ihren Docker-Images, wodurch die Containergröße und die Komplexität der Bereitstellung erheblich reduziert werden. Dieser Ansatz passt perfekt zu modernen CI/CD-Pipelines und Container-Bereitstellungsstrategien .

Lasst uns den falschen Weg zur Erstellung einer Pivot-Tabelle untersuchen und anschließend den richtigen Weg in C# lernen:

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 bei der Suche nach Tools zum Generieren von Pivot-Tabellen in C# finden:

Warum gilt dieser Ansatz in .NET als 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);
$vbLabelText   $csharpLabel

Dieses Interop-Beispiel erstellt eine native Excel-Pivot-Tabelle mit Produkt als Zeilen, Region als Spalten und Umsatz als Summe im Datenbereich. Auch wenn es funktioniert, erfordert dieser Ansatz die Installation von Microsoft Office und eine sorgfältige Verwaltung von COM-Objekten. In der Microsoft-Dokumentation wird erläutert, warum dieser Ansatz nicht mehr zeitgemäß ist. Aus DevOps Sicht ist dieser Ansatz besonders problematisch, da er nicht effektiv containerisiert werden kann – man kann Microsoft Office nicht in einem Linux-Docker-Container installieren oder in serverlosen Umgebungen bereitstellen.

Welche Probleme entstehen durch C# Interop?

Der Interop-Ansatz birgt einige bedeutende Herausforderungen, die ihn für moderne DevOps Praktiken und Cloud-native Bereitstellungen ungeeignet machen.

Leider empfehlen Stack Overflow und andere Programmier-Websites diese Methode weiterhin, weil sie in der Zeit mit Threads aus den frühen 2000er Jahren feststecken.

Bereitstellungsabhängigkeiten: Erfordert die Installation von Microsoft Office auf jedem Rechner, auf dem der Quellcode ausgeführt wird, 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.

Plattformbeschränkungen : Diese Lösung funktioniert nur unter Windows mit installiertem Office. Es kann unglaublich langsam sein und zu Speicherlecks führen. Keine Unterstützung für Linux , macOS , Docker-Container oder Cloud-Plattformen wie Azure Functions . Dies schränkt die Einsatzmöglichkeiten erheblich ein und verhindert die Nutzung moderner Container-Orchestrierungsplattformen.

Leistungsprobleme: Das Starten von Excel-Anwendungsinstanzen ist langsam und ressourcenintensiv, insbesondere bei serverseitiger Verarbeitung.

Versionskompatibilität: Unterschiedliche Office-Versionen können unterschiedliche COM-Schnittstellen aufweisen, was zu Kompatibilitätsproblemen in verschiedenen 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. Es erstellt zwar keine nativen Excel-Pivot-Tabellen, bietet aber leistungsstarke Aggregationsfunktionen, die sich perfekt für containerisierte Bereitstellungen und Cloud-native Architekturen eignen. Zu den Leistungsoptimierungen der Bibliothek gehören eine 40-fache Geschwindigkeitssteigerung und eine Reduzierung des Speicherverbrauchs von 19,5 GB auf unter 1 GB, wodurch sie sich ideal für ressourcenbeschränkte Containerumgebungen eignet.

Was macht diesen Ansatz für XLSX- oder XLS-Dateien modern?

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

So erstellen Sie Pivot-Tabellen auf containerfreundliche Weise. Dieser Ansatz funktioniert nahtlos in Docker-Containern, Kubernetes-Pods und serverlosen Funktionen ohne jegliche externe Abhängigkeiten. Die gesamte Anwendung kann in ein leichtgewichtiges Container-Image verpackt werden, das überall dort ausgeführt werden kann, wo .NET unterstützt wird.

Wie sieht die Ausgabe der Pivot-Tabelle aus?

Vergleich der ursprünglichen Excel-Verkaufsdaten mit der generierten Pivot-Tabelle, die die nach Regionen aggregierten Produktverkäufe mit Gesamtsummen anzeigt

Das Ergebnis zeigt, wie IronXL Rohdaten aus dem Verkauf in einen strukturierten Pivot-Bericht umwandelt, ohne dass eine Excel-Installation erforderlich ist. Dadurch eignet es sich perfekt für die automatisierte Berichterstellung in CI/CD-Pipelines.

Wie erstellt man dynamische Zusammenfassungen mit IronXL-Formeln?

Für Szenarien, die dynamische Aktualisierungen ähnlich der Pivot-Tabellen-Aktualisierungsfunktion erfordern, kann IronXL die in Excel integrierten Formeln nutzen. Diese Vorgehensweise ist vorzuziehen – Ihre Daten werden auf eine wesentlich modernere und elegantere Weise verarbeitet. Der Code ist leicht verständlich und einfach einzurichten, ohne dass man den Support kontaktieren oder Handbücher lesen muss. Dieser Ansatz ist besonders wertvoll in containerisierten Umgebungen, in denen formelbasierte Berechnungen benötigt werden, die sich automatisch aktualisieren.

Wie werden formelbasierte Zusammenfassungen automatisch aktualisiert?

// 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
$vbLabelText   $csharpLabel

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. Dieser Ansatz eignet sich ideal für containerisierte Microservices, die dynamische Berichte ohne externe Abhängigkeiten generieren müssen.

Welche Ergebnisse können Sie von dynamischen Zusammenfassungen erwarten?

Wenn wir diesen Code auf die Beispiel-Excel-Datei aus dem vorherigen Beispiel anwenden, erhalten wir folgende Ausgabe:

! Excel-Tabelle mit Produktverkaufsdaten und dynamischen Zusammenfassungsformeln, die Produkte (Laptop, Telefon, Tablet) nach Regionen mit berechneten Summen und Stückzahlen aufzeigt

Der Ansatz der dynamischen Zusammenfassung ermöglicht Echtzeitberechnungen, die sich bei Änderungen der Quelldaten automatisch aktualisieren. Dadurch eignet er sich perfekt für automatisierte Berichtspipelines in containerisierten Umgebungen. Dadurch entfällt die Notwendigkeit zeitgesteuerter Aktualisierungen von Pivot-Tabellen und es funktioniert nahtlos in .NET MAUI- und Blazor- Anwendungen.

Wie vergleicht man C# Interop mit IronXL für Pivot-Tabellen?

Aspekt

C# Interop

IronXL

Büro erforderlich

Ja - Vollständige Installation

Nein - Eigenständige Bibliothek

Plattformunterstützung

Nur für Windows

Windows, Linux, macOS, Docker

Speicherverwaltung

Manuelle COM-Bereinigung erforderlich

Automatische .NET-Garbage-Collection

Bereitstellung

Komplex - Office-Lizenzierung

Einfach - Einzelne DLL

Leistung

Langsam - Excel-Prozess-Start

Schnell - In-Memory-Berechnungen

Cloud-kompatibel

Nein - Azure-Einschränkungen

Ja - Unterstützung von Azure Functions

Native Pivot-Tabellen

Ja

Nein - Alternativen zur Aggregation

Entwicklungsgeschwindigkeit

Langsam - COM-Komplexität

Schnell - Intuitive API

Container-Unterstützung

Nein – Office kann nicht in einem Container untergebracht werden.

Ja – Docker-fähig

Gesundheitschecks

Schwierig – Überwachung des COM-Prozesses

Einfaches – Standardmäßiges .NET-Monitoring

Aus DevOps Sicht bietet die Architektur von IronXL erhebliche Vorteile für moderne Bereitstellungsszenarien. Die Fähigkeit der Bibliothek, in Containern ohne externe Abhängigkeiten zu laufen, bedeutet, dass Sie schlanke Docker-Images erstellen können, die schnell bereitgestellt werden und effizient skalieren. Die Gesundheitsprüfungen können mithilfe von Standard-.NET-Mustern implementiert werden, und zu den Sicherheitsfunktionen der Bibliothek gehören DigiCert Zertifizierung und der Verzicht auf COM-Schnittstellen, wodurch die Angriffsvektoren reduziert werden.

Welchen Ansatz sollten Sie wählen?

Wann sollte man C# Interop verwenden?

Wählen Sie C# Interop, wenn:

  • Native Excel-Pivot-Tabellenobjekte unbedingt erforderlich sind
  • Funktioniert ausschließlich unter Windows, wobei Office überall installiert ist.
  • Bereitstellung nur auf Desktop-Systemen, die Sie verwalten
  • Bereits vorhandener Legacy-Code von Interop abhängt
  • Verwendung älterer .NET Framework-Versionen
  • Sie haben keine Pläne, Containerisierung durchzuführen oder in die Cloud zu migrieren.

Wann liefert IronXL bessere Ergebnisse?

Wählen Sie IronXL, wenn:

  • Bereitstellung auf Servern oder in Cloud-Umgebungen (Azure, AWS)
  • Entwicklung plattformübergreifender Anwendungen, die in Containern laufen
  • Erfordert eine deutlich höhere Leistung mit 40-facher Geschwindigkeitssteigerung
  • Vermeidung von Office-Lizenzkosten und Bereitstellungskomplexität
  • Bedarf an einfacherem Code mit automatischer Lizenzschlüsselverwaltung
  • Unterstützt Mac-, iOS-, Android- und Linux-Systeme
  • Arbeiten mit modernen .NET Core- und .NET 5-10-Versionen
  • Pivot-Tabellenfelder programmgesteuert konfigurieren
  • Entwicklung von Microservices, die in verschiedene Formate exportieren
  • Implementierung automatisierter Berichtsfunktionen in CI/CD-Pipelines
  • Erstellung von Health-Check-Endpunkten für die Container-Orchestrierung
  • Konvertierung zwischen verschiedenen Tabellenformaten

Was haben wir über die Erstellung von Pivot-Tabellen in C# gelernt?

Während C# Excel Interop native Pivot-Tabellen erstellen kann, machen seine Bereitstellungseinschränkungen und seine Komplexität es für moderne Anwendungen, insbesondere in containerisierten Umgebungen, zunehmend unpraktisch. IronXL bietet leistungsstarke Alternativen durch Datenaggregation und formelbasierte Zusammenfassungen, wodurch Office-Abhängigkeiten beseitigt und gleichzeitig die analytischen Fähigkeiten erhalten bleiben.

Für Entwickler und DevOps -Ingenieure, die nach Alternativen zur Entwicklung von Pivot-Tabellen ohne Interop suchen, bietet IronXL einen ü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. Für DevOps Teams ist vor allem wichtig, dass IronXL echte Infrastruktur als Code mit containerisierten Bereitstellungen, automatisierter Skalierung und nahtloser Integration in moderne CI/CD-Pipelines ermöglicht.

Der umfassende Funktionsumfang der Bibliothek beinhaltet bedingte Formatierung , Zellstile , Formelunterstützung und Datenvalidierung und macht sie damit zu einer Komplettlösung für die Excel-Automatisierung in modernen .NET-Anwendungen. Egal ob Sie mit CSV-Dateien arbeiten , Tabellen verwalten oder komplexe Datentransformationen implementieren , IronXL bietet eine konsistente, einsatzfreundliche API.

Starten Sie jetzt mit IronXL.
green arrow pointer

Sind Sie bereit, Ihre Excel-Automatisierung zu modernisieren und Pivot-Tabellen-Code 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 , um Interop-Abhängigkeiten in Ihren Produktionsanwendungen zu beseitigen und Ihre Container-Bereitstellungen zu vereinfachen.

Häufig gestellte Fragen

Was ist eine Pivot-Tabelle in Excel?

Eine Pivot-Tabelle in Excel ist ein leistungsstarkes Werkzeug zur Zusammenfassung, Analyse, Erforschung und Präsentation von Daten. Sie ermöglicht es Benutzern, Spalten in Zeilen umzuwandeln und umgekehrt, was eine dynamische Datenanalyse ermöglicht.

Warum IronXL für die Erstellung von Excel-Pivot-Tabellen in C# verwenden?

IronXL ermöglicht es Entwicklern, Excel-Pivot-Tabellen in C# zu erstellen, ohne auf Office Interop angewiesen zu sein, was die Notwendigkeit von Excel-Installationen eliminiert und Abhängigkeiten reduziert, wodurch es eine moderne und effiziente Wahl ist.

Wie vergleicht sich IronXL mit C# Interop für Excel-Operationen?

IronXL bietet einen schlankeren und unabhängigen Ansatz im Vergleich zu C# Interop, das Office-Installationen erfordert. IronXL vereinfacht die Erstellung von Pivot-Tabellen und anderen Excel-Operationen ohne die Komplikationen von Interop.

Kann ich Pivot-Tabellen ohne installiertes Excel generieren?

Ja, mit IronXL können Sie Pivot-Tabellen in Ihren C#-Anwendungen generieren, ohne dass Excel installiert ist, da es unabhängig von Microsoft Office arbeitet.

Ist IronXL für große Datensätze geeignet?

IronXL ist dafür ausgelegt, große Datensätze effizient zu handhaben, was es geeignet für Anwendungen macht, die eine robuste Datenmanipulation und Pivot-Tabellenerstellung erfordern.

Was sind die Vorteile der Verwendung von IronXL gegenüber traditionellen Methoden?

IronXL bietet eine moderne, unabhängige Alternative zu traditionellen Methoden wie C# Interop und bietet Benutzerfreundlichkeit, Flexibilität und Unterstützung für komplexe Datenoperationen ohne die Notwendigkeit von Excel-Installationen.

Muss ich VBA lernen, um IronXL für Pivot-Tabellen zu verwenden?

Nein, IronXL ermöglicht es Entwicklern, direkt innerhalb von C# zu arbeiten, um Pivot-Tabellen zu erstellen und zu verwalten, wodurch die Notwendigkeit entfällt, VBA oder andere Excel-spezifische Programmiersprachen zu lernen.

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