Praca z plikami Microsoft Excel jest codziennym wymogiem dla wielu programistów .NET. Niezależnie od tego, czy chodzi o importowanie danych klientów, przetwarzanie raportów finansowych, czy migrację danych z arkuszy kalkulacyjnych do baz danych, programiści potrzebują niezawodnego sposobu odczytu plików Excel bez skomplikowanych zależności i konieczności instalowania programu Excel. Tradycyjne podejścia, takie jak automatyzacja COM za pośrednictwem Microsoft.Office.Interop, wymagają pełnej instalacji pakietu Office, wprowadzają ograniczenia platformowe i powodują powstawanie niestabilnych zależności wdrożeniowych. IronXL oferuje proste rozwiązanie, które działa na różnych platformach, eliminując wszystkie te problemy i umożliwiając operacje w Excelu bezpośrednio z poziomu kodu .NET.
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":
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ą wymagane ż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);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 - czy to XLS, XLSX, czy CSV. Intuicyjna skladnia indeksatora sheet["B1"] umozliwia dostep do komorek w sposob tak naturalny, jak praca z tablicami. Pełny wykaz dostępnych elementów i przeciążeń znajduje się w dokumentacji API IronXL.
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.
Przyklad ponizej odczytuje wiersze z arkusza i mapuje kazdy wiersz na typizowany obiekt 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}"
);
}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}"
)
NextTypizowane wlasciwosci -- IntValue, StringValue, DecimalValue i BoolValue -- automatycznie zajmuja sie konwersja typow. 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.
W przypadku obliczeń zagregowanych i zapytań filtrowanych IronXL obsługuje operacje na zakresach dzięki wbudowanej zgodności z LINQ:
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)
NextKlasa Range zapewnia dostep zblizony do kolekcji do wielu komorek jednoczesnie. Zgodnosc z LINQ oznacza, ze mozna filtrowac, transformowac i agregowac dane z Excela uzywajac znanych wzorcow C# bez koniecznosci konwersji do posrednich kolekcji. Wbudowane metody agregacji, takie jak Sum() i Max(), operuja bezposrednio na zakresach komorek. Aby uzyskać więcej informacji na temat odczytu danych z skoroszytów, zapoznaj się z przewodnikiem IronXL.Excel dotyczącym odczytu plików Excel.
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. Poniewaz powstaly obiekt jest standardowym System.Data.DataTable, dziala on z kazda sciezka kodowa zgodna z ADO.NET bez potrzeby wprowadzania zmian w warstwie dostepu 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);
}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 UsingMetoda ToDataTable() przyjmuje parametr boolowski, ktory wskazuje, czy pierwszy wiersz zawiera naglowki. Gdy ustawiony na true, IronXL automatycznie uzywa wartosci z pierwszego wiersza jako nazw 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();
}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()
NextTakie podejście zapewnia pełną elastyczność podczas importu. Null wartości są obsługiwane elegancko poprzez ich konwersję na DBNull.Value, zapewniając zgodność z ograniczeniami kolumn w bazie danych. Więcej wskazówek na temat zapisywania danych z powrotem do plików znajdziesz w przewodniku IronXL dotyczącym zapisywania plików Excel.
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)"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)"Obsługa formuł oznacza, że importowanie plików Excel zawierających złożone obliczenia działa bez konieczności odtwarzania logiki biznesowej w kodzie. Biblioteka automatycznie ocenia formuły, zwracając obliczone wartości przy zachowaniu oryginalnego ciągu formuły. Ma to nieocenione znaczenie podczas importowania modeli finansowych lub szablonów raportów zawierających zagnieżdżone formuły.
Kompatybilność międzyplatformowa zapewnia spójne działanie w systemach Windows, Linux, macOS oraz środowiskach kontenerowych. Dzięki temu IronXL doskonale nadaje się do wdrożeń w chmurze i mikrousług, gdzie instalacja pakietu Office nie jest możliwa. Dokumentacja Fundacji .NET podkreśla, w jaki sposób nowoczesne aplikacje .NET czerpią korzyści z niezależności od platformy.
Integracja z Entity Framework tworzy bezpośrednie potoki danych między Excelem a bazą danych. Poniższy wzorzec działa poprawnie z instrukcjami najwyższego poziomu w .NET 10:
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.")Ten wzorzec umożliwia bezpośrednią migrację danych z Excela do bazy danych przy minimalnym nakładzie kodu, dzięki czemu doskonale nadaje się do procesów ETL, jednorazowych migracji danych oraz zaplanowanych zadań importu. Ponieważ projekcja LINQ działa w pamięci przed zapisaniem kontekstu, można zastosować logikę walidacji lub transformacji na tym samym etapie. Aby utworzyć nowe pliki Excel na podstawie danych C#, zapoznaj się z przewodnikiem IronXL.Excel dotyczącym tworzenia plików Excel.
IronXL obsługuje szeroki zakres formatów arkuszy kalkulacyjnych bez konieczności instalowania dodatkowych bibliotek lub pakietu Office. Poniższa tabela zawiera podsumowanie obsługiwanych formatów i ich zastosowań:
| Format | Rozszerzenie | Uwagi |
|---|---|---|
| Skoroszyt programu Excel | .xlsx | Domyślny format dla programu Excel 2007 i nowszych wersji |
| Starsza wersja skoroszytu Excel | .xls | Kompatybilny ze starszymi wersjami programu Excel |
| Wartości rozdzielone przecinkami | .csv | Dane tabelaryczne w postaci zwykłego tekstu, szeroko obsługiwane |
| Wartości rozdzielone tabulatorami | .tsv | Odpowiednie dla danych z wbudowanymi przecinkami |
| Binarny skoroszyt programu Excel | .xlsb | Kompaktowy format binarny dla dużych plików |
Aby wyeksportować dane z powrotem do tych formatów, zapoznaj się z przewodnikiem IronXL dotyczącym eksportu do Excela.
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}");
}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}")
NextPeł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.
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ą:
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.
Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
