Najlepsza metoda odczytu plików Excel w C# | Przewodnik krok po kroku IronXL

Jaki jest najlepszy sposób na odczytanie plików Excel w języku C#?

Najlepszym rozwiązaniem jest użycie dedykowanej biblioteki niezależnej od pakietu Office, takiej jak biblioteka IronXL. Tradycyjne metody, takie jak Microsoft.Office.Interop.Excel, działają na komputerach, na których zainstalowano program Excel, ale są one niestabilne w środowiskach serwerowych lub kontenerowych, ponieważ uruchamiają proces COM w tle. OpenXML SDK jest bezpłatny i bezpieczny dla serwerów, ale udostępnia niskoopoziomowy model XML, który wymaga znacznej ilości powtarzalnego kodu przy wykonywaniu codziennych zadań.

IronXL plasuje się pomiędzy tymi skrajnościami. API odzwierciedla sposób, w jaki programiści postrzegają arkusze kalkulacyjne — skoroszyty zawierają arkusze, arkusze zawierają komórki, a komórki zawierają wpisane wartości. Biblioteka wewnętrznie obsługuje wykrywanie formatów, ocenę formuł i kodowanie, dzięki czemu możesz poświęcić czas na logikę biznesową, a nie na analizowanie szczegółów.

Dokumentacja dotycząca odczytu plików Excel w IronXL obejmuje pełny zakres API. Na razie poniższe sekcje przedstawiają podstawowe wzorce, które będą wykorzystywane w każdym projekcie.

Jak zainstalować IronXL w projekcie .NET?

Instalacja zajmuje mniej niż minutę przy użyciu menedżera pakietów NuGet. Otwórz terminal w katalogu projektu i uruchom:

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

Alternatywnie można użyć konsoli menedżera pakietów Visual Studio:

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Po instalacji dodaj dyrektywę using IronXL; do każdego pliku, który wymaga dostępu do arkusza kalkulacyjnego. Biblioteka jest przeznaczona dla platform .NET 10, .NET 8, .NET 6, .NET Framework 4.6.2 oraz .NET Standard 2.0, dzięki czemu można ją wdrożyć w istniejących projektach bez konieczności aktualizacji środowiska uruchomieniowego. Informacje dotyczące poszczególnych platform oraz szczegóły pakietu NuGet można znaleźć w instrukcji instalacji IronXL.

Nie są wymagańe żadne dodatkowe komponenty uruchomieniowe, wpisy w rejestrze ani licencje Office. Pakiet NuGet zawiera wszystko, czego potrzebuje biblioteka.

Jak załadować i otworzyć skoroszyt Excel?

Załadowanie skoroszytu wymaga jednego wywołania metody. WorkBook.Load przyjmuje ścieżkę do pliku i zwraca obiekt WorkBook, który reprezentuje cały plik w pamięci.

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

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

Obiekt WorkBook zapewnia dostęp do wszystkich danych arkusza. Każda instancja WorkSheet odpowiada zakładce w pliku. Dostęp według indeksu (WorkSheets[0]) jest niezawodny w przypadku plików jednostronicowych; Dostęp według nazwy jest bezpieczniejszy, gdy plik zawiera wiele kart o znanych nazwach.

IronXL automatycznie oblicza formuły podczas odczytu komórki. Jeśli komórka B10 zawiera =SUM(B2:B9), odczytanie sheet["B10"].DecimalValue zwraca obliczoną sumę, a nie ciąg formuły. Więcej informacji na temat opcji ładowania skoroszytów można znaleźć w poradniku dotyczącym ładowania arkuszy kalkulacyjnych.

Jak odczytać wartości komórek z arkusza?

IronXL zapewnia silnie typowane właściwości każdej komórki, dzięki czemu można odczytywać wartości bezpośrednio do odpowiedniego typu .NET bez ręcznego parsowania.

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

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

Składnia sheet["A2"] wykorzystuje standardową notację programu Excel. W literach kolumn nie rozróżnia się wielkości liter, a numery wierszy zaczynają się od 1, zgodnie z tym, jak Excel oznacza komórki. Dokumentacja dotycząca odczytu wartości komórek zawiera dodatkowe typowane akcesory, w tym DateTimeValue dla komórek sformatowanych jako daty.

Gdy komórka zawiera liczbę zapisaną jako tekst (częsty problem z jakością danych w eksportowanych arkuszach kalkulacyjnych), StringValue zwraca tekst w niezmienionej postaci, podczas gdy DecimalValue próbuje go przeanalizować i w przypadku niepowodzenia zwraca 0. Zawsze należy zweryfikować nieoczekiwane dane przed potraktowaniem ich jako wartości typowej w kodzie produkcyjnym.

Jak iterować po wierszach i komórkach?

Przeglądanie zbioru danych wymaga zakresu lub kolekcji wierszy. IronXL obsługuje oba podejścia i można je łączyć w zależności od kształtu danych.

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

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

Ciąg znaków "A2:D100" tworzy płaską kolekcję komórek. Wiersze w zakresie są przetwarzane od góry do dołu, od lewej do prawej. Ten wzorzec sprawdza się dobrze przy eksporcie do List<t>, DataTable lub bazy danych.

Właściwość sheet.RowCount odzwierciedla ostatni użyty wiersz w arkuszu, więc pętla kończy się automatycznie po zakończeniu danych. Przewodnik dotyczący iteracji zakresu w Excelu obejmuje dodatkowe wzorce iteracji, w tym przeglądanie od kolumny.

Jak radzisz sobie z wieloma formatami plików Excel?

IronXL automatycznie rozpoznaje format pliku na podstawie rozszerzenia i nagłówka pliku. Interfejs API jest identyczny dla plików XLSX, XLS i CSV, co oznacza, że ten sam kod parsujący działa we wszystkich trzech formatach bez logiki warunkówej.

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

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

W przypadku plików CSV IronXL przestrzega konwencji RFC 4180, w tym pól w cudzysłowie zawierających przecinki, znaków nowej linii wewnątrz wartości w cudzysłowie oraz podwójnych cudzysłowów z sekwencją escape. Przewodnik po konwersji plików CSV do formatu XLSX obejmuje dostosowywanie separatorów w przypadku niestandardowych eksportów CSV.

Gdy aplikacja musi akceptować pliki z systemów zewnętrznych, dobrą praktyką jest sprawdzenie rozszerzenia pliku i zweryfikowanie zawartości przed załadowaniem. IronXL zgłasza opisowy wyjątek, jeśli plik jest uszkodzony lub ma nieobsługiwany format, który można przechwycić i przekazać użytkownikowi.

Jak wykonywać zaawansowane zapytania na danych w programie Excel?

Oprócz odczytu komórka po komórce, IronXL udostępnia funkcje agregujące i kompatybilność z LINQ, które przekształcają zakres arkusza w kolekcję, którą można przeszukiwać.

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

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

Imports IronXL
Imports System.Linq

Dim workbook As WorkBook = WorkBook.Load("Financials.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Built-in aggregates -- no manual looping needed
Dim totalSales As Decimal = sheet("B2:B50").Sum()
Dim maxRevenue As Decimal = sheet("C2:C50").Max(Function(c) c.DecimalValue)
Dim avgMargin As Decimal = sheet("D2:D50").Avg()

' LINQ filtering directly on a range
Dim highValueRows = sheet("C2:C50") _
    .Where(Function(c) c.DecimalValue > 1000) _
    .Select(Function(c) New With {Key .AddressString = c.AddressString, Key .DecimalValue = c.DecimalValue})

For Each row In highValueRows
    Console.WriteLine($"High value at {row.AddressString}: {row.DecimalValue:C}")
Next

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

Zgodność z LINQ jest przydatna, gdy trzeba przefiltrować wiersze przed zaimportowaniem ich do bazy danych lub sprawdzić, czy wszystkie wartości w kolumnie spełniają określony próg. Biblioteka ocenia formuły przed uruchomieniem LINQ, więc zapytania agregujące zawsze działają na ostatecznych wartościach obliczonych, a nie na ciągach formuł.

Samouczek LINQ z IronXL obejmuje łączenie arkuszy, grupowanie według kolumn oraz rzutowanie wyników na obiekty silnie typowane — wzorce, które eliminują wiele powtarzalnego kodu w kodzie potoku danych.

Jak wyeksportować dane z Excela do tabeli danych (DataTable)?

Wiele aplikacji .NET ładuje dane z arkuszy kalkulacyjnych do ADO.NET DataTable w celu dalszego przetwarzania lub wstawienia do bazy danych. IronXL zapewnia metodę bezpośredniej konwersji, która eliminuje konieczność ręcznego mapowania kolumn.

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

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

Przekazanie true do ToDataTable powoduje, że pierwszy wiersz arkusza jest traktowany jako nagłówki kolumn. Wynikowy DataTable wykorzystuje nazwy kolumn łańcuchów znaków, które odpowiadają tekstowi nagłówka, dzięki czemu kolejne zapytania LINQ-to-DataSet są czytelne. Dokumentacja dotycząca eksportu do DataTable obejmuje opcje obsługi wartości null oraz wnioskowania o typach.

Ten wzorzec jest szczególnie przydatny, gdy kod niższego poziomu już oczekuje DataTable — na przykład podczas wywoływania SqlBulkCopy w celu wstawienia wierszy do serwera SQL. Możesz załadować plik XLSX, przekonwertować go na DataTable i wstawić zbiorczo bez pisania szablonowego kodu mapującego kolumny.

Pełna lista interfejsów API znajduje się w Dokumentacji API IronXL. Dokumentacja obejmuje wszystkie właściwości i metody wraz z opisami parametrów i szczegółami dotyczącymi typów zwracanych wartości.

Jakie są Twoje kolejne kroki?

Odczytywanie plików Excel w języku C# jest proste, jeśli dysponuje się odpowiednią biblioteką. IronXL eliminuje zależność od pakietu Office, upraszcza interfejs API i obsługuje formaty XLSX, XLS oraz CSV przy użyciu tej samej ścieżki kodu. Omówione tutaj wzorce — ładowanie skoroszytu, odczytywanie wpisanych wartości komórek, iterowanie zakresów, uruchamianie agregatów i eksportowanie do DataTable — obejmują większość rzeczywistych wymagań dotyczących odczytu arkuszy kalkulacyjnych.

Aby kontynuować opieranie się na tych wzorcach:

• Zapoznaj się z dokumentacją wprowadzającą do IronXL, aby uzyskać wskazówki dotyczące konfiguracji projektu i wymagań środowiskowych.
• Zapoznaj się z poradnikami dotyczącymi pisania, formatowania i tworzenia wykresów.
• Zapoznaj się z przewodnikiem dotyczącym obsługi formuł programu Excel, aby dowiedzieć się, które funkcje programu Excel są automatycznie oceniane przez IronXL.
• Sprawdź stronę licencyjną IronXL, aby zapoznać się z opcjami wdrożenia produkcyjnego.
• Zapoznaj się z blogiem IronXL, aby znaleźć praktyczne przykłady dotyczące walidacji danych, eksportu tabel przestawnych oraz obsługi plików chronionych hasłem.

Dla zespołów oceniających IronXL w porównaniu z innymi bibliotekami, porównanie IronXL vs EPPlus oraz porównanie IronXL vs NPOI obejmują testy wydajnościowe i różnice w API. Oba porównania zawierają przykłady kodu dla równoważnych operacji w każdej bibliotece.

Własna specyfikacja formatu plików Excel firmy Microsoft stanowi przydatne źródło informacji w przypadku napotkania nietypowych struktur arkuszy kalkulacyjnych pochodzących ze starszych systemów. Standard ECMA-376 definiuje format OOXML, który jest stosowany w plikach XLSX.

Zacznij od bezpłatnej licencji próbnej IronXL, aby przetestować pełny interfejs API w swoim własnym projekcie przed zakupem licencji produkcyjnej.