Wie man eine Excel-Datei in C# ohne Microsoft Office öffnet

Wie installiert man IronXL in einem .NET -Projekt?

Der Einstieg dauert nur wenige Sekunden. Öffnen Sie Ihr Projekt und verwenden Sie einen der folgenden Paketmanager:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Alternativ können Sie Visual Studio öffnen, mit der rechten Maustaste auf Ihr Projekt klicken, " NuGet Pakete verwalten" auswählen, nach "IronXL" suchen und auf "Installieren" klicken. Die Installationsanleitung deckt alle unterstützten Umgebungen ab, einschließlich Docker und Azure.

Nach der Installation fügen Sie den Namespace am Anfang Ihrer Datei hinzu:

using IronXL;

using IronXL;

Imports IronXL

Dieser eine Satz genügt. Es gibt keine komplexen COM-Referenzen, keine Office-Abhängigkeiten und keine versionsspezifischen Assemblys. Für einen kostenlosen Testschlüssel besuchen Sie die IronXL Testlizenzseite .

Wie öffnet man eine Excel-Arbeitsmappe und liest Zellwerte aus?

Die Kern-API ist unkompliziert. Laden Sie eine Arbeitsmappe, wählen Sie ein Arbeitsblatt aus und greifen Sie über die Adresse oder durch Iteration auf Zellen zu.

using IronXL;

// Load any Excel file -- XLSX, XLS, CSV, or TSV
WorkBook workbook = WorkBook.Load("example.xlsx");

// Access the second worksheet (zero-indexed)
WorkSheet worksheet = workbook.WorkSheets[1];

// Read a specific cell value
decimal revenue = worksheet["E2"].DecimalValue;
Console.WriteLine($"Order Total: {revenue}");

// Iterate over a range of cells
foreach (var cell in worksheet["C2:C6"])
{
    Console.WriteLine($"Product: {cell.Text}");
}

using IronXL;

// Load any Excel file -- XLSX, XLS, CSV, or TSV
WorkBook workbook = WorkBook.Load("example.xlsx");

// Access the second worksheet (zero-indexed)
WorkSheet worksheet = workbook.WorkSheets[1];

// Read a specific cell value
decimal revenue = worksheet["E2"].DecimalValue;
Console.WriteLine($"Order Total: {revenue}");

// Iterate over a range of cells
foreach (var cell in worksheet["C2:C6"])
{
    Console.WriteLine($"Product: {cell.Text}");
}

Imports IronXL

' Load any Excel file -- XLSX, XLS, CSV, or TSV
Dim workbook As WorkBook = WorkBook.Load("example.xlsx")

' Access the second worksheet (zero-indexed)
Dim worksheet As WorkSheet = workbook.WorkSheets(1)

' Read a specific cell value
Dim revenue As Decimal = worksheet("E2").DecimalValue
Console.WriteLine($"Order Total: {revenue}")

' Iterate over a range of cells
For Each cell In worksheet("C2:C6")
    Console.WriteLine($"Product: {cell.Text}")
Next

WorkBook.Load() erkennt automatisch das Dateiformat - Sie müssen nicht angeben, ob es sich um eine XLS- oder XLSX-Datei handelt. Greifen Sie auf die Arbeitsblätter über den Index oder den Namen zu, indem Sie workbook.GetWorkSheet("Sheet1") verwenden. Jede Zelle stellt typisierte Eigenschaften wie IntValue, DecimalValue, Datum/UhrzeitValue und Text dar.

Weitere Optionen zum Öffnen von Dateien finden Sie in der Anleitung zum Öffnen von Arbeitsmappen.

using IronXL;

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

// Access worksheet by exact name
WorkSheet salesSheet = workbook.GetWorkSheet("Sales Data");
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}");

// Iterate all worksheets in the workbook
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    if (sheet.Name.Contains("Inventory"))
    {
        Console.WriteLine($"Found inventory sheet: {sheet.Name}");
    }
}

using IronXL;

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

// Access worksheet by exact name
WorkSheet salesSheet = workbook.GetWorkSheet("Sales Data");
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}");

// Iterate all worksheets in the workbook
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    if (sheet.Name.Contains("Inventory"))
    {
        Console.WriteLine($"Found inventory sheet: {sheet.Name}");
    }
}

Imports IronXL

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

' Access worksheet by exact name
Dim salesSheet As WorkSheet = workbook.GetWorkSheet("Sales Data")
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}")

' Iterate all worksheets in the workbook
For Each sheet As WorkSheet In workbook.WorkSheets
    If sheet.Name.Contains("Inventory") Then
        Console.WriteLine($"Found inventory sheet: {sheet.Name}")
    End If
Next

Wie liest man verschiedene Datentypen aus Excel-Zellen?

IronXL stellt typisierte Zugriffsmethoden für jeden gängigen Excel-Datentyp bereit. Sie können Zeichenketten, ganze Zahlen, Dezimalzahlen, Datumsangaben, boolesche Werte und Formelergebnisse ohne manuelle Analyse einlesen.

using IronXL;

WorkBook wb = WorkBook.Load(@"C:\Data\Inventory.xlsx");
WorkSheet ws = wb.GetWorkSheet("Products");

// Read different data types directly
zeichenfolge productName = ws["A2"].StringValue;
int quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
Datum/Uhrzeit updated   = ws["D2"].Datum/UhrzeitValue;

// Use aggregate functions on ranges for performance
decimal totalStock = ws["B2:B100"].Sum();
decimal maxPrice   = ws["C2:C100"].Max();

Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}");

using IronXL;

WorkBook wb = WorkBook.Load(@"C:\Data\Inventory.xlsx");
WorkSheet ws = wb.GetWorkSheet("Products");

// Read different data types directly
zeichenfolge productName = ws["A2"].StringValue;
int quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
Datum/Uhrzeit updated   = ws["D2"].Datum/UhrzeitValue;

// Use aggregate functions on ranges for performance
decimal totalStock = ws["B2:B100"].Sum();
decimal maxPrice   = ws["C2:C100"].Max();

Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}");

Imports IronXL

Dim wb As WorkBook = WorkBook.Load("C:\Data\Inventory.xlsx")
Dim ws As WorkSheet = wb.GetWorkSheet("Products")

' Read different data types directly
Dim productName As String = ws("A2").StringValue
Dim quantity As Integer = ws("B2").IntValue
Dim price As Decimal = ws("C2").DecimalValue
Dim updated As DateTime = ws("D2").DateTimeValue

' Use aggregate functions on ranges for performance
Dim totalStock As Decimal = ws("B2:B100").Sum()
Dim maxPrice As Decimal = ws("C2:C100").Max()

Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}")
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}")

Die folgende Tabelle fasst die verfügbaren typisierten Zugriffsmethoden zusammen:

Ausführliche Informationen zum Lesen und Schreiben von Zelldaten finden Sie im Leitfaden zur Zellformatierung und in der Anleitung zum Importieren von Daten.

using IronXL;

WorkBook workbook = WorkBook.Load("data.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;

// Check if a cell is empty before reading
if (!ws["A1"].IsEmpty)
{
    Console.WriteLine(ws["A1"].StringValue);
}

// Provide a fallback value using a null-coalescing pattern
zeichenfolge cellText = ws["A1"].StringValue ?? "Default Value";

// Iterate a range and skip empty cells
foreach (var cell in ws["A1:A20"])
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine(cell.Text);
    }
}

using IronXL;

WorkBook workbook = WorkBook.Load("data.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;

// Check if a cell is empty before reading
if (!ws["A1"].IsEmpty)
{
    Console.WriteLine(ws["A1"].StringValue);
}

// Provide a fallback value using a null-coalescing pattern
zeichenfolge cellText = ws["A1"].StringValue ?? "Default Value";

// Iterate a range and skip empty cells
foreach (var cell in ws["A1:A20"])
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine(cell.Text);
    }
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Check if a cell is empty before reading
If Not ws("A1").IsEmpty Then
    Console.WriteLine(ws("A1").StringValue)
End If

' Provide a fallback value using a null-coalescing pattern
Dim cellText As String = If(ws("A1").StringValue, "Default Value")

' Iterate a range and skip empty cells
For Each cell In ws("A1:A20")
    If Not cell.IsEmpty Then
        Console.WriteLine(cell.Text)
    End If
Next

Wie entwickelt man einen produktionsreifen Excel-Reader?

Ein Excel-Reader für den praktischen Einsatz benötigt Dateivalidierung, Fehlerbehandlung, Unterstützung für mehrere Tabellenblätter und optionale Ausgabegenerierung. Das folgende Beispiel veranschaulicht all diese Muster in einer einzigen Klasse:

using IronXL;
using System.IO;

// Validate and load the file
static List<zeichenfolge> CheckLowStock(zeichenfolge filePath)
{
    var lowStockItems = new List<zeichenfolge>();

    if (!File.Exists(filePath))
    {
        Console.WriteLine($"File not found: {filePath}");
        return lowStockItems;
    }

    zeichenfolge ext = Path.GetExtension(filePath).ToLower();
    if (ext is not (".xlsx" or ".xls" or ".csv"))
    {
        Console.WriteLine($"Unsupported file type: {ext}");
        return lowStockItems;
    }

    try
    {
        WorkBook workbook = WorkBook.Load(filePath);

        foreach (WorkSheet sheet in workbook.WorkSheets)
        {
            Console.WriteLine($"Checking sheet: {sheet.Name}");

            for (int row = 2; row <= sheet.RowCount; row++)
            {
                zeichenfolge itemName  = sheet[$"A{row}"].StringValue;
                int stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !zeichenfolge.IsNullOrEmpty(itemName))
                {
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})");
                }
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error reading Excel file: {ex.Message}");
    }

    return lowStockItems;
}

// Export results to a new workbook
static void ExportReport(List<zeichenfolge> items, zeichenfolge outputPath)
{
    WorkBook report     = WorkBook.Create();
    WorkSheet sheet     = report.CreateWorkSheet("Low Stock Report");

    sheet["A1"].Value   = "Item Description";
    sheet["B1"].Value   = "Source Sheet";

    sheet["A1:B1"].Style.Font.Bold        = true;
    sheet["A1:B1"].Style.BackgroundColor  = "#4472C4";
    sheet["A1:B1"].Style.Font.Color       = "#FFFFFF";

    int rowIndex = 2;
    foreach (zeichenfolge item in items)
    {
        sheet[$"A{rowIndex}"].Value = item;
        rowIndex++;
    }

    report.SaveAs(outputPath);
    Console.WriteLine($"Report saved to: {outputPath}");
}

// Run
var lowStockItems = CheckLowStock("inventory.xlsx");
ExportReport(lowStockItems, "low-stock-report.xlsx");

using IronXL;
using System.IO;

// Validate and load the file
static List<zeichenfolge> CheckLowStock(zeichenfolge filePath)
{
    var lowStockItems = new List<zeichenfolge>();

    if (!File.Exists(filePath))
    {
        Console.WriteLine($"File not found: {filePath}");
        return lowStockItems;
    }

    zeichenfolge ext = Path.GetExtension(filePath).ToLower();
    if (ext is not (".xlsx" or ".xls" or ".csv"))
    {
        Console.WriteLine($"Unsupported file type: {ext}");
        return lowStockItems;
    }

    try
    {
        WorkBook workbook = WorkBook.Load(filePath);

        foreach (WorkSheet sheet in workbook.WorkSheets)
        {
            Console.WriteLine($"Checking sheet: {sheet.Name}");

            for (int row = 2; row <= sheet.RowCount; row++)
            {
                zeichenfolge itemName  = sheet[$"A{row}"].StringValue;
                int stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !zeichenfolge.IsNullOrEmpty(itemName))
                {
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})");
                }
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error reading Excel file: {ex.Message}");
    }

    return lowStockItems;
}

// Export results to a new workbook
static void ExportReport(List<zeichenfolge> items, zeichenfolge outputPath)
{
    WorkBook report     = WorkBook.Create();
    WorkSheet sheet     = report.CreateWorkSheet("Low Stock Report");

    sheet["A1"].Value   = "Item Description";
    sheet["B1"].Value   = "Source Sheet";

    sheet["A1:B1"].Style.Font.Bold        = true;
    sheet["A1:B1"].Style.BackgroundColor  = "#4472C4";
    sheet["A1:B1"].Style.Font.Color       = "#FFFFFF";

    int rowIndex = 2;
    foreach (zeichenfolge item in items)
    {
        sheet[$"A{rowIndex}"].Value = item;
        rowIndex++;
    }

    report.SaveAs(outputPath);
    Console.WriteLine($"Report saved to: {outputPath}");
}

// Run
var lowStockItems = CheckLowStock("inventory.xlsx");
ExportReport(lowStockItems, "low-stock-report.xlsx");

Imports IronXL
Imports System.IO

' Validate and load the file
Private Shared Function CheckLowStock(filePath As String) As List(Of String)
    Dim lowStockItems As New List(Of String)()

    If Not File.Exists(filePath) Then
        Console.WriteLine($"File not found: {filePath}")
        Return lowStockItems
    End If

    Dim ext As String = Path.GetExtension(filePath).ToLower()
    If ext <> ".xlsx" AndAlso ext <> ".xls" AndAlso ext <> ".csv" Then
        Console.WriteLine($"Unsupported file type: {ext}")
        Return lowStockItems
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Load(filePath)

        For Each sheet As WorkSheet In workbook.WorkSheets
            Console.WriteLine($"Checking sheet: {sheet.Name}")

            For row As Integer = 2 To sheet.RowCount
                Dim itemName As String = sheet($"A{row}").StringValue
                Dim stockLevel As Integer = sheet($"B{row}").IntValue

                If stockLevel < 10 AndAlso Not String.IsNullOrEmpty(itemName) Then
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})")
                End If
            Next
        Next
    Catch ex As Exception
        Console.WriteLine($"Error reading Excel file: {ex.Message}")
    End Try

    Return lowStockItems
End Function

' Export results to a new workbook
Private Shared Sub ExportReport(items As List(Of String), outputPath As String)
    Dim report As WorkBook = WorkBook.Create()
    Dim sheet As WorkSheet = report.CreateWorkSheet("Low Stock Report")

    sheet("A1").Value = "Item Description"
    sheet("B1").Value = "Source Sheet"

    sheet("A1:B1").Style.Font.Bold = True
    sheet("A1:B1").Style.BackgroundColor = "#4472C4"
    sheet("A1:B1").Style.Font.Color = "#FFFFFF"

    Dim rowIndex As Integer = 2
    For Each item As String In items
        sheet($"A{rowIndex}").Value = item
        rowIndex += 1
    Next

    report.SaveAs(outputPath)
    Console.WriteLine($"Report saved to: {outputPath}")
End Sub

' Run
Dim lowStockItems = CheckLowStock("inventory.xlsx")
ExportReport(lowStockItems, "low-stock-report.xlsx")

Dieses Beispiel verwendet Anweisungen auf oberster Ebene und deckt den gesamten Arbeitsablauf ab: Überprüfen des Dateipfads und der Dateierweiterung, Laden der Arbeitsmappe, Durchlaufen aller Arbeitsblätter, Anwenden der Geschäftslogik und Schreiben der Ergebnisse in eine neue Datei. Weitere Informationen zum Schreiben und Speichern von Arbeitsmappen finden Sie im Leitfaden zum Schreiben von Excel-Dateien und in der Anleitung zum Exportieren von Excel-Dateien.

Beachten Sie, dass die Methode ExportReport eine neue Arbeitsmappe mit WorkBook.Create() erstellt, anstatt die Quelldatei zu ändern. Quell- und Ausgabedateien getrennt zu halten, ist eine gute Praxis für Prüfpfade und vermeidet das versehentliche Überschreiben von Daten, von denen andere Prozesse abhängen. Wenn Sie stattdessen Daten an eine bestehende Arbeitsmappe anhängen müssen, laden Sie sie mit WorkBook.Load(), fügen Sie Zeilen zum entsprechenden Arbeitsblatt hinzu und rufen Sie SaveAs() zu einem neuen Pfad auf oder überschreiben Sie an Ort und Stelle.

using IronXL;

WorkBook workbook = WorkBook.Load("large-dataset.xlsx");
WorkSheet ws      = workbook.DefaultWorkSheet;

// Fast: aggregate functions operate on the range directly
decimal total   = ws["B2:B5000"].Sum();
decimal average = ws["B2:B5000"].Avg();
int count       = ws["B2:B5000"].Count();

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}");

// Export the worksheet to a DataSet for LINQ or database operations
var dataSet = workbook.ToDataSet();
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}");

using IronXL;

WorkBook workbook = WorkBook.Load("large-dataset.xlsx");
WorkSheet ws      = workbook.DefaultWorkSheet;

// Fast: aggregate functions operate on the range directly
decimal total   = ws["B2:B5000"].Sum();
decimal average = ws["B2:B5000"].Avg();
int count       = ws["B2:B5000"].Count();

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}");

// Export the worksheet to a DataSet for LINQ or database operations
var dataSet = workbook.ToDataSet();
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("large-dataset.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Fast: aggregate functions operate on the range directly
Dim total As Decimal = ws("B2:B5000").Sum()
Dim average As Decimal = ws("B2:B5000").Avg()
Dim count As Integer = ws("B2:B5000").Count()

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}")

' Export the worksheet to a DataSet for LINQ or database operations
Dim dataSet = workbook.ToDataSet()
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}")

Wie erhält man eine Lizenz und wie stellt man die Anwendung in der Produktionsumgebung bereit?

IronXL ist eine kommerzielle Bibliothek mit einer kostenlosen Testversion, die während der Entwicklung und des Testens volle Funktionalität bietet. Für den Einsatz in Produktionsumgebungen benötigen Sie einen gültigen Lizenzschlüssel. Details zu den Lizenzstufen, einschließlich Entwickler-, Team- und Enterprise , finden Sie auf der IronXL -Lizenzseite .

Um einen Lizenzschlüssel anzuwenden, muss dieser vor jedem IronXL Aufruf festgelegt werden:

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Die IronXL -Funktionsübersicht fasst alle Funktionen zusammen, vom Lesen und Schreiben von Dateien über das Erstellen von Diagrammen und das Anwenden bedingter Formatierungen bis hin zum Arbeiten mit benannten Bereichen. Die Anleitung zum Erstellen von Excel-Dateien und die Anleitung zum Zusammenführen von Zellen sind nützliche Ausgangspunkte für das Erstellen neuer Arbeitsmappen.

Für Diskussionen und Fragen aus der Community zur C#-Excel-Automatisierung sind die Microsoft Q&A-Foren und Stack Overflow gute Anlaufstellen. Die offizielle NuGet Paketseite bietet Versionsverlauf und Downloadstatistiken.

Was sind die wichtigsten Erkenntnisse zum Öffnen von Excel-Dateien in C#?

IronXL beseitigt die Abhängigkeit von Microsoft Office vollständig und ermöglicht so die praktische Verarbeitung von Excel-Dateien auf Servern, in Containern und in Cloud-Funktionen. Die API folgt einem einfachen Muster: Laden einer Arbeitsmappe, Zugriff auf Arbeitsblätter über Namen oder Index und Lesen von Zellen mithilfe typisierter Zugriffsmethoden. Aggregatfunktionen wie Sum(), Avg() und Max() verarbeiten große Datenmengen ohne den Overhead einer manuellen Iteration.

Die Bibliothek unterstützt die Formate XLSX, XLS, CSV und TSV, läuft unter .NET 10 und allen neueren .NET Versionen und ist plattformübergreifend einsetzbar. Die Fehlerbehandlung ist unkompliziert, da IronXL standardmäßige .NET-Ausnahmen auslöst, die Sie mit den bekannten try/catch-Mustern abfangen können - es müssen keine COM-Interop-Fehlercodes dekodiert werden. Um alle verfügbaren Optionen zu erkunden, beginnen Sie mit der IronXL-Dokumentationsseite oder probieren Sie die Anleitung zur offenen Arbeitsmappe als Schritt-für-Schritt-Referenz aus.

Starten Sie eine kostenlose Testversion von IronXL , um die Bibliothek in Ihren eigenen Projekten unverbindlich zu evaluieren.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten