Wie man Excel-Dateien in C# mit IronXL liest

Wie installiert man IronXL für die Excel-Verarbeitung?

Öffnen Sie die NuGet Paket-Manager-Konsole in Visual Studio und führen Sie den folgenden Befehl aus, um IronXL zu Ihrem Projekt hinzuzufügen. Alternativ können Sie, falls Sie lieber über ein Terminal arbeiten, den in der zweiten Zeile gezeigten .NET CLI-Befehl verwenden:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Install-Package IronXl.Excel
dotnet add package IronXl.Excel

Das Paket installiert sich in Sekundenschnelle und fügt Ihrem Projekt einen einzelnen verwalteten Assemblyverweis hinzu. Keine COM-Registrierung, keine Office Primary Interop Assemblies und keine versionsspezifischen Excel-Abhängigkeiten, die verwaltet werden müssen.

Fügen Sie nach der Installation die using-Anweisung am Anfang jeder Datei hinzu, die mit Tabellendaten arbeitet:

using IronXL;

using IronXL;

Dieser einzelne Namespace ermöglicht Ihnen den Zugriff auf WorkBook, WorkSheet, Zellbereiche, typisierte Werteigenschaften, Aggregatfunktionen und alle anderen IronXL Typen. Die NuGet Gallery-Seite für IronXl.Excel listet alle verfügbaren Versionen und deren vollständigen Abhängigkeitsbaum auf.

Welche Excel-Dateiformate unterstützt IronXL ?

Das Verständnis der Formate, die Ihre Anwendung verarbeiten muss, beeinflusst sowohl die von Ihnen durchgeführten API-Aufrufe als auch die Speicherentscheidungen, die Ihr Projekt trifft.

XLSX – das Standardformat seit Excel 2007 – ist ein ZIP-Archiv von XML-Dateien. Es unterstützt mehr als eine Million Zeilen, umfangreiche Formatierungen, Pivot-Tabellen und benannte Bereiche. Die meisten modernen Datenpipelines erzeugen XLSX-Ausgabedateien, daher ist dies das Format, dem Sie am häufigsten begegnen werden.

XLS ist das ältere Binärformat, das von Excel 2003 und früheren Versionen verwendet wurde. Einige Unternehmenssysteme exportieren immer noch XLS-Dateien, daher ist eine zuverlässige Unterstützung dieses Formats bei der Integration mit älteren Infrastrukturen wichtig. IronXL liest XLS-Dateien ohne jegliche spezielle Konfiguration Ihrerseits.

XLSM erweitert XLSX um die Unterstützung von Makros. IronXL liest die Tabellendaten aus XLSM-Dateien auch dann, wenn der eingebettete VBA-Code nicht ausgeführt wird. Dies ist das korrekte Verhalten für die serverseitige Datenextraktion.

CSV und TSV sind einfache, tabellarische Textformate, die häufig für den Datenaustausch zwischen Systemen verwendet werden. WorkBook.LoadCSV verarbeitet kommagetrennte Dateien, und IronXL gibt dasselbe WorkBook-Objekt zurück, mit dem Ihr Code bereits umgehen kann, sodass Ihre Datenleselogik unabhängig vom Quellformat einheitlich bleibt.

IronXL erkennt das Dateiformat automatisch anhand der Dateierweiterung, wenn Sie WorkBook.Load aufrufen. In den meisten Fällen ist es nicht nötig, das Format explizit anzugeben, was den Code vereinfacht, der Eingaben aus mehreren Quellen verarbeiten muss.

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

Die Methode WorkBook.Load ist der Einstiegspunkt für alle dateibasierten Operationen. Übergeben Sie den Dateipfad, und IronXL gibt ein vollständig gefülltes Arbeitsmappenobjekt zurück, das Sie sofort abfragen können:

using IronXL;

// Load the workbook; format is detected automatically
WorkBook workbook = WorkBook.Load("Employees.xlsx");

// Access the first worksheet
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a single cell by A1 address
string companyName = sheet["A1"].StringValue;
Console.WriteLine($"Company: {companyName}");

// Access sheets by name or by zero-based index
WorkSheet byName  = workbook.GetWorkSheet("Sales");
WorkSheet byIndex = workbook.WorkSheets[1];

// Load a password-protected file
WorkBook secured = WorkBook.Load("Confidential.xlsx", "p@ssw0rd");

using IronXL;

// Load the workbook; format is detected automatically
WorkBook workbook = WorkBook.Load("Employees.xlsx");

// Access the first worksheet
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a single cell by A1 address
string companyName = sheet["A1"].StringValue;
Console.WriteLine($"Company: {companyName}");

// Access sheets by name or by zero-based index
WorkSheet byName  = workbook.GetWorkSheet("Sales");
WorkSheet byIndex = workbook.WorkSheets[1];

// Load a password-protected file
WorkBook secured = WorkBook.Load("Confidential.xlsx", "p@ssw0rd");

Die Eigenschaft DefaultWorkSheet gibt das erste Tabellenblatt zurück und deckt damit die Mehrheit der einseitigen Dateien ab. Wenn Ihre Datei mehrere Tabellenblätter enthält, ruft GetWorkSheet diese anhand des Namens ab und WorkSheets[n] diese anhand des nullbasierten Index. Die WorkBook-API-Referenz dokumentiert jede Überladung und Eigenschaft des Workbook-Objekts.

Wie liest man eingegebene Zellenwerte in Excel aus?

Jede Zelle in IronXL stellt typisierte Eigenschaften bereit, die Werte im exakt benötigten Datentyp zurückgeben – manuelles Parsen oder Casten ist nicht erforderlich. Die typisierten Eigenschaften handhaben die Typumwandlung von der zugrunde liegenden Zelldarstellung automatisch:

using IronXL;

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

// Extract typed values from row 2
int      employeeId = sheet["A2"].IntValue;
string   name       = sheet["B2"].StringValue;
string   department = sheet["C2"].StringValue;
decimal  salary     = sheet["D2"].DecimalValue;
DateTime hireDate   = sheet["E2"].DateTimeValue;

Console.WriteLine($"ID:         {employeeId}");
Console.WriteLine($"Name:       {name}");
Console.WriteLine($"Department: {department}");
Console.WriteLine($"Salary:     {salary:C}");
Console.WriteLine($"Hired:      {hireDate:d}");

// Use the Text property for the formatted display value
string formattedSalary = sheet["D2"].Text;   // "$75,000.00"
string formattedDate   = sheet["E2"].Text;   // "28/02/2026"

// Guard against empty cells before reading
if (!sheet["B3"].IsEmpty)
{
    string value = sheet["B3"].StringValue;
}

using IronXL;

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

// Extract typed values from row 2
int      employeeId = sheet["A2"].IntValue;
string   name       = sheet["B2"].StringValue;
string   department = sheet["C2"].StringValue;
decimal  salary     = sheet["D2"].DecimalValue;
DateTime hireDate   = sheet["E2"].DateTimeValue;

Console.WriteLine($"ID:         {employeeId}");
Console.WriteLine($"Name:       {name}");
Console.WriteLine($"Department: {department}");
Console.WriteLine($"Salary:     {salary:C}");
Console.WriteLine($"Hired:      {hireDate:d}");

// Use the Text property for the formatted display value
string formattedSalary = sheet["D2"].Text;   // "$75,000.00"
string formattedDate   = sheet["E2"].Text;   // "28/02/2026"

// Guard against empty cells before reading
if (!sheet["B3"].IsEmpty)
{
    string value = sheet["B3"].StringValue;
}

Die Eigenschaft Text gibt den Anzeigewert genau so zurück, wie er in Excel formatiert ist – nützlich, wenn Sie die formatierte Zahlenzeichenfolge und nicht die rohe Zahl benötigen. Für Zellen, die Excel-Formeln enthalten, wertet IronXL den Ausdruck aus und gibt das berechnete Ergebnis über die gleichen typisierten Eigenschaften zurück. Zusätzliche Werteigenschaften -- BoolValue, DoubleValue, FloatValue -- erscheinen in der Zellwertreferenz .

Wie iteriert man durch Excel-Zeilen und -Spalten?

Die Verarbeitung jedes Datensatzes erfordert das Durchlaufen der Zeilen und Spalten. Die Bereichssyntax von IronXL entspricht direkt der A1-Notation von Excel, sodass die Auswahl eines Zellblocks jedem vertraut ist, der schon einmal Tabellenkalkulationsformeln geschrieben hat:

using IronXL;

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

// Iterate a single column range
Console.WriteLine("Employee List:");
foreach (var cell in sheet["B2:B100"])
{
    if (!string.IsNullOrEmpty(cell.Text))
        Console.WriteLine($"  - {cell.Text}");
}

// Iterate all rows and all columns using the Rows property
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
        Console.Write(cell.Text.PadRight(15));
    Console.WriteLine();
}

using IronXL;

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

// Iterate a single column range
Console.WriteLine("Employee List:");
foreach (var cell in sheet["B2:B100"])
{
    if (!string.IsNullOrEmpty(cell.Text))
        Console.WriteLine($"  - {cell.Text}");
}

// Iterate all rows and all columns using the Rows property
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
        Console.Write(cell.Text.PadRight(15));
    Console.WriteLine();
}

Der Bereich sheet["B2:B100"] gibt eine aufzählbare Sammlung von Zellenobjekten zurück. Die Prüfung string.IsNullOrEmpty überspringt leere Zeilen problemlos. Die Eigenschaft Rows -- dokumentiert im Leitfaden für Arbeitsblattdatenbereiche - durchläuft das Blatt Zeile für Zeile und zeigt die Zellen jeder Zeile an, ohne dass Sie die Spaltenanzahl im Voraus kennen müssen.

Wie führt man Aggregatberechnungen mit Excel-Daten durch?

IronXL enthält integrierte Aggregatfunktionen , die Ergebnisse direkt auf Zellbereichen berechnen – manuelle Akkumulationsschleifen sind nicht erforderlich:

using IronXL;

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

// Built-in aggregate methods work on any named range
decimal total   = sheet["D2:D200"].Sum();
decimal highest = sheet["D2:D200"].Max();
decimal lowest  = sheet["D2:D200"].Min();
decimal average = sheet["D2:D200"].Avg();

Console.WriteLine($"Total Payroll:  {total:C}");
Console.WriteLine($"Highest Salary: {highest:C}");
Console.WriteLine($"Lowest Salary:  {lowest:C}");
Console.WriteLine($"Average Salary: {average:C}");

// Combine with LINQ for filtered aggregation
decimal itTotal = sheet["D2:D200"]
    .Where(c => sheet[$"C{c.RowIndex}"].StringValue == "IT")
    .Sum(c => c.DecimalValue);
Console.WriteLine($"IT Department Total: {itTotal:C}");

using IronXL;

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

// Built-in aggregate methods work on any named range
decimal total   = sheet["D2:D200"].Sum();
decimal highest = sheet["D2:D200"].Max();
decimal lowest  = sheet["D2:D200"].Min();
decimal average = sheet["D2:D200"].Avg();

Console.WriteLine($"Total Payroll:  {total:C}");
Console.WriteLine($"Highest Salary: {highest:C}");
Console.WriteLine($"Lowest Salary:  {lowest:C}");
Console.WriteLine($"Average Salary: {average:C}");

// Combine with LINQ for filtered aggregation
decimal itTotal = sheet["D2:D200"]
    .Where(c => sheet[$"C{c.RowIndex}"].StringValue == "IT")
    .Sum(c => c.DecimalValue);
Console.WriteLine($"IT Department Total: {itTotal:C}");

Sum, Min, Max und Avg überspringen automatisch leere Zellen und führen die numerische Konvertierung im Hintergrund durch. Durch die Verkettung von LINQ-Abfragen auf den Bereich erhalten Sie gefilterte Aggregate – Abteilungs-Zwischensummen, Datumsbereichssummen und bedingte Zählungen – alles ohne die IronXL API zu verlassen.

Wie erstellt man einen vollständigen Mitarbeiterdatenleser?

Das folgende Beispiel fasst alle bisher behandelten Punkte in einer produktionsreifen Konsolenanwendung zusammen, die eine Mitarbeitertabelle lädt, jeden Datensatz formatiert, die Gehaltssummen summiert, das Zurückschreiben von Daten verarbeitet und Fehler elegant abfängt:

using IronXL;

try
{
    WorkBook workbook = WorkBook.Load("Employees.xlsx");
    WorkSheet sheet   = workbook.DefaultWorkSheet;

    Console.WriteLine("=== Employee Data Report ===\n");

    int     rowNumber     = 2;
    decimal totalSalary   = 0m;
    int     employeeCount = 0;

    while (!string.IsNullOrEmpty(sheet[$"A{rowNumber}"].StringValue))
    {
        int      id         = sheet[$"A{rowNumber}"].IntValue;
        string   name       = sheet[$"B{rowNumber}"].StringValue;
        string   department = sheet[$"C{rowNumber}"].StringValue;
        decimal  salary     = sheet[$"D{rowNumber}"].DecimalValue;

        Console.WriteLine($"{id,4}  {name,-20}  {department,-15}  {salary,10:C}");

        totalSalary   += salary;
        employeeCount += 1;
        rowNumber     += 1;
    }

    Console.WriteLine($"\nTotal Employees: {employeeCount}");
    Console.WriteLine($"Total Payroll:   {totalSalary:C}");

    // Write a new record back to the sheet and save
    sheet["A10"].Value = 1010;
    sheet["B10"].Value = "Jane Doe";
    sheet["C10"].Value = "Finance";
    sheet["D10"].Value = 75000;
    workbook.SaveAs("Employees-Updated.xlsx");
}
catch (Exception ex)
{
    Console.WriteLine($"Error reading Excel file: {ex.Message}");
}

using IronXL;

try
{
    WorkBook workbook = WorkBook.Load("Employees.xlsx");
    WorkSheet sheet   = workbook.DefaultWorkSheet;

    Console.WriteLine("=== Employee Data Report ===\n");

    int     rowNumber     = 2;
    decimal totalSalary   = 0m;
    int     employeeCount = 0;

    while (!string.IsNullOrEmpty(sheet[$"A{rowNumber}"].StringValue))
    {
        int      id         = sheet[$"A{rowNumber}"].IntValue;
        string   name       = sheet[$"B{rowNumber}"].StringValue;
        string   department = sheet[$"C{rowNumber}"].StringValue;
        decimal  salary     = sheet[$"D{rowNumber}"].DecimalValue;

        Console.WriteLine($"{id,4}  {name,-20}  {department,-15}  {salary,10:C}");

        totalSalary   += salary;
        employeeCount += 1;
        rowNumber     += 1;
    }

    Console.WriteLine($"\nTotal Employees: {employeeCount}");
    Console.WriteLine($"Total Payroll:   {totalSalary:C}");

    // Write a new record back to the sheet and save
    sheet["A10"].Value = 1010;
    sheet["B10"].Value = "Jane Doe";
    sheet["C10"].Value = "Finance";
    sheet["D10"].Value = 75000;
    workbook.SaveAs("Employees-Updated.xlsx");
}
catch (Exception ex)
{
    Console.WriteLine($"Error reading Excel file: {ex.Message}");
}

Die while Schleife wird beendet, sobald Spalte A leer ist. Dadurch kann der Reader Tabellenkalkulationen beliebiger Länge verarbeiten, ohne dass eine fest codierte Zeilenanzahl erforderlich ist. Das Zurückschreiben der Werte erfolgt nach der gleichen Zelladressensyntax wie das Lesen, und SaveAs speichert die Änderungen in einer neuen Datei, sodass das Original unberührt bleibt. Der try/catch Block behandelt fehlende Dateien, gesperrte Arbeitsmappen und beschädigte Daten – alles Szenarien, die in Produktionsumgebungen auftreten, in denen Eingabedateien von externen Quellen stammen.

Wie gehen Sie mit anspruchsvollen Lesesituationen um?

In realen Projekten treten mehrere weniger häufige, aber wichtige Szenarien auf. Benannte Bereiche, die Suche nach Arbeitsblättern und das Laden von CSV-Dateien verfügen jeweils über eine eigene API-Unterstützung.

Benannte Bereiche ermöglichen es Ihnen, Daten über eine logische Bezeichnung anstatt über eine Zellenadresse zu referenzieren. Wenn der Autor der Arbeitsmappe einen benannten Bereich mit der Bezeichnung SalaryTable definiert hat, können Sie direkt über GetRangeByName darauf zugreifen:

var range = workbook.GetRangeByName("SalaryTable");
decimal total = range.Sum();
Console.WriteLine($"Named range total: {total:C}");

var range = workbook.GetRangeByName("SalaryTable");
decimal total = range.Sum();
Console.WriteLine($"Named range total: {total:C}");

Die Arbeitsblatterkennung listet jedes Blatt in der Arbeitsmappe auf, was beim Verarbeiten von Dateien mit einer variablen Anzahl von Registerkarten hilfreich ist:

foreach (WorkSheet ws in workbook.WorkSheets)
    Console.WriteLine($"Sheet: {ws.Name}, Rows: {ws.RowCount}");

foreach (WorkSheet ws in workbook.WorkSheets)
    Console.WriteLine($"Sheet: {ws.Name}, Rows: {ws.RowCount}");

Das Laden von CSV-Dateien erfolgt über eine spezielle, für Klartextdateien optimierte Methode, die einen WorkSheet-Wert zurückgibt. Die Navigation erfolgt über dieselbe Bereichs-API:

WorkBook csv    = WorkBook.LoadCSV("data.csv");
WorkSheet first = csv.DefaultWorkSheet;
Console.WriteLine(first["A1"].StringValue);

WorkBook csv    = WorkBook.LoadCSV("data.csv");
WorkSheet first = csv.DefaultWorkSheet;
Console.WriteLine(first["A1"].StringValue);

Diese Muster decken die fortgeschrittenen Leseszenarien ab, die in Datenmigrationsprojekten, ETL-Pipelines und automatisierten Berichtssystemen auftreten. Die vollständige API-Oberfläche finden Sie in der IronXL Objektreferenz .

Weitere maßgebliche Quellen:

• IronXL Dokumentationsstartseite
• So bearbeiten Sie Excel-Formeln
• Wie man mit mathematischen Funktionen arbeitet
• So wählen Sie Bereiche aus
• ECMA-376 Open XML-Spezifikation – der maßgebliche Standard zur Definition des XLSX-Formats
• Microsoft Open XML SDK-Dokumentation – Referenzmaterial zur zugrunde liegenden Dateistruktur
• NuGet Galerie -- IronXl.Excel -- Paketseite mit Versionsverlauf und Downloadstatistiken

Was sind Ihre nächsten Schritte?

IronXL macht aus einer komplexen Interop-Herausforderung mit vielen Abhängigkeiten ein Excel-Datei-Lesen wenige Zeilen unkomplizierten C#-Code. Das Laden von Arbeitsmappen, das Extrahieren typisierter Werte, das Iterieren Zeile für Zeile, das Ausführen von Aggregatberechnungen und die Behandlung von Sonderfällen folgen alle dem gleichen konsistenten API-Muster – ohne dass Microsoft Office irgendwo in Ihrer Bereitstellungsumgebung installiert sein muss.

Vom Tutorial zur Produktion:

1. Starten Sie eine kostenlose Testphase , um den vollen Funktionsumfang von IronXL freizuschalten und ihn anhand Ihrer eigenen Excel-Dateien zu überprüfen, bevor Sie eine Lizenz erwerben.
2. In der vollständigen IronXL Dokumentation finden Sie Anleitungen zum Schreiben, Formatieren, Gestalten und Konvertieren von Tabellenkalkulationen.
3. Erkunden Sie die Objektreferenz und die vollständige API , um alle in der Bibliothek verfügbaren Klassen, Methoden und Eigenschaften zu entdecken.
4. Lesen Sie die Anleitung zum Erstellen von Tabellenkalkulationen, wenn Ihr Arbeitsablauf das Generieren von Ausgabedateien sowie das Lesen von Eingabedateien erfordert.
5. Im Blogbeitragsindex von IronXL finden Sie weitere Anleitungen zu realen Anwendungsfällen wie Berichtserstellung, Datenvalidierung und Konsolidierung mehrerer Tabellenblätter.