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

Jaki jest najlepszy sposób na czytanie plików Excel w 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 czytania w Excelu z IronXL obejmuje pełny 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

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

Install-Package IronXL.Excel

Po instalacji dodaj dyrektywę using IronXL; do każdego pliku, który potrzebuje dostępu do arkuszy kalkulacyjnych. 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ą wymagane ż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 akceptuje ś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 utrzymuje dostępność wszystkich danych arkusza. Każda instancja WorkSheet odpowiada zakładce w pliku. Dostęp przez indeks (WorkSheets[0]) jest niezawodny dla plików z jedną zakładką; 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 zwróci 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"] używa standardowego notacji Excela. 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 odczytu wartości komórki pokazuje dodatkowe typowane akcesory włącznie z DateTimeValue do komórek sformatowanych jako daty.

Kiedy komórka zawiera liczbę zapisaną jako tekst (częsty problem z jakością danych w eksportowanych arkuszach kalkulacyjnych), StringValue zwraca tekst w stanie nienaruszonym, podczas gdy DecimalValue próbuje je sparsować i zwraca 0 w razie niepowodzenia. 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 zakresu "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 działa dobrze przy eksportowaniu do List<t>, DataTable, lub bazy danych.

Właściwość sheet.RowCount odzwierciedla ostatnio użyty wiersz w arkuszu, więc pętla kończy się automatycznie, kiedy dane się kończą. Przewodnik iteracji zakresu Excel obejmuje dodatkowe wzorce itereacji, w tym przeszukiwanie kolumnowe.

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

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 konwersji CSV na XLSX obejmuje dostosowywanie separatorów dla 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($"Duze 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($"Duze 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($"Duze 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 kolumny i projektowanie wyników w silnie typowane obiekty -- wzory, które eliminują dużo boilerplatu w kodzie rurociągu danych.

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

Wiele aplikacji .NET wczytuje dane z arkuszy kalkulacyjnych do ADO.NET DataTable dla dalszego przetwarzania lub umieszczania w bazie 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

Przekazywanie true do ToDataTable traktuje pierwszy wiersz arkusza jako nagłówki kolumn. Powstały DataTable używa nazw kolumn ciągów dopasowanych do tekstu nagłówka, dzięki czemu następujące zapytania LINQ-to-DataSet są czytelne. Dokumentacja eksportu DataTable obejmuje opcje obsługi null i wnioskowania typów danych.

Ten wzorzec jest szczególnie użyteczny, kiedy kod końcowy już oczekuje DataTable -- na przykład, gdy wywołujesz SqlBulkCopy by wstawić wiersze do SQL Server. Możesz wczytać plik XLSX, przekonwertować go na DataTable, i masowo zaimportować bez pisania szablonu mapowania kolumn.

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 -- wczytywanie skoroszytu, odczyt wartości typowanych komórek, iteracja zakresów, uruchamianie agregatów i eksport do DataTable -- pokrywają większość rzeczywistych wymagań 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.
• Przejrzyj przewodnik po wsparciu formuł Excel, aby zrozumieć, które funkcje Excel IronXL ocenia automatycznie.
• 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 stosunku do innych bibliotek, porównanie IronXL z EPPlus i porównanie IronXL z NPOI obejmują wyniki punktowe wydajności 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.