Das Lesen und Verarbeiten von OpenDocument Spreadsheet (ODS)- und Excel-Dateien in C# ist unkompliziert, wenn man die richtige Bibliothek verwendet. Mit IronXL laden Sie jede XLS-, XLSX-, ODS- oder CSV-Datei mittels eines einzigen Methodenaufrufs in ein WorkBook-Objekt. Es ist keine Microsoft Excel-Installation erforderlich, keine COM-Registrierung und keine Interop-Komplikationen. Dieser Leitfaden führt Sie durch jeden einzelnen Schritt: Installation des Pakets, Laden von Dateien, Extrahieren von typisierten Zellwerten, Arbeiten mit benannten Arbeitsblättern, Umgang mit verbundenen Zellen und Bereitstellung in Linux- oder Containerumgebungen.

Wie installiert man IronXL in einem .NET -Projekt?

Installation des NuGet -Paketmanagers

Fügen Sie IronXL über den NuGet -Paketmanager zu Ihrem Projekt hinzu. Öffnen Sie die Paketmanager-Konsole in Visual Studio und führen Sie den Befehl aus:

Install-Package IronXL.Excel

IronXL zielt auf .NET 8, .NET 9, .NET 10, .NET Framework 4.6.2+ und .NET Standard 2.0, sodass es sowohl zu modernen als auch zu älteren Codebasen passt. Nach der Installation des Paketes fügen Sie die using IronXL; Direktive am Anfang jeder Datei hinzu, die mit Tabellen arbeitet, und sind bereit, Ihr erstes Arbeitsbuch zu laden.

Für Azure Functions, Docker-Container oder auf Linux gehostete APIs ist keine zusätzliche Laufzeitkonfiguration erforderlich. Die Bibliothek bündelt alles Notwendige intern und greift nicht auf Excel-Automatisierungskomponenten zu.

Wie lädt man eine OpenOffice- oder Excel-Datei in C#?

IronXL behandelt ODS-, XLS-, XLSX- und CSV-Dateien über die WorkBook.Load Methode identisch. Sie übergeben einen absoluten oder relativen Dateipfad, und die Bibliothek erkennt das Format anhand des Dateikopfes – nicht nur anhand der Dateiendung. Das bedeutet, dass eine Datei, die von .ods in .xlsx umbenannt wird, immer noch korrekt gelesen wird.

using IronXL;

// Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
WorkBook workbook = WorkBook.Load("quarterly_report.ods");

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

// Read a cell value
string companyName = sheet["A1"].StringValue;
int recordCount   = sheet["B1"].IntValue;

Console.WriteLine($"Company : {companyName}");
Console.WriteLine($"Records : {recordCount}");

using IronXL;

// Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
WorkBook workbook = WorkBook.Load("quarterly_report.ods");

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

// Read a cell value
string companyName = sheet["A1"].StringValue;
int recordCount   = sheet["B1"].IntValue;

Console.WriteLine($"Company : {companyName}");
Console.WriteLine($"Records : {recordCount}");

Imports IronXL

' Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
Dim workbook As WorkBook = WorkBook.Load("quarterly_report.ods")

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

' Read a cell value
Dim companyName As String = sheet("A1").StringValue
Dim recordCount As Integer = sheet("B1").IntValue

Console.WriteLine($"Company : {companyName}")
Console.WriteLine($"Records : {recordCount}")

Imports IronXL

' Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
Dim workbook As WorkBook = WorkBook.Load("quarterly_report.ods")

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

' Read a cell value
Dim companyName As String = sheet("A1").StringValue
Dim recordCount As Integer = sheet("B1").IntValue

Console.WriteLine($"Company : {companyName}")
Console.WriteLine($"Records : {recordCount}")

Der gleiche Aufruf funktioniert sowohl für XLSX- als auch für XLS-Dateien – Sie müssen lediglich den Pfad ändern. WorkBook.Load gibt dasselbe stark typisierte Objekt unabhängig vom Quellformat zurück, sodass der Rest Ihres Codes identisch bleibt, egal ob die Datei aus Microsoft Excel, LibreOffice oder einer anderen ODF-konformen Anwendung stammt.

Wie liest man jede Zeile und Zelle in einem Arbeitsblatt?

Iterieren der Zeilenkollektion

Das Iterieren über alle Zeilen und Zellen ist die häufigste Aufgabe bei der Excel-Verarbeitung – egal ob Sie Importdaten validieren, Datensätze transformieren oder eine Berichtspipeline speisen. IronXL stellt eine Rows Sammlung auf jedem WorkSheet zur Verfügung:

using IronXL;

WorkBook workbook  = WorkBook.Load("customers.xlsx");
WorkSheet worksheet = workbook.WorkSheets[0];

Console.WriteLine($"Total rows    : {worksheet.RowCount}");
Console.WriteLine($"Total columns : {worksheet.ColumnCount}");
Console.WriteLine();

foreach (var row in worksheet.Rows)
{
    foreach (var cell in row)
    {
        if (!cell.IsEmpty)
            Console.Write($"{cell.StringValue,-20}");
    }
    Console.WriteLine();
}

using IronXL;

WorkBook workbook  = WorkBook.Load("customers.xlsx");
WorkSheet worksheet = workbook.WorkSheets[0];

Console.WriteLine($"Total rows    : {worksheet.RowCount}");
Console.WriteLine($"Total columns : {worksheet.ColumnCount}");
Console.WriteLine();

foreach (var row in worksheet.Rows)
{
    foreach (var cell in row)
    {
        if (!cell.IsEmpty)
            Console.Write($"{cell.StringValue,-20}");
    }
    Console.WriteLine();
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")
Dim worksheet As WorkSheet = workbook.WorkSheets(0)

Console.WriteLine($"Total rows    : {worksheet.RowCount}")
Console.WriteLine($"Total columns : {worksheet.ColumnCount}")
Console.WriteLine()

For Each row In worksheet.Rows
    For Each cell In row
        If Not cell.IsEmpty Then
            Console.Write($"{cell.StringValue,-20}")
        End If
    Next
    Console.WriteLine()
Next

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")
Dim worksheet As WorkSheet = workbook.WorkSheets(0)

Console.WriteLine($"Total rows    : {worksheet.RowCount}")
Console.WriteLine($"Total columns : {worksheet.ColumnCount}")
Console.WriteLine()

For Each row In worksheet.Rows
    For Each cell In row
        If Not cell.IsEmpty Then
            Console.Write($"{cell.StringValue,-20}")
        End If
    Next
    Console.WriteLine()
Next

Die RowCount und ColumnCount Eigenschaften geben nur den ausgefüllten Bereich zurück – leere nachfolgende Zeilen und Spalten sind nicht enthalten. Die Überprüfung von cell.IsEmpty vor dem Lesen verhindert unnötige Verarbeitung auf spärlich besetzten Blättern.

Bei großen Dateien sollten Sie den bereichsbasierten Zugriff (worksheet["A1:D500"]) anstelle der vollständigen Blattiteration in Betracht ziehen. Dadurch wird die Anzahl der in den Speicher geladenen Zellen begrenzt und die Verarbeitung beschleunigt, wenn nur eine Teilmenge der Daten benötigt wird.

Wie extrahiert man typisierte Werte aus Zellen?

Typisierte Eigenschaften

Die Zellen einer realen Tabellenkalkulation enthalten Zeichenketten, ganze Zahlen, Dezimalzahlen, boolesche Werte und Datumsangaben. IronXL stellt dedizierte typisierte Eigenschaften bereit, sodass Sie niemals Rohzeichenketten manuell parsen müssen:

using IronXL;

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

// Typed accessors handle conversion automatically
string  productName = sheet["A2"].StringValue;
int     quantity    = sheet["B2"].IntValue;
decimal unitPrice   = sheet["C2"].DecimalValue;
bool    inStock     = sheet["D2"].BoolValue;
DateTime? lastAudit = sheet["E2"].DateTimeValue;

Console.WriteLine($"Product  : {productName}");
Console.WriteLine($"Qty      : {quantity}");
Console.WriteLine($"Price    : {unitPrice:C}");
Console.WriteLine($"In Stock : {inStock}");
Console.WriteLine($"Audited  : {lastAudit?.ToString("d") ?? "Never"}");

using IronXL;

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

// Typed accessors handle conversion automatically
string  productName = sheet["A2"].StringValue;
int     quantity    = sheet["B2"].IntValue;
decimal unitPrice   = sheet["C2"].DecimalValue;
bool    inStock     = sheet["D2"].BoolValue;
DateTime? lastAudit = sheet["E2"].DateTimeValue;

Console.WriteLine($"Product  : {productName}");
Console.WriteLine($"Qty      : {quantity}");
Console.WriteLine($"Price    : {unitPrice:C}");
Console.WriteLine($"In Stock : {inStock}");
Console.WriteLine($"Audited  : {lastAudit?.ToString("d") ?? "Never"}");

Imports IronXL

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

' Typed accessors handle conversion automatically
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim unitPrice As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue
Dim lastAudit As DateTime? = sheet("E2").DateTimeValue

Console.WriteLine($"Product  : {productName}")
Console.WriteLine($"Qty      : {quantity}")
Console.WriteLine($"Price    : {unitPrice:C}")
Console.WriteLine($"In Stock : {inStock}")
Console.WriteLine($"Audited  : {If(lastAudit?.ToString("d"), "Never")}")

Imports IronXL

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

' Typed accessors handle conversion automatically
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim unitPrice As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue
Dim lastAudit As DateTime? = sheet("E2").DateTimeValue

Console.WriteLine($"Product  : {productName}")
Console.WriteLine($"Qty      : {quantity}")
Console.WriteLine($"Price    : {unitPrice:C}")
Console.WriteLine($"In Stock : {inStock}")
Console.WriteLine($"Audited  : {If(lastAudit?.ToString("d"), "Never")}")

Wenn eine Zelle eine Formel enthält, wertet IronXL diese aus und gibt das berechnete Ergebnis über die gleichen typisierten Eigenschaften zurück. Sie müssen keine separate Auswertungsmethode aufrufen. Für Zellen, die leer sein könnten oder einen inkompatiblen Typ enthalten, gibt die Bibliothek den Standardwert für diesen Typ zurück, anstatt eine Ausnahme auszulösen, was die Logik der Eingabevalidierung vereinfacht.

Wie arbeitet man mit mehreren benannten Arbeitsblättern?

Zugriff über Name, Index oder Iteration

Enterprise Tabellenkalkulationen enthalten oft mehrere benannte Tabellenblätter – eines pro Monat, eines pro Region oder eines pro Produktlinie. IronXL bietet Ihnen mehrere Möglichkeiten, darauf zuzugreifen:

using IronXL;

WorkBook workbook = WorkBook.Load("annual_sales.xlsx");

// Option 1: access by name (throws if the sheet does not exist)
WorkSheet januarySheet = workbook.GetWorkSheet("January");

// Option 2: iterate all sheets in the workbook
foreach (WorkSheet ws in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}");

    // Read the header row from each sheet
    string header = ws["A1"].StringValue;
    Console.WriteLine($"  Header: {header}");
}

// Option 3: access by zero-based index
WorkSheet lastSheet = workbook.WorkSheets[workbook.WorkSheets.Count - 1];
Console.WriteLine($"Last sheet: {lastSheet.Name}");

using IronXL;

WorkBook workbook = WorkBook.Load("annual_sales.xlsx");

// Option 1: access by name (throws if the sheet does not exist)
WorkSheet januarySheet = workbook.GetWorkSheet("January");

// Option 2: iterate all sheets in the workbook
foreach (WorkSheet ws in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}");

    // Read the header row from each sheet
    string header = ws["A1"].StringValue;
    Console.WriteLine($"  Header: {header}");
}

// Option 3: access by zero-based index
WorkSheet lastSheet = workbook.WorkSheets[workbook.WorkSheets.Count - 1];
Console.WriteLine($"Last sheet: {lastSheet.Name}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("annual_sales.xlsx")

' Option 1: access by name (throws if the sheet does not exist)
Dim januarySheet As WorkSheet = workbook.GetWorkSheet("January")

' Option 2: iterate all sheets in the workbook
For Each ws As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}")

    ' Read the header row from each sheet
    Dim header As String = ws("A1").StringValue
    Console.WriteLine($"  Header: {header}")
Next

' Option 3: access by zero-based index
Dim lastSheet As WorkSheet = workbook.WorkSheets(workbook.WorkSheets.Count - 1)
Console.WriteLine($"Last sheet: {lastSheet.Name}")

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("annual_sales.xlsx")

' Option 1: access by name (throws if the sheet does not exist)
Dim januarySheet As WorkSheet = workbook.GetWorkSheet("January")

' Option 2: iterate all sheets in the workbook
For Each ws As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}")

    ' Read the header row from each sheet
    Dim header As String = ws("A1").StringValue
    Console.WriteLine($"  Header: {header}")
Next

' Option 3: access by zero-based index
Dim lastSheet As WorkSheet = workbook.WorkSheets(workbook.WorkSheets.Count - 1)
Console.WriteLine($"Last sheet: {lastSheet.Name}")

Wenn der Blattname zur Entwurfszeit bekannt ist, ist GetWorkSheet die klarste Option. Für dynamische Verarbeitung – bei der Blattnamen aus Benutzereingaben oder Konfigurationen stammen – verhindert das Iterieren der WorkSheets-Sammlung fest codierte Annahmen und behandelt Arbeitsmappen mit variierender Blattzahl.

Wie geht man mit verbundenen Zellen und formatierten Bereichen um?

In Berichten und Dashboards werden häufig verbundene Zellen für Überschriften, gruppierte Beschriftungen und Zusammenfassungszeilen verwendet. IronXL liest den Wert aus der Zelle oben links eines zusammengeführten Bereichs genau so, wie er in Excel angezeigt wird:

using IronXL;

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

// The merged region A1:D1 stores its value in cell A1
string reportTitle = sheet["A1"].StringValue;
Console.WriteLine($"Report title : {reportTitle}");

// Read cell formatting metadata
var titleCell = sheet["A1"];
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}");
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}");

// Scan an entire column for non-empty section headers
foreach (var cell in sheet["A1:A100"])
{
    if (!cell.IsEmpty && cell.Style.Font.Bold)
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}");
}

using IronXL;

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

// The merged region A1:D1 stores its value in cell A1
string reportTitle = sheet["A1"].StringValue;
Console.WriteLine($"Report title : {reportTitle}");

// Read cell formatting metadata
var titleCell = sheet["A1"];
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}");
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}");

// Scan an entire column for non-empty section headers
foreach (var cell in sheet["A1:A100"])
{
    if (!cell.IsEmpty && cell.Style.Font.Bold)
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}");
}

Imports IronXL

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

' The merged region A1:D1 stores its value in cell A1
Dim reportTitle As String = sheet("A1").StringValue
Console.WriteLine($"Report title : {reportTitle}")

' Read cell formatting metadata
Dim titleCell = sheet("A1")
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}")
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}")

' Scan an entire column for non-empty section headers
For Each cell In sheet("A1:A100")
    If Not cell.IsEmpty AndAlso cell.Style.Font.Bold Then
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}")
    End If
Next

Imports IronXL

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

' The merged region A1:D1 stores its value in cell A1
Dim reportTitle As String = sheet("A1").StringValue
Console.WriteLine($"Report title : {reportTitle}")

' Read cell formatting metadata
Dim titleCell = sheet("A1")
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}")
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}")

' Scan an entire column for non-empty section headers
For Each cell In sheet("A1:A100")
    If Not cell.IsEmpty AndAlso cell.Style.Font.Bold Then
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}")
    End If
Next

Der Style Eigentumbaum spiegelt die Struktur der OOXML SpreadsheetML-Spezifikation wider, sodass Eigenschaftsnamen vertraut wirken, wenn Sie mit dem Open XML SDK gearbeitet haben. IronXL verpackt diese ganze Komplexität jedoch in eine übersichtliche API, die keinerlei XML-Manipulation Ihrerseits erfordert.

Wie importiert man CSV-Dateien mit der gleichen API?

CSV-Dateien, die von Datenbankexporten, CRM-Systemen und älteren Anwendungen erzeugt wurden, können durch denselben WorkBook.Load-Aufruf gelesen werden. IronXL leitet das Trennzeichen aus dem Dateiinhalt ab:

using IronXL;

// Load a comma-separated values file -- same method, same API
WorkBook csvWorkbook  = WorkBook.Load("export.csv");
WorkSheet csvSheet    = csvWorkbook.DefaultWorkSheet;

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}");

// Process rows exactly like any other worksheet
foreach (var row in csvSheet.Rows)
{
    string id   = row[0].StringValue;
    string name = row[1].StringValue;
    Console.WriteLine($"{id,-10} {name}");
}

using IronXL;

// Load a comma-separated values file -- same method, same API
WorkBook csvWorkbook  = WorkBook.Load("export.csv");
WorkSheet csvSheet    = csvWorkbook.DefaultWorkSheet;

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}");

// Process rows exactly like any other worksheet
foreach (var row in csvSheet.Rows)
{
    string id   = row[0].StringValue;
    string name = row[1].StringValue;
    Console.WriteLine($"{id,-10} {name}");
}

Imports IronXL

' Load a comma-separated values file -- same method, same API
Dim csvWorkbook As WorkBook = WorkBook.Load("export.csv")
Dim csvSheet As WorkSheet = csvWorkbook.DefaultWorkSheet

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}")

' Process rows exactly like any other worksheet
For Each row In csvSheet.Rows
    Dim id As String = row(0).StringValue
    Dim name As String = row(1).StringValue
    Console.WriteLine($"{id,-10} {name}")
Next

Imports IronXL

' Load a comma-separated values file -- same method, same API
Dim csvWorkbook As WorkBook = WorkBook.Load("export.csv")
Dim csvSheet As WorkSheet = csvWorkbook.DefaultWorkSheet

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}")

' Process rows exactly like any other worksheet
For Each row In csvSheet.Rows
    Dim id As String = row(0).StringValue
    Dim name As String = row(1).StringValue
    Console.WriteLine($"{id,-10} {name}")
Next

Nach dem Laden können Sie die Daten als XLSX mit csvWorkbook.SaveAs("output.xlsx") speichern. Dies ist ein gängiges Muster für CSV-zu-Excel-Konvertierungspipelines – eine CSV-Datei empfangen, sie mit berechneten Spalten oder Formatierungen anreichern und dem Benutzer einen formatierten XLSX-Bericht zurückgeben.

Für tab-getrennte Dateien oder benutzerdefinierte Trennzeichen verwenden Sie WorkBook.LoadCSV("file.tsv", fileFormat: ExcelFileFormat.TSV), um das Format explizit anzugeben.

Wie schneidet IronXL im Vergleich zu Microsoft.Office.Interop.Excel ab?

Interop, Open XML SDK und IronXL im Vergleich

Die gebräuchlichste Alternative zu IronXL für die Excel-Automatisierung in .NET ist Microsoft.Office.Interop.Excel . Das Verständnis der Vor- und Nachteile hilft Ihnen bei der Auswahl des richtigen Werkzeugs für Ihr Projekt.

Microsoft Interop kapselt das Excel-COM-Objektmodell. Das bedeutet, dass Excel auf jedem Rechner installiert sein muss, auf dem Ihr Code ausgeführt wird – einschließlich Webserver, Build-Agenten und Cloud-VMs. Die Lebensdauer des COM-Objekts wird manuell verwaltet: Sie müssen jedes Range, Worksheet und Workbook-Objekt explizit freigeben, andernfalls sammeln sich Excel-Prozesse im Hintergrund an und verbrauchen Speicher, bis der Server neu startet. Auch die Lizenzierung gibt Anlass zur Sorge: Die Office-EULA verbietet in vielen Fällen die serverseitige Automatisierung.

IronXL umgeht all diese Einschränkungen. Es handelt sich um eine rein verwaltete Bibliothek ohne COM-Abhängigkeit. Das WorkBook-Objekt ist eine Standard .NET-Klasse; Die automatische Speicherbereinigung (Garbage Collection) übernimmt die Aufräumarbeiten. Sie können denselben Code auf einem Entwicklerlaptop, einem Azure App Service, einem Docker-Container oder einem Raspberry Pi mit Linux ausführen.

Das Open XML SDK von Microsoft ist eine weitere Alternative. Es ermöglicht den direkten Zugriff auf das OOXML-Dateiformat ohne Excel-Kenntnisse, arbeitet aber auf einer sehr niedrigen Ebene – man bearbeitet XML-Elemente direkt. Das Auslesen eines einzelnen Zellenwerts erfordert das Navigieren in gemeinsam genutzten Zeichenfolgentabellen, Zellbezügen und Stilindizes. IronXL verpackt all das in den einzeiligen sheet["A1"].StringValue-Aufruf, der in diesem Leitfaden gezeigt wird.

Wie implementiert man die Excel-Verarbeitung unter Linux und Docker?

Bei Server-Implementierungen erweist sich die Unabhängigkeit von IronXL von Excel als besonders wertvoll. Derselbe Code, den Sie unter Windows schreiben, läuft unverändert unter Ubuntu, Alpine Linux oder macOS. Für containerisierte Bereitstellungen ist in Ihrer Dockerfile keine spezielle Konfiguration erforderlich:

# Standard .NET runtime image -- no Office packages needed
FROM mcr.microsoft.com/dotnet/runtime:10.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ExcelProcessor.dll"]

# Standard .NET runtime image -- no Office packages needed
FROM mcr.microsoft.com/dotnet/runtime:10.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ExcelProcessor.dll"]

Für Azure Functions und AWS Lambda funktioniert IronXL innerhalb der verwalteten Laufzeitumgebung ohne zusätzliche Konfiguration. Der Aufwand beim Kaltstart ist minimal, da kein COM-Initialisierungsschritt erforderlich ist.

Thread-Sicherheit ist integriert: Mehrere Threads können unterschiedliche WorkBook-Instanzen gleichzeitig öffnen, ohne dass eine Koordination erforderlich ist. Wenn Sie Tausende von Dateien parallel verarbeiten müssen – zum Beispiel in einem Hintergrundjob, der von Benutzern hochgeladene Tabellenkalkulationen einliest – können Sie Parallel.ForEach oder Task.WhenAll über einen Pool von WorkBook-Instanzen verwenden, ohne das Risiko einer Beschädigung.

Der Speicherverbrauch bleibt vorhersehbar, da IronXL bei der Initialisierung nur das angeforderte Arbeitsblatt in den Speicher lädt und nicht die gesamte Arbeitsmappe. Bei sehr großen Dateien ist dieser Unterschied wichtig: Eine Arbeitsmappe mit zehn 50-MB-Blättern benötigt nicht 500 MB RAM, nur um ein einziges Blatt zu lesen. Die IronXL-Leistungsdokumentation behandelt weitere Strategien zur Handhabung von Hochvolumen-Dateiverarbeitungsszenarien.

Was sind Ihre nächsten Schritte?

Der schnellste Weg, IronXL in Ihrem Projekt zu validieren, besteht darin, das NuGet Paket zu installieren und die Beispiele in diesem Leitfaden mit einer echten Datei aus Ihrer Umgebung auszuführen. Mit einer kostenlosen Testlizenz werden alle Funktionen freigeschaltet, ohne dass Codeänderungen erforderlich sind, wenn Sie bereit für den Produktiveinsatz sind.

Entdecken Sie verwandte IronXL -Funktionen, die das Lesen von Dateien ergänzen:

• Excel-Dateien in C# schreiben und erstellen – Berichte und Datenexporte programmatisch erstellen
• Zellen, Zeilen und Spalten formatieren – Farben, Schriftarten und Rahmen im Code anwenden
• Mit Excel-Formeln in C# arbeiten – Formelzellen lesen und schreiben
• Excel in PDF umwandeln in .NET – PDF-Berichte aus Tabellendaten erstellen
• IronXL API-Dokumentation – vollständige Referenz aller Klassen und Methoden
• IronXL Lizenzierung und Preisgestaltung – Optionen für einzelne Entwickler und Enterprise
• IronXL NuGet-Seite – Installationsanleitung für alle Projekttypen
• IronXL-Tutorials – Schritt-für-Schritt-Anleitungen für häufige Anwendungsfälle
• Vergleichen Sie IronXL mit EPPlus – Seite-an-Seite-Vergleich von Funktionen und Lizenzen
• IronXL Produktseite – Funktionsübersicht und erste Schritte

Bei Fragen zur Lizenzierung, zur plattformübergreifenden Unterstützung oder zu spezifischen Dateiformatanforderungen steht Ihnen das IronXL Supportteam per Live-Chat und E-Mail zur Verfügung.

Erster Schritt:

Jetzt kostenlos starten