Die Arbeit mit Microsoft Excel-Dateien ist für viele .NET-Entwickler eine tägliche Anforderung. Ob es um den Import von Kundendaten, die Verarbeitung von Finanzberichten oder die Migration von Daten aus Tabellenkalkulationen in Datenbanken geht – Entwickler benötigen eine zuverlässige Möglichkeit, Excel-Dateien zu lesen, ohne komplexe Abhängigkeiten oder die Installation von Excel vorauszusetzen. Herkömmliche Ansätze wie die COM-Automatisierung über Microsoft.Office.Interop erfordern eine vollständige Office-Installation, führen zu Plattformbeschränkungen und erzeugen brüchige Bereitstellungsabhängigkeiten. IronXL bietet eine unkomplizierte Lösung, die plattformübergreifend funktioniert, all diese Probleme beseitigt und Excel-Operationen direkt aus verwaltetem .NET -Code ermöglicht.
Der Einstieg in den Excel-Import in C# dauert mit IronXL nur wenige Minuten. Die Excel-Bibliothek unterstützt sowohl das ältere XLS- als auch das moderne XLSX-Format sowie CSV, TSV und andere Tabellenkalkulationsformate. Im Gegensatz zu Lösungen, die auf Microsoft.Office.Interop.Excel basieren, läuft IronXL unabhängig auf jeder .NET- oder .NET Core-Plattform.
Installieren Sie IronXL über den NuGet Paketmanager oder die .NET Befehlszeilenschnittstelle. Alternativ können Sie in Visual Studio den Dialog "NuGet -Pakete verwalten" verwenden und nach "IronXL" suchen:
Ausführliche Informationen zur Installation, einschließlich Angaben zur Versionskompatibilität und zu Abhängigkeiten, finden Sie im IronXL NuGet-Installationshandbuch. Es werden keine zusätzlichen Laufzeitabhängigkeiten oder Office-Komponenten benötigt – das Paket ist in sich abgeschlossen. Sobald das Paket installiert ist, ist der Import von Excel-Daten unkompliziert:
using IronXL;
// Load any Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
// Access the first worksheet
WorkSheet sheet = workBook.WorkSheets[0];
// Read a cell value
string value = sheet["B1"].StringValue;
Console.WriteLine(value);Imports IronXL
' Load any Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
' Access the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets(0)
' Read a cell value
Dim value As String = sheet("B1").StringValue
Console.WriteLine(value)Dieser Code demonstriert den zentralen Arbeitsablauf: Laden einer Arbeitsmappe, Zugriff auf ein Arbeitsblatt und Lesen von Zellwerten. Die WorkBook.Load()-Methode erkennt automatisch das Dateiformat – ob es sich um XLS, XLSX oder CSV handelt. Die intuitive Indexierungs-Syntax sheet["B1"] macht den Zugriff auf Zellen so natürlich wie die Arbeit mit Arrays. Eine vollständige Übersicht der verfügbaren Member und Überladungen finden Sie in der IronXL -API-Dokumentation .
Echte Anwendungen brauchen mehr als nur einzelne Zellwerte. IronXL zeichnet sich durch den Import ganzer Datensätze und deren Umwandlung in nutzbare C#-Objekte aus. Wenn Sie strukturierte Excel-Daten importieren müssen, bietet die Bibliothek mehrere Ansätze, die direkt auf Ihre Domänenmodelle abgebildet werden können.
Das folgende Beispiel liest Zeilen aus einem Arbeitsblatt und ordnet jede Zeile einem typisierten Product-Objekt zu:
using IronXL;
// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Map rows to typed objects
var products = new List<Product>();
foreach (var row in sheet.Rows)
{
var product = new Product
{
Id = row.Columns[0].IntValue,
Name = row.Columns[1].StringValue,
Price = row.Columns[2].DecimalValue,
IsAvailable = row.Columns[3].BoolValue
};
products.Add(product);
}
foreach (var product in products)
{
Console.WriteLine(
$"Id: {product.Id}, Name: {product.Name}, " +
$"Price: {product.Price}, Available: {product.IsAvailable}"
);
}Imports IronXL
' Load the Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Map rows to typed objects
Dim products As New List(Of Product)()
For Each row In sheet.Rows
Dim product As New Product With {
.Id = row.Columns(0).IntValue,
.Name = row.Columns(1).StringValue,
.Price = row.Columns(2).DecimalValue,
.IsAvailable = row.Columns(3).BoolValue
}
products.Add(product)
Next
For Each product In products
Console.WriteLine(
$"Id: {product.Id}, Name: {product.Name}, " &
$"Price: {product.Price}, Available: {product.IsAvailable}"
)
NextDie typisierten Eigenschaften – IntValue, StringValue, DecimalValue und BoolValue – übernehmen die Typkonvertierung automatisch. Dieser Ansatz macht manuelles Parsen überflüssig und reduziert Fehler beim Arbeiten mit Spalten unterschiedlicher Datentypen. Viele Entwickler auf Stack Overflow schätzen diesen typsicheren Ansatz für den Excel-Datenimport.
Für Aggregatberechnungen und gefilterte Abfragen unterstützt IronXL Bereichsoperationen mit integrierter LINQ-Kompatibilität:
using IronXL;
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Read a named cell range
Range dataRange = sheet["A1:D5"];
// Calculate aggregates directly on a range
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");
decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");
// Filter using LINQ
var highValueOrders = dataRange
.Where(cell => cell.DecimalValue > 100)
.Select(cell => cell.Value)
.ToList();
Console.WriteLine("Orders above 100:");
foreach (var order in highValueOrders)
{
Console.WriteLine(order);
}Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Read a named cell range
Dim dataRange As Range = sheet("A1:D5")
' Calculate aggregates directly on a range
Dim sum As Decimal = sheet("C1:C5").Sum()
Console.WriteLine($"Sum of C1:C5: {sum}")
Dim max As Decimal = sheet("C1:C5").Max(Function(c) c.DecimalValue)
Console.WriteLine($"Max of C1:C5: {max}")
' Filter using LINQ
Dim highValueOrders = dataRange _
.Where(Function(cell) cell.DecimalValue > 100) _
.Select(Function(cell) cell.Value) _
.ToList()
Console.WriteLine("Orders above 100:")
For Each order In highValueOrders
Console.WriteLine(order)
NextDie Range-Klasse bietet sammlungsartigen Zugriff auf mehrere Zellen gleichzeitig. Die LINQ-Kompatibilität bedeutet, dass Sie Excel-Daten filtern, transformieren und aggregieren können, indem Sie vertraute C#-Muster verwenden, ohne diese zuerst in Zwischenkollektionen zu konvertieren. Die integrierten Aggregationsmethoden wie Sum() und Max() arbeiten direkt auf Zellbereichen. Weitere Informationen zum Lesen von Arbeitsmappendaten finden Sie im IronXL-Leitfaden zum Lesen von Excel-Dateien.
Die DataTable-Konvertierung ist für Datenbankoperationen und Datenbindungsszenarien unerlässlich. IronXL bietet integrierte Methoden, die die Konvertierung von Excel in DataSet oder DataTable übernehmen. Diese Funktion ist besonders nützlich, wenn Sie Excel-Tabellen in SQL Server oder andere relationale Datenbanken importieren müssen. Da das resultierende Objekt ein standardmäßiges System.Data.DataTable ist, funktioniert es mit jedem ADO.NET-kompatiblen Codepfad, ohne Änderungen an Ihrer Datenzugriffsschicht zu erfordern.
using IronXL;
using System.Data;
using System.Data.SqlClient;
// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select the first worksheet
WorkSheet sheet = workBook.WorkSheets.First();
// Convert to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);
// Use SqlBulkCopy to insert directly into SQL Server
string connectionString = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;";
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
bulkCopy.DestinationTableName = "Inventory";
bulkCopy.WriteToServer(dataTable);
}Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
' Load Excel file
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
' Select the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets.First()
' Convert to DataTable -- first row becomes column headers
Dim dataTable As DataTable = sheet.ToDataTable(True)
' Use SqlBulkCopy to insert directly into SQL Server
Dim connectionString As String = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;"
Using bulkCopy As New SqlBulkCopy(connectionString)
bulkCopy.DestinationTableName = "Inventory"
bulkCopy.WriteToServer(dataTable)
End UsingDie ToDataTable()-Methode akzeptiert einen booleschen Parameter, der angibt, ob die erste Zeile Überschriften enthält. Wenn auf true gesetzt, verwendet IronXL die Werte der ersten Zeile automatisch als Spaltennamen. Die resultierende DataTable integriert sich ohne zusätzliche Konfiguration in ADO .NET, Entity Framework und Datenbindungssteuerelemente.
Um den Konvertierungsprozess besser steuern zu können, können Sie die DataTable manuell erstellen:
using IronXL;
using System.Data;
WorkBook workBook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workBook.WorkSheets.First();
// Build DataTable manually for custom column types or validation
DataTable customTable = new DataTable();
for (int col = 0; col < sheet.ColumnCount; col++)
{
customTable.Columns.Add($"Column{col + 1}", typeof(string));
}
foreach (var row in sheet.Rows)
{
var dataRow = customTable.NewRow();
for (int col = 0; col < sheet.ColumnCount; col++)
{
dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
}
customTable.Rows.Add(dataRow);
}
// Print headers
foreach (DataColumn column in customTable.Columns)
{
Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();
// Print data rows
foreach (DataRow row in customTable.Rows)
{
foreach (var item in row.ItemArray)
{
Console.Write($"{item}\t");
}
Console.WriteLine();
}Imports IronXL
Imports System.Data
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workBook.WorkSheets.First()
' Build DataTable manually for custom column types or validation
Dim customTable As New DataTable()
For col As Integer = 0 To sheet.ColumnCount - 1
customTable.Columns.Add($"Column{col + 1}", GetType(String))
Next
For Each row In sheet.Rows
Dim dataRow = customTable.NewRow()
For col As Integer = 0 To sheet.ColumnCount - 1
dataRow(col) = If(row.Columns(col).Value, DBNull.Value)
Next
customTable.Rows.Add(dataRow)
Next
' Print headers
For Each column As DataColumn In customTable.Columns
Console.Write($"{column.ColumnName}" & vbTab)
Next
Console.WriteLine()
' Print data rows
For Each row As DataRow In customTable.Rows
For Each item In row.ItemArray
Console.Write($"{item}" & vbTab)
Next
Console.WriteLine()
NextDiese Vorgehensweise bietet Ihnen volle Flexibilität beim Import. Nullwerte werden geschickt gehandhabt, indem sie in DBNull.Value konvertiert werden, um die Kompatibilität mit Datenbanksäulenbeschränkungen zu gewährleisten. Weitere Anleitungen zum Zurückschreiben von Daten in Dateien finden Sie im IronXL-Leitfaden zum Schreiben von Excel-Dateien.
IronXL bietet mehr als nur einfaches Lesen und verfügt über Funktionen für komplexe reale Szenarien. Die Bibliothek erhält die Excel-Formeln und ermöglicht so die dynamische Auswertung von Berechnungen. Für Entwickler, die mit komplexen Excel-Arbeitsmappen arbeiten, gewährleistet dies die Datenintegrität während des gesamten Importvorgangs.
using IronXL;
WorkBook workBook = WorkBook.Load("FinancialReport.xlsx");
WorkSheet sheet = workBook.GetWorkSheet("Reports");
// Read the evaluated result of a formula cell
decimal calculatedTotal = sheet["E10"].DecimalValue;
Console.WriteLine($"Total: {calculatedTotal}");
// Read the formula string itself
string formula = sheet["E10"].Formula;
Console.WriteLine($"Formula: {formula}"); // e.g. "=SUM(E2:E9)"Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("FinancialReport.xlsx")
Dim sheet As WorkSheet = workBook.GetWorkSheet("Reports")
' Read the evaluated result of a formula cell
Dim calculatedTotal As Decimal = sheet("E10").DecimalValue
Console.WriteLine($"Total: {calculatedTotal}")
' Read the formula string itself
Dim formula As String = sheet("E10").Formula
Console.WriteLine($"Formula: {formula}") ' e.g. "=SUM(E2:E9)"Die Formelunterstützung ermöglicht den Import von Excel-Dateien mit komplexen Berechnungen, ohne dass die Geschäftslogik im Code nachgebildet werden muss. Die Bibliothek wertet Formeln automatisch aus und gibt berechnete Werte zurück, wobei die ursprüngliche Formelzeichenfolge erhalten bleibt. Dies erweist sich als unschätzbar wertvoll beim Import von Finanzmodellen oder Berichtsvorlagen, die verschachtelte Formeln enthalten.
Die plattformübergreifende Kompatibilität gewährleistet ein konsistentes Verhalten in Windows-, Linux-, macOS- und Container-Umgebungen. Dadurch eignet sich IronXL hervorragend für Cloud-Bereitstellungen und Microservices, bei denen eine Office-Installation nicht möglich ist. Die Dokumentation der .NET Foundation hebt hervor, wie moderne .NET Anwendungen von der Plattformunabhängigkeit profitieren.
Die Integration von Entity Framework ermöglicht die direkte Datenübertragung von Excel zu Datenbanken. Das folgende Muster funktioniert einwandfrei mit .NET 10 Top-Level-Anweisungen:
using IronXL;
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Skip the header row, map remaining rows to entity objects
var products = sheet.Rows
.Skip(1)
.Select(row => new Product
{
Name = row.Columns[0].StringValue,
Price = row.Columns[1].DecimalValue
})
.ToList();
using var context = new AppDbContext();
await context.Products.AddRangeAsync(products);
await context.SaveChangesAsync();
Console.WriteLine($"Imported {products.Count} products.");Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Skip the header row, map remaining rows to entity objects
Dim products = sheet.Rows _
.Skip(1) _
.Select(Function(row) New Product With {
.Name = row.Columns(0).StringValue,
.Price = row.Columns(1).DecimalValue
}) _
.ToList()
Using context As New AppDbContext()
Await context.Products.AddRangeAsync(products)
Await context.SaveChangesAsync()
End Using
Console.WriteLine($"Imported {products.Count} products.")Dieses Muster ermöglicht die direkte Migration von Excel-Daten in Datenbanken mit minimalem Codeaufwand und eignet sich daher gut für ETL-Prozesse, einmalige Datenmigrationen und geplante Importaufträge. Da die LINQ-Projektion im Speicher ausgeführt wird, bevor der Kontext gespeichert wird, können Sie im selben Schritt Validierungs- oder Transformationslogik anwenden. Informationen zum Erstellen neuer Excel-Dateien aus C#-Daten finden Sie im IronXL-Leitfaden zum Erstellen von Excel-Dateien.
IronXL verarbeitet eine breite Palette von Tabellenkalkulationsformaten ohne zusätzliche Bibliotheken oder Office-Installation. Die folgende Tabelle fasst die unterstützten Formate und ihre Anwendungsfälle zusammen:
| Format | Verlängerung | Anmerkungen |
|---|---|---|
| Excel-Arbeitsbuch | .xlsx | Standardformat für Excel 2007 und höher |
| Legacy-Excel-Arbeitsmappe | .xls | Kompatibel mit älteren Excel-Versionen |
| Kommagetrennte Werte | .csv | Einfache tabellarische Daten, weit verbreitet unterstützt |
| Tabulatorgetrennte Werte | .tsv | Geeignet für Daten mit eingebetteten Kommas |
| Excel-Arbeitsmappe (Binär) | .xlsb | Kompaktes Binärformat für große Dateien |
Informationen zum Zurückexportieren von Daten in diese Formate finden Sie im IronXL-Export-Excel-Leitfaden.
Beim Importieren von Excel-Dateien ist das Beibehalten oder Überprüfen der Zellformatierung oft genauso wichtig wie das Lesen der Rohwerte. IronXL stellt für jede Zelle Eigenschaften für Schriftart, Farbe, Ausrichtung und Rahmen bereit, sodass Sie Validierungsregeln anwenden oder Stile programmatisch reproduzieren können. Dies ist besonders nützlich für Berichte, bei denen die visuelle Formatierung eine semantische Bedeutung hat – zum Beispiel farbige Zellen, die Risikostufen anzeigen, oder fettgedruckte Zeilen, die Summen kennzeichnen.
Beispielsweise sollten Sie prüfen, ob Zellen fettgedruckten Text enthalten – ein häufiges Indiz dafür, dass es sich um eine Zusammenfassungs- oder Summenzeile handelt –, bevor Sie entscheiden, ob Sie diese in Ihren importierten Datensatz aufnehmen:
using IronXL;
WorkBook workBook = WorkBook.Load("StyledReport.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
foreach (var row in sheet.Rows)
{
var firstCell = row.Columns[0];
// Skip rows where the first cell is bold (typically header or total rows)
if (firstCell.Style.Font.Bold)
{
continue;
}
Console.WriteLine($"Data row: {firstCell.StringValue}");
}Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("StyledReport.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
For Each row In sheet.Rows
Dim firstCell = row.Columns(0)
' Skip rows where the first cell is bold (typically header or total rows)
If firstCell.Style.Font.Bold Then
Continue For
End If
Console.WriteLine($"Data row: {firstCell.StringValue}")
NextEine vollständige Übersicht über die Formatierung von Zellen und Bereichen, einschließlich Zahlenformatierungszeichenfolgen und Zugriff auf Hintergrundfarben, finden Sie im IronXL-Leitfaden zur Zellenformatierung. Sie können auch Zusammenführungsoperationen auf Ausgabedateien anwenden, nachdem diese verarbeitet wurden – siehe dazu den IronXL Leitfaden zum Zusammenführen von Zellen .
IronXL bietet flexible Lizenzierungsoptionen, die dem Umfang Ihres Projekts gerecht werden. Für Evaluierungszwecke steht eine kostenlose Testlizenz zur Verfügung, die Ihnen während der Entwicklungsphase Zugriff auf alle Funktionen ohne zeitliche Einschränkungen ermöglicht. Die Testversion fügt den Ausgabedateien ein Wasserzeichen hinzu, das mit einer gültigen Produktionslizenz entfernt wird.
Für Teams, die Produktionsanwendungen entwickeln, bietet IronXL Lizenzierungsoptionen für einzelne Entwickler, Teams und unternehmensweite Bereitstellungen. Alle Produktionslizenzen beinhalten:
Wenn Sie IronXL zusammen mit anderen Excel-Bibliotheken evaluieren, bietet Ihnen die IronXL -Funktionsübersicht eine detaillierte Aufschlüsselung dessen, was in jeder Stufe enthalten ist.
Um IronXL noch heute in Ihrem Projekt einzusetzen, besuchen Sie die IronXL -Produktseite oder beginnen Sie direkt mit der IronXL -Dokumentation , die Einrichtungsanleitungen, praktische Artikel und API-Referenzen zu allen Funktionen der Bibliothek enthält.
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.
