Das Einlesen von Excel-Dateien in C#-Anwendungen ist eine wiederkehrende Anforderung für Unternehmenssoftware, Datenverarbeitungspipelines und Berichtssysteme. Herkömmliche Ansätze mit Microsoft Office Interop erfordern die Installation von Excel auf jedem Server oder jeder Workstation, wodurch brüchige Abhängigkeiten entstehen, die die Bereitstellung und Lizenzierung erschweren. IronXL beseitigt diese Abhängigkeit vollständig – Ihre Anwendung liest XLSX-, XLS-, CSV- und andere Tabellenkalkulationsformate, ohne dass Office irgendwo in der Umgebung installiert sein muss.
Dieses Tutorial führt Sie durch alle notwendigen Techniken: Installation der Bibliothek, Laden von Arbeitsmappen, Extrahieren von typisierten Zellwerten, Iterieren über Zeilen und Spalten, Ausführen von Aggregatberechnungen und Erstellen eines vollständigen Mitarbeiterdatenlesers. Alle Beispiele verwenden C# mit Anweisungen auf oberster Ebene, die auf .NET 10 abzielen.
Ö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:
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;Imports IronXLDieser einzelne Namespace gibt Ihnen Zugriff auf WorkBook, WorkSheet, Zellbereiche, typisierte Werteigenschaften, Aggregatfunktionen und jeden anderen IronXL-Typ. Die NuGet Gallery-Seite für IronXL.Excel listet alle verfügbaren Versionen und deren vollständigen Abhängigkeitsbaum auf.
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 Enterprise 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 durch Kommas getrennte Dateien, und IronXL gibt dasselbe WorkBook-Objekt zurück, das Ihr Code bereits zu navigieren weiß, und hält so Ihre Datenleselogik unabhängig vom Quellformat einheitlich.
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.
| Format | Verlängerung | Load-Methode | Anmerkungen |
|---|---|---|---|
| Open XML-Arbeitsmappe | .xlsx | WorkBook.Load | Standardmäßiges modernes Format |
| Legacy-Binär | .xls | WorkBook.Load | Excel 2003 und früher |
| Makro-fähig | .xlsm | WorkBook.Load | Daten gelesen; Makros nicht ausgeführt |
| durch Komma getrennt | .csv | WorkBook.LoadCSV | Optimierter CSV-Parser |
| durch Tabulatoren getrennt | .tsv | WorkBook.Load | Tabulator-Trennzeichenvariante |
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");Imports IronXL
' Load the workbook; format is detected automatically
Dim workbook As WorkBook = WorkBook.Load("Employees.xlsx")
' Access the first worksheet
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read a single cell by A1 address
Dim companyName As String = sheet("A1").StringValue
Console.WriteLine($"Company: {companyName}")
' Access sheets by name or by zero-based index
Dim byName As WorkSheet = workbook.GetWorkSheet("Sales")
Dim byIndex As WorkSheet = workbook.WorkSheets(1)
' Load a password-protected file
Dim secured As WorkBook = WorkBook.Load("Confidential.xlsx", "p@ssw0rd")Die Eigenschaft DefaultWorkSheet gibt das erste Blatt zurück, das den Großteil der Einblattdateien abdeckt. Wenn Ihre Datei mehrere Blätter enthält, ruft GetWorkSheet sie nach Name ab und WorkSheets[n] nach null-basiertem Index. Die WorkBook-API-Referenz dokumentiert jede Überladung und Eigenschaft des Workbook-Objekts.
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;
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("Employees.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Extract typed values from row 2
Dim employeeId As Integer = sheet("A2").IntValue
Dim name As String = sheet("B2").StringValue
Dim department As String = sheet("C2").StringValue
Dim salary As Decimal = sheet("D2").DecimalValue
Dim hireDate As DateTime = 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
Dim formattedSalary As String = sheet("D2").Text ' "$75,000.00"
Dim formattedDate As String = sheet("E2").Text ' "28/02/2026"
' Guard against empty cells before reading
If Not sheet("B3").IsEmpty Then
Dim value As String = sheet("B3").StringValue
End IfDie Eigenschaft Text gibt den Anzeigewert genau so zurück, wie er in Excel formatiert ist - nützlich, wenn Sie die formatierte Zahlenzeichenfolge benötigen, anstelle der rohen numerischen. 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 Zellwert-Referenz.
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();
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("Employees.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Iterate a single column range
Console.WriteLine("Employee List:")
For Each cell In sheet("B2:B100")
If Not String.IsNullOrEmpty(cell.Text) Then
Console.WriteLine($" - {cell.Text}")
End If
Next
' Iterate all rows and all columns using the Rows property
For Each row In sheet.Rows
For Each cell In row
Console.Write(cell.Text.PadRight(15))
Next
Console.WriteLine()
NextDer Bereich sheet["B2:B100"] gibt eine aufzählbare Sammlung von Zellobjekten zurück. Die Prüfung von string.IsNullOrEmpty überspringt elegant leere Zeilen. Die Eigenschaft Rows -- dokumentiert im Leitfaden für Bereiche des Arbeitsblatts -- durchläuft das Blatt zeilenweise und stellt die Zellen jeder Zeile bereit, ohne dass Sie die Spaltenanzahl im Voraus wissen müssen.
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}");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("Employees.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Built-in aggregate methods work on any named range
Dim total As Decimal = sheet("D2:D200").Sum()
Dim highest As Decimal = sheet("D2:D200").Max()
Dim lowest As Decimal = sheet("D2:D200").Min()
Dim average As Decimal = 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
Dim itTotal As Decimal = sheet("D2:D200") _
.Where(Function(c) sheet($"C{c.RowIndex}").StringValue = "IT") _
.Sum(Function(c) c.DecimalValue)
Console.WriteLine($"IT Department Total: {itTotal:C}")Sum, Min, Max und Avg überspringen automatisch leere Zellen und behandeln die numerische Konvertierung im Hintergrund. 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.
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}");
}Imports IronXL
Try
Dim workbook As WorkBook = WorkBook.Load("Employees.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine("=== Employee Data Report ===" & vbCrLf)
Dim rowNumber As Integer = 2
Dim totalSalary As Decimal = 0D
Dim employeeCount As Integer = 0
While Not String.IsNullOrEmpty(sheet($"A{rowNumber}").StringValue)
Dim id As Integer = sheet($"A{rowNumber}").IntValue
Dim name As String = sheet($"B{rowNumber}").StringValue
Dim department As String = sheet($"C{rowNumber}").StringValue
Dim salary As Decimal = sheet($"D{rowNumber}").DecimalValue
Console.WriteLine($"{id,4} {name,-20} {department,-15} {salary,10:C}")
totalSalary += salary
employeeCount += 1
rowNumber += 1
End While
Console.WriteLine(vbCrLf & $"Total 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 ex As Exception
Console.WriteLine($"Error reading Excel file: {ex.Message}")
End TryDie while Schleife wird beendet, wenn die Spalte A leer wird, wodurch der Leser sich an Kalkulationstabellen beliebiger Länge anpassen kann, ohne eine fest kodierte Zeilenanzahl zu benötigen. Das Zurückschreiben von Werten folgt der gleichen Zelladressensyntax wie das Lesen, und SaveAs speichert die Änderungen in einer neuen Datei, sodass das Original unberührt bleibt. Der Block try/catch behandelt fehlende Dateien, gesperrte Arbeitsmappen und beschädigte Daten - alle Szenarien, die in Produktionsumgebungen auftreten, in denen Eingabedateien aus externen Quellen stammen.
Die Anleitung zum Erstellen von Tabellenkalkulationen und die Anleitung zum Konvertieren von XLSX in CSV zeigen, wie man Lesen und Schreiben in durchgängigen Arbeitsabläufen kombiniert. Der Leitfaden zur Zellenformatierung behandelt Schriftgrößen, Farben und Rahmen, wenn eine formatierte Ausgabe erforderlich ist.
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 Arbeitsmappenautor einen benannten Bereich namens 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}");Dim range = workbook.GetRangeByName("SalaryTable")
Dim total As Decimal = 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}");For Each ws As WorkSheet In workbook.WorkSheets
Console.WriteLine($"Sheet: {ws.Name}, Rows: {ws.RowCount}")
NextCSV-Laden verwendet eine spezielle Methode, die für Klartextdateien optimiert ist und ein WorkSheet zurückgibt, das Sie mit demselben Bereichs-API navigieren:
WorkBook csv = WorkBook.LoadCSV("data.csv");
WorkSheet first = csv.DefaultWorkSheet;
Console.WriteLine(first["A1"].StringValue);Dim csv As WorkBook = WorkBook.LoadCSV("data.csv")
Dim first As WorkSheet = 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 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:
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronXL ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Das Excel-API, das Sie brauchen, ohne den Office Interop Aufwand.
