Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronXL
  2. IronXL Blog
  3. IronXL verwenden
  4. Pivot-Tabelle in Excel mit C# Interop erstellen
IRONXL VERWENDEN

Wie man Pivot-Tabellen in Excel mit C# ohne Interop erstellt

Jordi Bardia
Jordi Bardia
Aktualisiert:

Das Erstellen von Pivot-Tabellen in Excel mit C# ist unkompliziert, wenn Sie die richtige Bibliothek wählen: Excel-Interop benötigt Office auf jedem Rechner, während IronXL überall dort funktioniert, wo .NET ausgeführt wird. Dieser Leitfaden erläutert beide Ansätze anhand vollständiger Codebeispiele und behandelt Einrichtung, Datenaggregation, Feldkonfiguration und Bereitstellungsaspekte, damit Sie die optimale Lösung für Ihr Projekt finden.

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 1 - IronXL

Worin besteht der Unterschied zwischen Excel-Interop und IronXL?

Bevor man auch nur eine Zeile Code schreibt, ist es hilfreich zu verstehen, was die einzelnen Ansätze im Detail bewirken. Excel-Interop verwendet COM (Component Object Model), um Microsoft Excel direkt von C# aus zu steuern. Der .NET Prozess kommuniziert mit einer laufenden Excel-Instanz, weshalb Excel selbst auf dem Rechner installiert sein muss. Jedes Objekt, das Sie bearbeiten – Arbeitsmappen, Tabellenblätter, Bereiche, Pivot-Tabellen – ist ein COM-Wrapper und muss explizit freigegeben werden, um Speicherlecks zu vermeiden.

IronXL verfolgt einen grundlegend anderen Ansatz. Es liest und schreibt das Open XML-Dateiformat direkt, ohne Excel überhaupt zu starten. Das Ergebnis ist eine standardmäßige .NET Bibliothek mit vertrauten Objektmustern, automatischer Speicherbereinigung und ohne Abhängigkeit von der Office-Installation oder -Lizenzierung. Dank dieser Architektur eignet sich IronXL für serverseitige Workloads , Docker-Container, Linux-Hosts und jede .NET 6-, .NET 8- oder .NET 10-Umgebung.

Excel-Interop vs. IronXL – auf einen Blick
Kriterien Excel-Interop IronXL
Büro erforderlich Ja Nein
Nur für Windows Ja Nein – plattformübergreifend
Speicherverwaltung Manuelle COM-Freigabe Automatische (.NET GC)
Serverbereitstellung Schwierig Einfach
Native Pivot-Tabelle Vollständige Excel-Pivot-API Datenaggregation über LINQ
Lizenz erforderlich Bürolizenz IronXL Lizenz

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 2 - Plattformübergreifend

Wie installiert man die einzelnen Bibliotheken?

Excel-Interop einrichten

Excel-Interop wird als NuGet Paket ausgeliefert. Führen Sie eine der folgenden Optionen in Ihrem Projekt aus:

Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.Excel
Install-Package Microsoft.Office.Interop.Excel
dotnet add package Microsoft.Office.Interop.Excel
SHELL

Beachten Sie, dass das Paket allein nicht ausreicht – auf dem Zielrechner muss eine passende Version von Microsoft Excel installiert und ordnungsgemäß lizenziert sein. Diese Abhängigkeit schließt die meisten Server-, Container- und Cloud-Szenarien aus.

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 3 – Excel-Interop-Installation

IronXL einrichten

Installieren Sie IronXL über NuGet ohne zusätzliche Systemvoraussetzungen:

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 sofort auf jeder Plattform, die .NET unterstützt, mit dem Lesen und Schreiben von Excel-Dateien beginnen. Keine Office-Lizenz, keine COM-Registrierung, keine Serverkonfiguration. Weitere Optionen, einschließlich Offline-Installation und Einrichtung von Projektreferenzen, finden Sie im IronXL Installationshandbuch .

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 4 – Installation

Starten Sie jetzt mit IronXL.
green arrow pointer

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

Der Interop-Pivot-Tabellen-Workflow folgt einer strikten Abfolge: Zuerst wird ein Pivot-Cache aus einem Quellbereich erstellt, dann wird ein PivotTable-Objekt auf einem separaten Arbeitsblatt erstellt und anschließend die Feldausrichtung konfiguriert. Das folgende Beispiel verwendet C#-Anweisungen auf oberster Ebene, die mit .NET 10 kompatibel sind:

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

// Launch Excel and set up workbooks
var excelApp = new Excel.Application();
excelApp.Visible = false;
var workbook = excelApp.Workbooks.Add();
var dataSheet = (Excel.Worksheet)workbook.Worksheets[1];
dataSheet.Name = "SalesData";
var pivotSheet = (Excel.Worksheet)workbook.Worksheets.Add();
pivotSheet.Name = "Pivot";

// Populate header row
dataSheet.Cells[1, 1] = "Product";
dataSheet.Cells[1, 2] = "Region";
dataSheet.Cells[1, 3] = "Sales";

// Add sample data rows
object[,] rows = {
    { "Laptop",   "Neinrth", 1200 },
    { "Laptop",   "South", 1500 },
    { "Phone",    "Neinrth",  800 },
    { "Phone",    "South",  950 },
    { "Tablet",   "East",   600 },
    { "Tablet",   "West",   750 },
    { "Monitor",  "Neinrth",  400 },
    { "Monitor",  "South",  500 },
    { "Keyboard", "East",   300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
    dataSheet.Cells[i + 2, 1] = rows[i, 0];
    dataSheet.Cells[i + 2, 2] = rows[i, 1];
    dataSheet.Cells[i + 2, 3] = rows[i, 2];
}

// Build pivot cache from source range
Excel.Range dataRange = dataSheet.Range["A1:C10"];
Excel.PivotCache pivotCache = workbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase, dataRange);

// Create the PivotTable on the pivot sheet
Excel.PivotTables pivotTables = (Excel.PivotTables)pivotSheet.PivotTables();
Excel.PivotTable pivotTable = pivotTables.Add(
    pivotCache, pivotSheet.Range["A3"], "SalesPivot");

// Assign field orientations
((Excel.PivotField)pivotTable.PivotFields("Product")).Orientation =
    Excel.XlPivotFieldOrientation.xlRowField;
((Excel.PivotField)pivotTable.PivotFields("Region")).Orientation =
    Excel.XlPivotFieldOrientation.xlColumnField;
((Excel.PivotField)pivotTable.PivotFields("Sales")).Orientation =
    Excel.XlPivotFieldOrientation.xlDataField;

// Enable grand totals
pivotTable.RowGrand = true;
pivotTable.ColumnGrand = true;

// Save and close
workbook.SaveAs(@"C:\output\pivot_interop.xlsx");
workbook.Close(false);
excelApp.Quit();

// Release every COM object -- skipping any of these causes Excel to stay in memory
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotTables);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(dataRange);
Marshal.ReleaseComObject(pivotSheet);
Marshal.ReleaseComObject(dataSheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);
using Excel = Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;

// Launch Excel and set up workbooks
var excelApp = new Excel.Application();
excelApp.Visible = false;
var workbook = excelApp.Workbooks.Add();
var dataSheet = (Excel.Worksheet)workbook.Worksheets[1];
dataSheet.Name = "SalesData";
var pivotSheet = (Excel.Worksheet)workbook.Worksheets.Add();
pivotSheet.Name = "Pivot";

// Populate header row
dataSheet.Cells[1, 1] = "Product";
dataSheet.Cells[1, 2] = "Region";
dataSheet.Cells[1, 3] = "Sales";

// Add sample data rows
object[,] rows = {
    { "Laptop",   "Neinrth", 1200 },
    { "Laptop",   "South", 1500 },
    { "Phone",    "Neinrth",  800 },
    { "Phone",    "South",  950 },
    { "Tablet",   "East",   600 },
    { "Tablet",   "West",   750 },
    { "Monitor",  "Neinrth",  400 },
    { "Monitor",  "South",  500 },
    { "Keyboard", "East",   300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
    dataSheet.Cells[i + 2, 1] = rows[i, 0];
    dataSheet.Cells[i + 2, 2] = rows[i, 1];
    dataSheet.Cells[i + 2, 3] = rows[i, 2];
}

// Build pivot cache from source range
Excel.Range dataRange = dataSheet.Range["A1:C10"];
Excel.PivotCache pivotCache = workbook.PivotCaches().Create(
    Excel.XlPivotTableSourceType.xlDatabase, dataRange);

// Create the PivotTable on the pivot sheet
Excel.PivotTables pivotTables = (Excel.PivotTables)pivotSheet.PivotTables();
Excel.PivotTable pivotTable = pivotTables.Add(
    pivotCache, pivotSheet.Range["A3"], "SalesPivot");

// Assign field orientations
((Excel.PivotField)pivotTable.PivotFields("Product")).Orientation =
    Excel.XlPivotFieldOrientation.xlRowField;
((Excel.PivotField)pivotTable.PivotFields("Region")).Orientation =
    Excel.XlPivotFieldOrientation.xlColumnField;
((Excel.PivotField)pivotTable.PivotFields("Sales")).Orientation =
    Excel.XlPivotFieldOrientation.xlDataField;

// Enable grand totals
pivotTable.RowGrand = true;
pivotTable.ColumnGrand = true;

// Save and close
workbook.SaveAs(@"C:\output\pivot_interop.xlsx");
workbook.Close(false);
excelApp.Quit();

// Release every COM object -- skipping any of these causes Excel to stay in memory
Marshal.ReleaseComObject(pivotTable);
Marshal.ReleaseComObject(pivotTables);
Marshal.ReleaseComObject(pivotCache);
Marshal.ReleaseComObject(dataRange);
Marshal.ReleaseComObject(pivotSheet);
Marshal.ReleaseComObject(dataSheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);
$vbLabelText   $csharpLabel

Jeder COM-Wrapper erfordert einen passenden Marshal.ReleaseComObject-Aufruf. Fehlt auch nur eine einzige Referenz, bleibt der Excel-Prozess im Hintergrund aktiv und verbraucht Speicher und Dateihandles, bis der Hostprozess beendet wird. Dieser Aufräumaufwand skaliert mit der Komplexität Ihrer Tabellenkalkulationsvorgänge.

Wie erzielt man mit IronXL das gleiche Ergebnis?

IronXL stellt keine native Pivot-Tabellen-API wie Interop bereit – das Open XML Pivot-Format verfügt über Hunderte von XML-Attributen, und die meisten Geschäftsanforderungen werden zuverlässiger mit expliziter LINQ-Aggregation in reinem C# erfüllt. Das Ergebnis ist ein übersichtliches Übersichtsblatt, das beim Öffnen der Datei korrekt neu berechnet wird, ohne dass Excel einen Pivot-Cache aktualisieren muss.

using IronXL;
using System.Data;

// Create workbook and populate source data
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet dataSheet = workbook.CreateWorkSheet("SalesData");

dataSheet["A1"].Value = "Product";
dataSheet["B1"].Value = "Region";
dataSheet["C1"].Value = "Sales";

object[,] rows = {
    { "Laptop",   "Neinrth", 1200 },
    { "Laptop",   "South", 1500 },
    { "Phone",    "Neinrth",  800 },
    { "Phone",    "South",  950 },
    { "Tablet",   "East",   600 },
    { "Tablet",   "West",   750 },
    { "Monitor",  "Neinrth",  400 },
    { "Monitor",  "South",  500 },
    { "Keyboard", "East",   300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
    dataSheet[$"A{i + 2}"].Value = rows[i, 0];
    dataSheet[$"B{i + 2}"].Value = rows[i, 1];
    dataSheet[$"C{i + 2}"].Value = rows[i, 2];
}

// Aggregate data with LINQ -- equivalent to a pivot table row/column/value layout
DataTable table = dataSheet["A1:C10"].ToDataTable(true);
var summary = table.AsEnumerable()
    .GroupBy(row => row.Field<string>("Product"))
    .Select((group, idx) => new
    {
        Product    = group.Key,
        TotalSales = group.Sum(r => Convert.ToDecimal(r["Sales"])),
        RegionCount = group.Select(r => r.Field<string>("Region")).Distinct().Count(),
        RowIndex   = idx + 2
    })
    .OrderByDescending(x => x.TotalSales);

// Write the summary sheet
WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Total Sales";
summarySheet["C1"].Value = "Regions";

foreach (var item in summary)
{
    summarySheet[$"A{item.RowIndex}"].Value = item.Product;
    summarySheet[$"B{item.RowIndex}"].Value = (double)item.TotalSales;
    summarySheet[$"C{item.RowIndex}"].Value = item.RegionCount;
}

// Apply currency format to the sales column
summarySheet["B:B"].FormatString = "$#,##0.00";

// Bold the header row
summarySheet["A1:C1"].Style.Font.Bold = true;

// Save -- no COM cleanup needed
workbook.SaveAs(@"C:\output\analysis_ironxl.xlsx");
using IronXL;
using System.Data;

// Create workbook and populate source data
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet dataSheet = workbook.CreateWorkSheet("SalesData");

dataSheet["A1"].Value = "Product";
dataSheet["B1"].Value = "Region";
dataSheet["C1"].Value = "Sales";

object[,] rows = {
    { "Laptop",   "Neinrth", 1200 },
    { "Laptop",   "South", 1500 },
    { "Phone",    "Neinrth",  800 },
    { "Phone",    "South",  950 },
    { "Tablet",   "East",   600 },
    { "Tablet",   "West",   750 },
    { "Monitor",  "Neinrth",  400 },
    { "Monitor",  "South",  500 },
    { "Keyboard", "East",   300 },
};
for (int i = 0; i < rows.GetLength(0); i++)
{
    dataSheet[$"A{i + 2}"].Value = rows[i, 0];
    dataSheet[$"B{i + 2}"].Value = rows[i, 1];
    dataSheet[$"C{i + 2}"].Value = rows[i, 2];
}

// Aggregate data with LINQ -- equivalent to a pivot table row/column/value layout
DataTable table = dataSheet["A1:C10"].ToDataTable(true);
var summary = table.AsEnumerable()
    .GroupBy(row => row.Field<string>("Product"))
    .Select((group, idx) => new
    {
        Product    = group.Key,
        TotalSales = group.Sum(r => Convert.ToDecimal(r["Sales"])),
        RegionCount = group.Select(r => r.Field<string>("Region")).Distinct().Count(),
        RowIndex   = idx + 2
    })
    .OrderByDescending(x => x.TotalSales);

// Write the summary sheet
WorkSheet summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet["A1"].Value = "Product";
summarySheet["B1"].Value = "Total Sales";
summarySheet["C1"].Value = "Regions";

foreach (var item in summary)
{
    summarySheet[$"A{item.RowIndex}"].Value = item.Product;
    summarySheet[$"B{item.RowIndex}"].Value = (double)item.TotalSales;
    summarySheet[$"C{item.RowIndex}"].Value = item.RegionCount;
}

// Apply currency format to the sales column
summarySheet["B:B"].FormatString = "$#,##0.00";

// Bold the header row
summarySheet["A1:C1"].Style.Font.Bold = true;

// Save -- no COM cleanup needed
workbook.SaveAs(@"C:\output\analysis_ironxl.xlsx");
$vbLabelText   $csharpLabel

Es müssen keine COM-Objekte freigegeben, kein Excel-Prozess beendet und keine Office-Lizenz verwaltet werden. Derselbe Code lässt sich ohne Änderungen unter Linux, macOS und Windows kompilieren und ausführen. Weitere Details zur Aggregations-API finden Sie in der IronXL WorkSheet-Dokumentation .

Ausgabe

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 6 – IronXL -Ausgabe

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 7 – Zusammenfassende Ausgabe

Was sind die wichtigsten Unterschiede bei der Bereitstellung und Wartung?

Bereitstellungsanforderungen

Die Bereitstellung einer Interop-basierten Anwendung erfordert die Überprüfung, ob in der Zielumgebung Windows ausgeführt wird, die richtige Office-Version installiert ist und auf dem Server COM-Automatisierungsberechtigungen konfiguriert sind. Cloud-basierte Umgebungen und containerisierte Workloads können diese Anforderungen in der Regel nicht erfüllen, ohne eine virtualisierte Windows-Desktop-Infrastruktur hinzuzufügen, was die Kosten und die betriebliche Komplexität erheblich erhöht.

IronXL unterliegt keinen solchen Einschränkungen. Fügen Sie das NuGet Paket hinzu, legen Sie Ihr Zielframework auf .NET 6 oder höher fest, und die Anwendung lässt sich auf jedem Host bereitstellen – einschließlich Linux-Containern, Azure App Service unter Linux, AWS Lambda und lokalen Windows-Servern. Auf der Seite mit den Systemanforderungen für IronXL ist die vollständige Kompatibilitätsmatrix aufgeführt.

Fehlerbehandlung und Fehlersuche

Interop-Fehler äußern sich als COM-Ausnahmen (COMException), die sich nur schwer auf für den Benutzer sichtbare Meldungen abbilden lassen. Versionskonflikte zwischen der installierten Office-Version und der Interop-Assembly stellen eine weitere Fehlerquelle dar. Die Behebung dieser Probleme erfordert in der Regel die Reproduktion der exakten Office-Version auf einem Entwicklungsrechner.

IronXL löst standardmäßige System.Exception Unterklassen mit beschreibenden Meldungen aus. Sie können Dateivorgänge in einen try-catch-Block einbetten und aussagekräftiges Feedback liefern, ohne die COM-Fehlercodes verstehen zu müssen. Der IronXL Leitfaden zur Fehlerbehebung behandelt häufige Ausnahmen und deren Lösungen.

Speicher und Leistung

COM-Objekte belegen nicht verwalteten Speicher. Wenn Ihr Code viele Arbeitsblätter verarbeitet oder in einer Schleife läuft, führt das Versäumnis, jede Referenz korrekt freizugeben, zu einem mit der Zeit zunehmenden Speicherverbrauch – ein Problem, das schwer zu erkennen ist, bis es zu einem Produktionsvorfall führt. Interop ist zudem von Natur aus Single-Threaded, da es nur ein einziges Excel-Fenster steuert.

IronXL verwendet verwaltete Objekte, die vom .NET Garbage-Collector unterstützt werden. Der Speicher wird automatisch freigegeben, wenn Objekte ihren Gültigkeitsbereich verlassen. Die parallele Verarbeitung mehrerer Arbeitsmappen ist unkompliziert, da kein gemeinsamer COM-Zustand mit Sperren geschützt werden muss.

Wie wählt man zwischen den beiden Ansätzen?

Das richtige Tool hängt von zwei Bedingungen ab: wo der Code ausgeführt wird und ob natives Pivot-Tabellen-XML erforderlich ist.

Wählen Sie Excel-Interop, wenn:

Die Arbeitslast wird nur auf Windows-Desktop-Rechnern ausgeführt, auf denen Office bereits installiert ist.

  • Die exakte native Pivot-Tabellenformatierung (Datenschnitte, gruppierte Datumsfelder, berechnete Elemente) muss in der Ausgabedatei beibehalten werden. Sie pflegen eine bestehende Interop-Codebasis, daher ist eine vollständige Neuentwicklung nicht gerechtfertigt.

Wählen Sie IronXL, wenn:

Die Anwendung läuft auf einem Server, in einem Container oder in einer Cloud-Funktion.

  • Plattformübergreifende oder Linux-Bereitstellung erforderlich Sie benötigen eine Datenaggregationslogik, die mit Unit-Tests testbar ist und nicht von einem Excel-Prozess abhängt.
  • Sie müssen Excel-Dateien in großem Umfang oder parallel verarbeiten.

Für die meisten neuen .NET 10-Projekte ist IronXL die praktische Standardlösung. Die IronXL Bibliothek bietet außerdem Funktionen zum Lesen von Excel-Dateien in C# , zum Erstellen von Diagrammen , zum Anwenden von Zellstilen , zum Arbeiten mit Formeln und zum Exportieren von Excel-Daten in DataTable – wodurch der Bedarf an mehreren Bibliotheken in Ihrem Stack reduziert wird.

So erstellen Sie Pivot-Tabellen in Excel mit C# Interop vs. IronXL: Bild 8 – Funktionen

Welche zusätzlichen IronXL -Funktionen unterstützen die Datenanalyse?

Über die grundlegende Aggregation hinaus bietet IronXL verschiedene Funktionen, die komplexere Datenanalyse-Workflows unterstützen:

Daten sortieren und filtern

Sie können einen Bereich vor dem Erstellen eines Zusammenfassungsblatts in aufsteigender oder absteigender Reihenfolge sortieren. Dadurch wird sichergestellt, dass die Ausgabe die Daten stets in einer konsistenten Reihenfolge präsentiert, was die nachfolgende Verarbeitung besser vorhersehbar macht. Die Sortieroptionen auf Bereichsebene finden Sie in der IronXL -Dokumentation .

Anwenden der bedingten Formatierung

Durch die programmatische Anwendung bedingter Formatierungsregeln können Ausreißer oder Schwellenwerte hervorgehoben werden. Beispielsweise können Sie Zellen im Übersichtsblatt rot einfärben, wenn die Umsätze unter ein Ziel fallen. So erhalten Sie einen schnellen Überblick, ohne dass die Endbenutzer Regeln manuell konfigurieren müssen.

Vorhandene Excel-Dateien lesen

Wenn die Quelldaten aus einer bestehenden Tabellenkalkulation und nicht aus einer Datenbank stammen, können Sie sie direkt mit WorkBook.Load laden:

using IronXL;

WorkBook existing = WorkBook.Load(@"C:\data\sales_report.xlsx");
WorkSheet sheet = existing.WorkSheets[0];

// Read column C starting at row 2
var salesValues = sheet["C2:C100"]
    .Where(cell => cell.Value != null && cell.Value.ToString() != string.Empty)
    .Select(cell => cell.DecimalValue)
    .ToList();

decimal total = salesValues.Sum();
Console.WriteLine($"Total sales from file: {total:C}");
using IronXL;

WorkBook existing = WorkBook.Load(@"C:\data\sales_report.xlsx");
WorkSheet sheet = existing.WorkSheets[0];

// Read column C starting at row 2
var salesValues = sheet["C2:C100"]
    .Where(cell => cell.Value != null && cell.Value.ToString() != string.Empty)
    .Select(cell => cell.DecimalValue)
    .ToList();

decimal total = salesValues.Sum();
Console.WriteLine($"Total sales from file: {total:C}");
$vbLabelText   $csharpLabel

Dieses Muster funktioniert für .xlsx, .xls, .csv und andere von IronXL unterstützte Formate. Einzelheiten zu den unterstützten Formaten finden Sie in der IronXL -Dateiformatdokumentation .

Exportieren nach CSV

Nachdem Sie ein zusammenfassendes Arbeitsblatt erstellt haben, können Sie es für nachgelagerte Systeme, die Excel nicht akzeptieren, im CSV-Format exportieren:

workbook.SaveAsCsv(@"C:\output\summary.csv");
workbook.SaveAsCsv(@"C:\output\summary.csv");
$vbLabelText   $csharpLabel

Dies ist besonders nützlich in ETL-Pipelines, bei denen der Endverbraucher ein Datenbankimporttool oder ein Data-Warehouse-Loader ist.

Wie kann ich IronXL kostenlos nutzen?

IronXL ist als kostenlose Testlizenz erhältlich, mit der Sie den vollen Funktionsumfang testen können, ohne ein Abonnement abzuschließen. Die Testversion fügt den Ausgabedateien ein Wasserzeichen hinzu, das Sie beim Anwenden eines Produktionslizenzschlüssels entfernen.

Um einen Lizenzschlüssel im Code zu aktivieren, muss dieser vor jeder IronXL Operation festgelegt werden:

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
$vbLabelText   $csharpLabel

Sie können den Schlüssel auch über eine Umgebungsvariable (IRONXL_LICENSEKEY) oder über appsettings.json in ASP.NET Core Projekten festlegen. Auf der IronXL Lizenzseite werden alle verfügbaren Stufen beschrieben, einschließlich Team- und Organisationsoptionen.

Für Produktionsbereitstellungen sollten Sie die IronXL Bereitstellungsdokumentation und die umfassendere IronXL -Tutorialbibliothek nach Mustern für ASP.NET Core, Azure Functions und Docker durchsuchen.

So erstellen Sie eine Pivot-Tabelle in Excel mit C# Interop vs. IronXL: Bild 9 - Lizenzierung

Wie geht es mit dem nächsten Schritt weiter?

Excel-Pivot-Tabellen in C# müssen nicht zwangsläufig Office-Abhängigkeit und COM-Komplexität bedeuten. Mit IronXL schreiben Sie einfachen .NET Code, der auf jeder Plattform läuft, die Speicherverwaltung automatisch übernimmt und sich nahtlos in Unit-Testing-Frameworks und CI/CD-Pipelines integriert.

Laden Sie die kostenlose Testversion von IronXL herunter und führen Sie die Beispiele aus diesem Leitfaden mit Ihren eigenen Daten aus. Bei Fragen stehen Ihnen das IronXL -Community-Forum und das Support-Portal sowohl für Test- als auch für Lizenznutzer zur Verfügung. Sobald Sie bereit für die Bereitstellung sind, prüfen Sie die Lizenzoptionen , um den Plan zu finden, der zu Ihrer Teamgröße und Ihrem Nutzungsvolumen passt.

Häufig gestellte Fragen

Was ist der Vorteil von IronXL gegenüber Excel Interop bei der Erstellung von Pivot-Tabellen?

IronXL bietet eine modernere und effizientere Methode zur Erstellung von Pivot-Tabellen in Excel-Dateien als das traditionelle Excel Interop. Es vereinfacht den Prozess und reduziert die Menge des benötigten Boilerplate-Codes.

Kann ich eine Pivot-Tabelle in Excel mit C# und IronXL erstellen?

Ja, IronXL bietet eine unkomplizierte Methode zur Erstellung von Pivot-Tabellen in Excel mit C#. Es ermöglicht Entwicklern die einfache Bearbeitung von Excel-Dateien, ohne dass sie auf Excel Interop angewiesen sind.

Ist IronXL mit .NET-Anwendungen kompatibel?

IronXL ist vollständig kompatibel mit .NET-Anwendungen und damit eine ausgezeichnete Wahl für Entwickler, die Excel-Funktionen in ihre C#-Projekte integrieren möchten.

Muss für IronXL Excel auf dem System installiert sein?

Nein, IronXL erfordert nicht, dass Microsoft Excel auf dem System installiert ist. Es arbeitet unabhängig, was ein wesentlicher Vorteil gegenüber Excel Interop ist, das die Installation von Excel voraussetzt.

Wie vereinfacht IronXL den Prozess der Erstellung von Pivot-Tabellen?

IronXL vereinfacht den Prozess durch die Bereitstellung einer benutzerfreundlichen API, die den Bedarf an umfangreichem Boilerplate-Code reduziert und den Entwicklungsprozess schneller und effizienter macht.

Was sind die Systemvoraussetzungen für die Verwendung von IronXL?

IronXL setzt eine mit dem .NET Framework kompatible Umgebung voraus, benötigt aber keine Installation von Microsoft Excel, was die Bereitstellung vereinfacht und Abhängigkeiten reduziert.

Kann IronXL große Excel-Dateien effizient handhaben?

Ja, IronXL wurde entwickelt, um große Excel-Dateien effizient zu verarbeiten und eignet sich daher für Geschäftsanwendungen, die große Datenmengen verarbeiten müssen.

Gibt es eine Lernkurve für die Verwendung von IronXL im Vergleich zu Excel Interop?

IronXL ist so konzipiert, dass es intuitiv und leicht zu erlernen ist, mit umfassender Dokumentation und Beispielen, was den Einstieg im Vergleich zu dem komplexeren Excel Interop erleichtert.

Welche Arten von Excel-Operationen kann IronXL neben der Erstellung von Pivot-Tabellen durchführen?

IronXL kann eine breite Palette von Excel-Operationen durchführen, darunter das Lesen und Schreiben von Excel-Dateien, das Formatieren von Zellen und das Anwenden von Formeln, um nur einige zu nennen.

Kann IronXL Pivot-Tabellen auch in andere Formate als Excel exportieren?

IronXL ist zwar in erster Linie auf Excel-Operationen ausgerichtet, unterstützt aber auch den Export von Daten in andere Formate wie CSV und PDF, je nach Ihren Projektanforderungen.

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