Wie man Excel-Daten in C# mit IronXL importiert

Wie installiert man IronXL und wie beginnt man mit dem Excel-Import?

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:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Für detaillierte Installationsinformationen, einschließlich Versionskompatibilität und Abhängigkeitshinweisen, konsultieren Sie bitte den IronXL NuGet Installationsleitfaden . 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);

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);

Dieser Code demonstriert den zentralen Arbeitsablauf: Laden einer Arbeitsmappe, Zugriff auf ein Arbeitsblatt und Lesen von Zellwerten. Die Methode WorkBook.Load() erkennt das Dateiformat automatisch – egal ob XLS, XLSX oder CSV. Dank der intuitiven Indexersyntax sheet["B1"] ist der Zugriff auf Zellen so einfach wie die Arbeit mit Arrays. Eine vollständige Übersicht der verfügbaren Member und Überladungen finden Sie in der IronXL -API-Dokumentation .

Wie liest man Excel-Daten in C#-Objekte ein?

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}"
    );
}

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}"
    );
}

Die 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.

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);
}

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);
}

Wie konvertiert man Excel-Tabellen in C# in DataTables?

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 vom Typ System.Data.DataTable ist, funktioniert es mit jedem ADO.NET-kompatiblen Codepfad, ohne dass Änderungen an Ihrer Datenzugriffsschicht erforderlich sind.

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);
}

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);
}

Die Methode ToDataTable() akzeptiert einen booleschen Parameter, der angibt, ob die erste Zeile Überschriften enthält. Bei der Einstellung true verwendet IronXL automatisch die Werte der ersten Zeile 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();
}

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();
}

Diese Vorgehensweise bietet Ihnen volle Flexibilität beim Import. Nullwerte werden auf elegante Weise behandelt, indem sie in DBNull.Value umgewandelt werden, wodurch die Kompatibilität mit den Spaltenbeschränkungen der Datenbank gewährleistet wird. Weitere Hinweise zum Zurückschreiben von Daten in Dateien finden Sie im IronXL Leitfaden zum Schreiben von Excel-Dateien .

Wie arbeitet man mit Formeln, mehrseitigen Arbeitsmappen und dem Entity Framework?

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)"

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)"

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.");

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.");

Wie handhabt man die Zellformatierung beim Import?

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}");
}

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}");
}

Eine vollständige Übersicht zur Zell- und Bereichsformatierung, einschließlich Zahlenformatzeichenfolgen und Zugriff auf die Hintergrundfarbe, finden Sie im IronXL Leitfaden zur Zellformatierung . Sie können auch Zusammenführungsoperationen auf Ausgabedateien anwenden, nachdem diese verarbeitet wurden – siehe dazu den IronXL Leitfaden zu Zusammenführungszellen .

Wie wählen Sie die richtige IronXL -Lizenz für Ihr Projekt aus?

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:

• Lizenzgebührenfreie Weiterverbreitungsrechte
• Prioritäre Unterstützung durch das IronXL -Entwicklungsteam
• Zugriff auf alle aktuellen und kleineren Versionsaktualisierungen während der Lizenzlaufzeit

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.