Das Einlesen von Excel-Dateien in C# stellt eine häufige Herausforderung for .NET Entwickler dar. Egal ob Sie eine Datenimportpipeline, ein Reporting-Tool oder ein Stapelverarbeitungssystem entwickeln, das saubere Parsen von Tabellenkalkulationsdaten ist wichtig. IronXL ist eine .NET Bibliothek, die XLSX-, XLS- und CSV-Dateien verarbeitet, ohne dass Microsoft Office oder COM-Interop auf dem Server erforderlich ist. Dieser Leitfaden führt Sie durch den gesamten Arbeitsablauf – von der Installation bis hin zu fortgeschrittenen Abfragen –, damit Sie die richtige Vorgehensweise für Ihr Projekt auswählen können.
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.
| Ansatz | Benötigt Office? | Server sicher? | API-Vereinfachung | Formatunterstützung |
|---|---|---|---|---|
| COM-Interop | Ja | Nein | Niedrig | XLSX, XLS |
| OpenXML SDK | Nein | Ja | Niedrig | Nur XLSX |
| IronXL | Nein | Ja | Hoch | XLSX, XLS, CSV |
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.
Die Installation dauert mit dem NuGet -Paketmanager weniger als eine Minute. Öffne ein Terminal in deinem Projektverzeichnis und führe folgenden Befehl aus:
Alternativ können Sie die Visual Studio-Paket-Manager-Konsole verwenden:
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.
Nach dem Hinzufügen des Pakets muss das Projekt einmal neu erstellt werden, um zu bestätigen, dass die Referenz korrekt aufgelöst wird. Wenn Sie einen CS0246 Fehler für IronXL Typen sehen, überprüfen Sie, ob die using IronXL; Direktive vorhanden ist und dass das Ziel-Framework in Ihrer .csproj eine der unterstützten Versionen ist. Die IronXL Kompatibilitätsmatrix listet alle bestätigten Laufzeitziele auf.
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}");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 .
Wenn ein Arbeitsbuch mehrere Tabs enthält, können Sie diese mit workbook.WorkSheets auflisten und nacheinander verarbeiten. Dies ist nützlich für Dateien, die Daten nach Monat, Abteilung oder Region auf separate Registerkarten aufteilen. Die WorkSheet.Name Eigenschaft gibt Ihnen das Tab-Label als String zurück, das Sie für bedingte Verarbeitung oder Protokollierung verwenden können.
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}");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.
Datumszellen in Excel werden intern als Seriennummern gespeichert. IronXL bietet DateTimeValue, um sie in ein .NET DateTime Objekt ohne manuelle Arithmetik zu konvertieren. Für Zellen, die TRUE oder FALSE enthalten, gibt BoolValue den richtigen booleschen Wert zurück, ohne Zeichensatzvergleich. Diese typisierten Zugriffsmethoden eliminieren eine Klasse von Datentypfehlern, die häufig beim Einlesen von Tabellenkalkulationen mit generischen textbasierten Parsern auftreten.
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());
}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.
Die meisten Tabellenkalkulationen haben eine Kopfzeile, die die Spaltennamen beschreibt, anstatt Daten zu enthalten. Beginnen Sie die Bereicheiteration bei Zeile 2 (z.B. "A2:D100") oder beginnen Sie die Indexschleife bei rowIndex = 1, um die Kopfzeile zu überspringen. Wenn Sie ToDataTable(true) verwenden, behandelt IronXL die Kopfzeilenerkennung automatisch und ordnet Spaltennamen aus der ersten Zeile zu.
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}");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.
Ü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}");
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.
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"]}");
}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")}")
Nexttrue 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.
| Betrieb | API | Rücksendungen |
|---|---|---|
| Datei laden | WorkBook.Load(path) | Arbeitsmappe |
| Arbeitsblatt über Index abrufen | workbook.WorkSheets[0] | Arbeitsblatt |
| Arbeitsblatt nach Namen abrufen | workbook.GetWorkSheet("name") | Arbeitsblatt |
| Zeichenkette in Zelle lesen | sheet["A1"].StringValue | String |
| Dezimalzahl lesen | sheet["B1"].DecimalValue | Dezimal |
| Iterationsbereich | foreach cell in sheet["A2:D100"] | IEnumerable<Cell> |
| Summe eines Bereichs | sheet["B2:B50"].Sum() | Dezimal |
| Export in DataTable | sheet.ToDataTable(true) | DataTable |
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.
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:
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.
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.
