Jak zaimportować dane z Excela w C# przy użyciu IronXL

Jak zainstalować IronXL i rozpocząć importowanie danych z Excela?

Rozpoczęcie importu z Excela w języku C# zajmuje zaledwie kilka minut dzięki IronXL. Biblioteka Excel obsługuje zarówno starszy format XLS, jak i nowoczesny format XLSX, a także CSV, TSV i inne formaty arkuszy kalkulacyjnych. W przeciwieństwie do rozwiązań opartych na Microsoft.Office.Interop.Excel, IronXL działa niezależnie na dowolnej platformie .NET lub .NET Core.

Zainstaluj IronXL za pomocą menedżera pakietów NuGet lub interfejsu CLI .NET. Można również skorzystać z okna dialogowego Zarządzaj pakietami NuGet w programie Visual Studio i wyszukać "IronXL":

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Pełne informacje dotyczące instalacji, w tym kompatybilność wersji i uwagi dotyczące zależności, można znaleźć w przewodniku instalacji IronXL NuGet. Nie są wymagańe żadne dodatkowe zależności środowiskowe ani komponenty pakietu Office — pakiet jest samowystarczalny. Po zainstalowaniu pakietu importowanie danych z Excela jest proste:

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

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)

Ten kod ilustruje podstawowy przebieg pracy: ładowanie skoroszytu, uzyskiwanie dostępu do arkusza i odczytywanie wartości komórek. Metoda WorkBook.Load() automatycznie wykrywa format pliku — niezależnie od tego, czy jest to XLS, XLSX czy CSV. Intuicyjna składnia indeksatora sheet["B1"] sprawia, że dostęp do komórek jest tak naturalny, jak praca z tablicami. Pełny wykaz dostępnych elementów i przeciążeń znajduje się w dokumentacji API IronXL.

Jak wczytać dane z Excela do obiektów C#?

Rzeczywiste aplikacje wymagają więcej niż wartości pojedynczych komórek. IronXL doskonale radzi sobie z importowaniem całych zbiorów danych i przekształcaniem ich w użyteczne obiekty C#. Gdy zachodzi potrzeba importowania ustrukturyzowanych danych z Excela, biblioteka oferuje wiele metod, które bezpośrednio mapują się na modele domenowe.

Poniższy przykład odczytuje wiersze z arkusza i mapuje każdy wiersz na obiekt typu Product:

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

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

Właściwości typowane -- IntValue, StringValue, DecimalValue oraz BoolValue -- automatycznie obsługują konwersję typów. Takie podejście eliminuje ręczne parsowanie i zmniejsza liczbę błędów podczas pracy z kolumnami zawierającymi różne typy danych. Wielu programistów na Stack Overflow docenia to bezpieczne pod względem typów podejście do importu danych z Excela.

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

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

Jak przekonwertować plik Excel na DataTable w języku C#?

Konwersja DataTable jest niezbędna w operacjach na bazach danych i scenariuszach powiązania danych. IronXL udostępnia wbudowane metody obsługujące konwersję z formatu Excel do DataSet lub DataTable. Ta funkcja jest szczególnie przydatna, gdy trzeba zaimportować arkusze kalkulacyjne Excel do SQL Server lub innych relacyjnych baz danych. Ponieważ wynikowy obiekt jest standardowym System.Data.DataTable, działa on z każdą ścieżką kodu zgodną z ADO.NET bez konieczności wprowadzania zmian w warstwie dostępu do danych.

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

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 Using

Metoda ToDataTable() przyjmuje parametr logiczny wskazujący, czy pierwszy wiersz zawiera nagłówki. Po ustawieniu na true, IronXL automatycznie wykorzystuje wartości z pierwszego wiersza jako nazwy kolumn. Powstała tabela danych (DataTable) integruje się z ADO.NET Framework, Entity Framework i kontrolkami powiązania danych bez konieczności dodatkowej konfiguracji.

Aby uzyskać większą kontrolę nad procesem konwersji, można ręcznie utworzyć tabelę DataTable:

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

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()
Next

Takie podejście zapewnia pełną elastyczność podczas importu. Wartości null są obsługiwane w sposób elegancki poprzez konwersję ich na DBNull.Value, co zapewnia zgodność z ograniczeniami kolumn bazy danych. Więcej wskazówek na temat zapisywania danych z powrotem do plików znajdziesz w przewodniku IronXL dotyczącym zapisywania plików Excel.

Jak pracować z formułami, skoroszytami wielarkuszowymi i Entity Framework?

IronXL wykracza poza podstawowe funkcje odczytu, oferując funkcje dostosowane do złożonych scenariuszy z życia codziennego. Biblioteka zachowuje formuły programu Excel, umożliwiając dynamiczne obliczanie wyników. Dla programistów pracujących ze złożonymi skoroszytami Excel zapewnia to zachowanie integralności danych podczas całego procesu importu.

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

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

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

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

Jak radzisz sobie z formatowaniem komórek podczas importu?

Podczas importowania plików Excel zachowanie lub sprawdzenie formatowania komórek jest często równie ważne jak odczytanie surowych wartości. IronXL udostępnia właściwości czcionki, koloru, wyrównania i obramowania dla każdej komórki, dzięki czemu można programowo stosować reguły walidacji lub odtwarzać style. Jest to szczególnie przydatne w przypadku raportów, w których formatowanie wizualne ma znaczenie semantyczne — na przykład kolorowe komórki wskazujące poziomy ryzyka lub pogrubione wiersze oznaczające sumy.

Na przykład, przed podjęciem decyzji o włączeniu danego wiersza do importowanego zestawu danych warto sprawdzić, czy komórki zawierają pogrubiony tekst — co często oznacza, że wiersz jest wierszem podsumowującym lub sumującym:

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

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

Pełne informacje na temat formatowania komórek i zakresów, w tym ciągów formatów liczbowych i dostępu do koloru tła, można znaleźć w przewodniku po formatowaniu komórek IronXL. Można również zastosować operacje scałania do plików wyjściowych po przetworzeniu — zobacz przewodnik IronXL dotyczący scałania komórek.

Jak wybrać odpowiednią licencję IronXL dla swojego projektu?

IronXL oferuje elastyczne opcje licencyjne dostosowane do skali Twojego projektu. Dostępna jest bezpłatna licencja próbna, która zapewnia dostęp do wszystkich funkcji bez ograniczeń czasowych podczas tworzenia oprogramowania. Wersja próbna dodaje znak wodny do plików wyjściowych, który jest usuwany po zakupie ważnej licencji produkcyjnej.

Dla zespołów tworzących aplikacje produkcyjne licencja IronXL obejmuje opcje dla indywidualnych programistów, zespołów oraz wdrożeń w całej organizacji. Wszystkie licencje produkcyjne obejmują:

• Prawa do redystrybucji bez opłat licencyjnych
• Priorytetowe wsparcie ze strony zespołu programistów IronXL
• Dostęp do wszystkich aktualizacji bieżących i pomniejszych wersji w okresie obowiązywania licencji

Jeśli porównujesz IronXL z innymi bibliotekami IronXL, przegląd funkcji IronXL zawiera szczegółowy opis tego, co obejmuje każdy poziom.

Aby już dziś zacząć korzystać z IronXL w swoim projekcie, odwiedź stronę produktu IronXL lub przejdź bezpośrednio do dokumentacji IronXL, gdzie znajdziesz przewodniki konfiguracji, artykuły instruktażowe oraz Dokumentację API obejmującą wszystkie funkcje biblioteki IronXL.