Die beste Methode zum Lesen von Excel-Dateien in C# | IronXL Schritt-für-Schritt-Anleitung

Was ist der beste Weg, um Excel-Dateien in C# zu lesen?

Die beste Vorgehensweise ist die Verwendung einer dedizierten, Office-unabhängigen Bibliothek wie beispielsweise IronXL. Herkömmliche Methoden wie Microsoft.Office.Interop.Excel funktionieren auf Rechnern, auf denen Excel installiert ist, sind aber in Server- oder Containerumgebungen fehleranfällig, da sie im Hintergrund einen COM-Prozess starten. Das OpenXML SDK ist kostenlos und serversicher, stellt aber ein Niedrig-Level-XML-Modell bereit, das für alltägliche Aufgaben einen erheblichen Mehraufwand an Code erfordert.

IronXL liegt zwischen diesen Extremen. Die API spiegelt die Denkweise von Entwicklern in Bezug auf Tabellenkalkulationen wider – Arbeitsmappen enthalten Arbeitsblätter, Arbeitsblätter enthalten Zellen und Zellen enthalten eingegebene Werte. Die Bibliothek übernimmt die Formaterkennung, die Formelauswertung und die Kodierung intern, sodass Sie Ihre Zeit mit der Geschäftslogik verbringen können, anstatt Details zu analysieren.

Die Excel-Lesedokumentation von IronXL deckt die gesamte API-Oberfläche ab. Die folgenden Abschnitte zeigen Ihnen zunächst die Kernmuster, die Sie in jedem Projekt verwenden werden.

Wie installiert man IronXL in einem .NET -Projekt?

Die Installation dauert mit dem NuGet -Paketmanager weniger als eine Minute. Öffne ein Terminal in deinem Projektverzeichnis und führe folgenden Befehl aus:

dotnet add package IronXL.Excel

Alternativ können Sie die Visual Studio-Paket-Manager-Konsole verwenden:

Install-Package IronXL.Excel

Nach der Installation fügen Sie die using IronXL; Direktive in jede Datei ein, die auf Tabellenkalkulationszugriff angewiesen ist. Die Bibliothek ist für .NET 10, .NET 8, .NET 6, .NET Framework 4.6.2 und .NET Standard 2.0 geeignet und lässt sich daher ohne Aktualisierung der Laufzeitumgebung in bestehende Projekte integrieren. Plattformspezifische Hinweise und Details zum NuGet Paket finden Sie im IronXL Installationshandbuch .

Es werden keine zusätzlichen Laufzeitkomponenten, Registry-Einträge oder Office-Lizenzen benötigt. Das NuGet Paket enthält alles, was die Bibliothek benötigt.

Wie lädt und liest man eine Excel-Arbeitsmappe?

Zum Laden einer Arbeitsmappe ist ein einziger Methodenaufruf erforderlich. WorkBook.Load akzeptiert einen Dateipfad und gibt ein WorkBook Objekt zurück, das die gesamte Datei im Speicher darstellt.

using IronXL;

// Load any supported format -- XLSX, XLS, or CSV
WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access the first worksheet by position
WorkSheet worksheet = workbook.WorkSheets[0];

// Or retrieve a named worksheet
WorkSheet expenses = workbook.GetWorkSheet("Expenses");

Console.WriteLine($"Sheets loaded: {workbook.WorkSheets.Count}");
Console.WriteLine($"Default sheet rows: {worksheet.RowCount}");

using IronXL;

// Load any supported format -- XLSX, XLS, or CSV
WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access the first worksheet by position
WorkSheet worksheet = workbook.WorkSheets[0];

// Or retrieve a named worksheet
WorkSheet expenses = workbook.GetWorkSheet("Expenses");

Console.WriteLine($"Sheets loaded: {workbook.WorkSheets.Count}");
Console.WriteLine($"Default sheet rows: {worksheet.RowCount}");

Imports IronXL

' Load any supported format -- XLSX, XLS, or CSV
Dim workbook As WorkBook = WorkBook.Load("financial_report.xlsx")

' Access the first worksheet by position
Dim worksheet As WorkSheet = workbook.WorkSheets(0)

' Or retrieve a named worksheet
Dim expenses As WorkSheet = workbook.GetWorkSheet("Expenses")

Console.WriteLine($"Sheets loaded: {workbook.WorkSheets.Count}")
Console.WriteLine($"Default sheet rows: {worksheet.RowCount}")

Das WorkBook Objekt hält alle Arbeitsblattdaten zugänglich. Jede WorkSheet Instanz entspricht einem Tab im Datei. Der Zugriff über den Index (WorkSheets[0]) ist zuverlässig bei Dateien mit nur einem Blatt; Der Zugriff über den Namen ist sicherer, wenn die Datei mehrere Tabs mit bekannten Namen enthält.

IronXL wertet Formeln automatisch aus, sobald Sie eine Zelle lesen. Wenn die Zelle B10 =SUM(B2:B9) enthält, gibt das Lesen von sheet["B10"].DecimalValue die berechnete Summe zurück, nicht den Formelstring. Weitere Informationen zu den Optionen zum Laden von Arbeitsmappen finden Sie in der Anleitung zum Laden von Tabellenkalkulationen .

Wie liest man Zellwerte aus einem Arbeitsblatt aus?

IronXL stellt für jede Zelle stark typisierte Eigenschaften bereit, sodass Sie Werte direkt in den richtigen .NET -Typ einlesen können, ohne sie manuell parsen zu müssen.

using IronXL;

WorkBook workbook = WorkBook.Load("Products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Address-based access with typed properties
string productName = sheet["A2"].StringValue;
int quantity       = sheet["B2"].IntValue;
decimal price      = sheet["C2"].DecimalValue;
bool inStock       = sheet["D2"].BoolValue;

// Check for empty cells before processing
var statusCell = sheet["E2"];
if (statusCell.Value != null && statusCell.StringValue.Length > 0)
{
    Console.WriteLine($"Status: {statusCell.StringValue}");
}

// Row/column index access (zero-based)
var firstDataCell = sheet.Rows[1].Columns[0];
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");

using IronXL;

WorkBook workbook = WorkBook.Load("Products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Address-based access with typed properties
string productName = sheet["A2"].StringValue;
int quantity       = sheet["B2"].IntValue;
decimal price      = sheet["C2"].DecimalValue;
bool inStock       = sheet["D2"].BoolValue;

// Check for empty cells before processing
var statusCell = sheet["E2"];
if (statusCell.Value != null && statusCell.StringValue.Length > 0)
{
    Console.WriteLine($"Status: {statusCell.StringValue}");
}

// Row/column index access (zero-based)
var firstDataCell = sheet.Rows[1].Columns[0];
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("Products.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Address-based access with typed properties
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim price As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue

' Check for empty cells before processing
Dim statusCell = sheet("E2")
If statusCell.Value IsNot Nothing AndAlso statusCell.StringValue.Length > 0 Then
    Console.WriteLine($"Status: {statusCell.StringValue}")
End If

' Row/column index access (zero-based)
Dim firstDataCell = sheet.Rows(1).Columns(0)
Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}")

Die sheet["A2"] Syntax verwendet die Standard-Excel-Neintation. Bei den Spaltenbuchstaben wird nicht zwischen Groß- und Kleinschreibung unterschieden, und die Zeilennummern beginnen bei 1, entsprechend der Zellbezeichnung in Excel. Die Zellwertelektrodokumentation zeigt weitere typisierte Zugriffe einschließlich DateTimeValue für als Datum formatierte Zellen.

Wenn eine Zelle eine als Text gespeicherte Zahl enthält (ein übliches Datenqualitätsproblem bei exportierten Tabellenkalkulationen), gibt StringValue den Text unverändert zurück, während DecimalValue einen Parser versucht und bei Misserfolg 0 zurückgibt. Unerwartete Daten müssen immer validiert werden, bevor sie im Produktionscode als typisierter Wert behandelt werden.

Wie iteriert man durch Zeilen und Zellen?

Das Durchlaufen eines Datensatzes erfordert einen Bereich oder eine Zeilensammlung. IronXL unterstützt beide Ansätze, und Sie können sie kombinieren, um die Form der Daten abzubilden.

using IronXL;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");
WorkSheet sheet = workbook.WorkSheets[0];

// Iterate a cell range -- skips header row
foreach (var cell in sheet["A2:D100"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Row-by-row with column access
for (int rowIndex = 1; rowIndex < sheet.RowCount; rowIndex++)
{
    var row = sheet.Rows[rowIndex];
    var values = new System.Text.StringBuilder();

    foreach (var cell in row)
    {
        if (cell.Value != null)
            values.Append($"{cell.StringValue}\t");
    }

    Console.WriteLine(values.ToString().TrimEnd());
}

using IronXL;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");
WorkSheet sheet = workbook.WorkSheets[0];

// Iterate a cell range -- skips header row
foreach (var cell in sheet["A2:D100"])
{
    Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}

// Row-by-row with column access
for (int rowIndex = 1; rowIndex < sheet.RowCount; rowIndex++)
{
    var row = sheet.Rows[rowIndex];
    var values = new System.Text.StringBuilder();

    foreach (var cell in row)
    {
        if (cell.Value != null)
            values.Append($"{cell.StringValue}\t");
    }

    Console.WriteLine(values.ToString().TrimEnd());
}

Imports IronXL
Imports System.Text

Dim workbook As WorkBook = WorkBook.Load("financial_report.xlsx")
Dim sheet As WorkSheet = workbook.WorkSheets(0)

' Iterate a cell range -- skips header row
For Each cell In sheet("A2:D100")
    Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next

' Row-by-row with column access
For rowIndex As Integer = 1 To sheet.RowCount - 1
    Dim row = sheet.Rows(rowIndex)
    Dim values As New StringBuilder()

    For Each cell In row
        If cell.Value IsNot Nothing Then
            values.Append($"{cell.StringValue}" & vbTab)
        End If
    Next

    Console.WriteLine(values.ToString().TrimEnd())
Next

Der Bereichsstring "A2:D100" erstellt eine flache Zellensammlung. Die Zeilen innerhalb des Bereichs werden von oben nach unten und von links nach rechts verarbeitet. Dieses Muster funktioniert gut beim Export nach List<t>, DataTable oder eine Datenbank.

Die sheet.RowCount Eigenschaft spiegelt die zuletzt verwendete Zeile im Arbeitsblatt wider, sodass die Schleife automatisch endet, wenn die Daten enden. Der Leitfaden zum Durchlaufen von Excel-Bereichen behandelt zusätzliche Iterationsmuster, einschließlich Spalten-erst-Durchlauf.

Wie geht man mit mehreren Excel-Formaten um?

IronXL erkennt das Dateiformat automatisch anhand der Dateierweiterung und des Dateikopfes. Die API ist für XLSX-, XLS- und CSV-Dateien identisch, was bedeutet, dass derselbe Parsing-Code für alle drei Formate ohne bedingte Logik funktioniert.

using IronXL;

// Load different formats with identical API
WorkBook xlsxBook = WorkBook.Load("Modern.xlsx");
WorkBook xlsBook  = WorkBook.Load("Legacy.xls");
WorkBook csvBook  = WorkBook.Load("Export.csv");

// Access worksheets identically across formats
WorkSheet sheet1 = xlsxBook.DefaultWorkSheet;
WorkSheet sheet2 = xlsBook.DefaultWorkSheet;
WorkSheet sheet3 = csvBook.DefaultWorkSheet;

// Cross-format conversion -- save XLSX as CSV, or CSV as XLSX
xlsxBook.SaveAs("converted_output.csv");
csvBook.SaveAs("structured_output.xlsx");

Console.WriteLine($"XLSX rows: {sheet1.RowCount}");
Console.WriteLine($"XLS rows:  {sheet2.RowCount}");
Console.WriteLine($"CSV rows:  {sheet3.RowCount}");

using IronXL;

// Load different formats with identical API
WorkBook xlsxBook = WorkBook.Load("Modern.xlsx");
WorkBook xlsBook  = WorkBook.Load("Legacy.xls");
WorkBook csvBook  = WorkBook.Load("Export.csv");

// Access worksheets identically across formats
WorkSheet sheet1 = xlsxBook.DefaultWorkSheet;
WorkSheet sheet2 = xlsBook.DefaultWorkSheet;
WorkSheet sheet3 = csvBook.DefaultWorkSheet;

// Cross-format conversion -- save XLSX as CSV, or CSV as XLSX
xlsxBook.SaveAs("converted_output.csv");
csvBook.SaveAs("structured_output.xlsx");

Console.WriteLine($"XLSX rows: {sheet1.RowCount}");
Console.WriteLine($"XLS rows:  {sheet2.RowCount}");
Console.WriteLine($"CSV rows:  {sheet3.RowCount}");

Imports IronXL

' Load different formats with identical API
Dim xlsxBook As WorkBook = WorkBook.Load("Modern.xlsx")
Dim xlsBook As WorkBook = WorkBook.Load("Legacy.xls")
Dim csvBook As WorkBook = WorkBook.Load("Export.csv")

' Access worksheets identically across formats
Dim sheet1 As WorkSheet = xlsxBook.DefaultWorkSheet
Dim sheet2 As WorkSheet = xlsBook.DefaultWorkSheet
Dim sheet3 As WorkSheet = csvBook.DefaultWorkSheet

' Cross-format conversion -- save XLSX as CSV, or CSV as XLSX
xlsxBook.SaveAs("converted_output.csv")
csvBook.SaveAs("structured_output.xlsx")

Console.WriteLine($"XLSX rows: {sheet1.RowCount}")
Console.WriteLine($"XLS rows:  {sheet2.RowCount}")
Console.WriteLine($"CSV rows:  {sheet3.RowCount}")

Bei CSV-Dateien beachtet IronXL die Konventionen von RFC 4180, einschließlich der Kennzeichnung von Feldern mit Kommas, Zeilenumbrüchen innerhalb von Werten in Anführungszeichen und maskierten doppelten Anführungszeichen. Der Leitfaden zur CSV-zu-XLSX-Konvertierung behandelt die Anpassung von Trennzeichen für nicht standardmäßige CSV-Exporte.

Wenn Ihre Anwendung Dateien von externen Systemen empfangen muss, ist es ratsam, die Dateierweiterung zu überprüfen und den Inhalt vor dem Laden zu validieren. IronXL löst eine beschreibende Ausnahme aus, wenn die Datei beschädigt ist oder ein nicht unterstütztes Format aufweist. Diese Ausnahme können Sie abfangen und dem Benutzer anzeigen.

Wie führt man erweiterte Abfragen auf Excel-Daten durch?

Über das Lesen einzelner Zellen hinaus bietet IronXL Aggregatfunktionen und LINQ-Kompatibilität, die einen Tabellenbereich in eine abfragbare Sammlung verwandeln.

using IronXL;
using System.Linq;

WorkBook workbook = WorkBook.Load("Financials.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Built-in aggregates -- no manual looping needed
decimal totalSales = sheet["B2:B50"].Sum();
decimal maxRevenue = sheet["C2:C50"].Max(c => c.DecimalValue);
decimal avgMargin  = sheet["D2:D50"].Avg();

// LINQ filtering directly on a range
var highValueRows = sheet["C2:C50"]
    .Where(c => c.DecimalValue > 1000)
    .Select(c => new { c.AddressString, c.DecimalValue });

foreach (var row in highValueRows)
    Console.WriteLine($"Hoch value at {row.AddressString}: {row.DecimalValue:C}");

// Write a calculated result back to the sheet
sheet["E2"].Value = totalSales;
workbook.SaveAs("Financials_Updated.xlsx");

Console.WriteLine($"Total: {totalSales:C}, Max: {maxRevenue:C}, Avg: {avgMargin:C}");

using IronXL;
using System.Linq;

WorkBook workbook = WorkBook.Load("Financials.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Built-in aggregates -- no manual looping needed
decimal totalSales = sheet["B2:B50"].Sum();
decimal maxRevenue = sheet["C2:C50"].Max(c => c.DecimalValue);
decimal avgMargin  = sheet["D2:D50"].Avg();

// LINQ filtering directly on a range
var highValueRows = sheet["C2:C50"]
    .Where(c => c.DecimalValue > 1000)
    .Select(c => new { c.AddressString, c.DecimalValue });

foreach (var row in highValueRows)
    Console.WriteLine($"Hoch value at {row.AddressString}: {row.DecimalValue:C}");

// Write a calculated result back to the sheet
sheet["E2"].Value = totalSales;
workbook.SaveAs("Financials_Updated.xlsx");

Console.WriteLine($"Total: {totalSales:C}, Max: {maxRevenue:C}, Avg: {avgMargin:C}");

Imports IronXL
Imports System.Linq

Dim workbook As WorkBook = WorkBook.Load("Financials.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Built-in aggregates -- no manual looping needed
Dim totalSales As Decimal = sheet("B2:B50").Sum()
Dim maxRevenue As Decimal = sheet("C2:C50").Max(Function(c) c.DecimalValue)
Dim avgMargin As Decimal = sheet("D2:D50").Avg()

' LINQ filtering directly on a range
Dim highValueRows = sheet("C2:C50") _
    .Where(Function(c) c.DecimalValue > 1000) _
    .Select(Function(c) New With {Key .AddressString = c.AddressString, Key .DecimalValue = c.DecimalValue})

For Each row In highValueRows
    Console.WriteLine($"Hoch value at {row.AddressString}: {row.DecimalValue:C}")
Next

' Write a calculated result back to the sheet
sheet("E2").Value = totalSales
workbook.SaveAs("Financials_Updated.xlsx")

Console.WriteLine($"Total: {totalSales:C}, Max: {maxRevenue:C}, Avg: {avgMargin:C}")

Die LINQ-Kompatibilität ist nützlich, wenn Sie Zeilen vor dem Import in eine Datenbank filtern oder überprüfen müssen, ob alle Werte in einer Spalte einen Schwellenwert erfüllen. Die Bibliothek wertet Formeln aus, bevor LINQ ausgeführt wird, sodass Aggregatabfragen immer mit den endgültig berechneten Werten und nicht mit Formelzeichenfolgen arbeiten.

Das LINQ mit IronXL Tutorial behandelt das Zusammenführen von Arbeitsblättern, das Gruppieren nach Spalte und das Projizieren von Ergebnissen in stark typisierte Objekte -- Muster, die eine Menge Boilerplate in Datenpipeline-Code eliminieren.

Wie exportiert man Excel-Daten in eine DataTable?

Viele .NET Anwendungen laden Tabellendaten in ein ADO.NET DataTable zur weiteren Verarbeitung oder Datenbankeinfügung. IronXL bietet eine direkte Konvertierungsmethode, die die Neintwendigkeit einer manuellen Spaltenzuordnung überflüssig macht.

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Convert worksheet to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);

Console.WriteLine($"Columns: {dataTable.Columns.Count}");
Console.WriteLine($"Rows:    {dataTable.Rows.Count}");

// Iterate the DataTable normally
foreach (DataRow row in dataTable.Rows)
{
    Console.WriteLine($"{row["ProductName"]} -- {row["Quantity"]} -- {row["Price"]}");
}

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("SalesData.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Convert worksheet to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);

Console.WriteLine($"Columns: {dataTable.Columns.Count}");
Console.WriteLine($"Rows:    {dataTable.Rows.Count}");

// Iterate the DataTable normally
foreach (DataRow row in dataTable.Rows)
{
    Console.WriteLine($"{row["ProductName"]} -- {row["Quantity"]} -- {row["Price"]}");
}

Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("SalesData.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Convert worksheet to DataTable -- first row becomes column headers
Dim dataTable As DataTable = sheet.ToDataTable(True)

Console.WriteLine($"Columns: {dataTable.Columns.Count}")
Console.WriteLine($"Rows:    {dataTable.Rows.Count}")

' Iterate the DataTable normally
For Each row As DataRow In dataTable.Rows
    Console.WriteLine($"{row("ProductName")} -- {row("Quantity")} -- {row("Price")}")
Next

true an ToDataTable zu übergeben behandelt die erste Arbeitsblattzeile als Spaltenköpfe. Das resultierende DataTable verwendet String-Spaltennamen, die mit dem Kopfzeilentext übereinstimmen, wodurch nachfolgende LINQ-to-DataSet Abfragen lesbar werden. Die Dokumentation zum Export von DataTables behandelt den Umgang mit Null-Werten und Typ-Inferenz-Optionen.

Dieses Muster ist besonders nützlich, wenn der nachfolgende Code bereits ein DataTable erwartet -- zum Beispiel, wenn SqlBulkCopy aufgerufen wird, um Zeilen in SQL Server einzufügen. Sie können die XLSX-Datei laden, sie in ein DataTable umwandeln und in großen Mengen einfügen, ohne eine Spaltenzuordnung zu schreiben.

Eine vollständige API-Liste finden Sie in der IronXL API-Referenz . Die Referenz umfasst alle Eigenschaften und Methoden mit Parameterbeschreibungen und Angaben zum Rückgabetyp.

Was sind Ihre nächsten Schritte?

Das Lesen von Excel-Dateien in C# ist unkompliziert, sobald man die richtige Bibliothek hat. IronXL beseitigt die Office-Abhängigkeit, vereinfacht die API-Oberfläche und verarbeitet XLSX-, XLS- und CSV-Formate mit demselben Codepfad. Die hier behandelten Muster -- Laden eines Arbeitsbuchs, Lesen typisierter Zellwerte, Durchlaufen von Bereichen, Ausführen von Aggregaten und Exportieren in ein DataTable -- decken die Mehrheit der Anforderungen an das Lesen von Tabellenkalkulationen in der Praxis ab.

Um diese Muster weiter auszubauen:

• Lesen Sie die IronXL Dokumentation für Einsteiger , um Hinweise zur Projekteinrichtung und zu den Laufzeitanforderungen zu erhalten.
• Entdecken Sie die Anleitungen zum Schreiben, Formatieren und Erstellen von Diagrammen.
• Überprüfen Sie den Leitfaden zur Unterstützung von Excel-Formeln, um zu verstehen, welche Excel-Funktionen IronXL automatisch auswertet.
• Informationen zu den Produktionsbereitstellungsoptionen finden Sie auf der IronXL -Lizenzseite .
• Im IronXL Blog finden Sie praktische Beispiele zu Datenvalidierung, Pivot-Tabellen-Export und passwortgeschützter Dateiverarbeitung.

Für Teams, die IronXL mit anderen Bibliotheken evaluieren, deckt der Vergleich IronXL vs EPPlus und der Vergleich IronXL vs NPOI Leistungsbenchmarks und API-Unterschiede ab. Beide Vergleiche enthalten Codebeispiele für äquivalente Betrieben in den jeweiligen Bibliotheken.

Die Spezifikation des Excel-Dateiformats von Microsoft selbst ist eine nützliche Referenz, falls Sie auf ungewöhnliche Tabellenstrukturen aus älteren Systemen stoßen. Der ECMA-376-Standard definiert das OOXML-Format, dem XLSX-Dateien folgen.

Beginnen Sie mit einer kostenlosen IronXL -Testlizenz , um die vollständige API in Ihrem eigenen Projekt zu testen, bevor Sie sich für eine Produktionslizenz entscheiden.