Jak importować plik Excel w C#

Jakie kluczowe funkcje sprawiają, że IronXL jest niezbędny do importu z Excela?

• Otwieraj i przeglądaj pliki Excel oraz wyszukuj dane z różnych formatów arkuszy kalkulacyjnych, takich jak pliki XLS/CSV/TSV/XLSX, bez konieczności instalowania programu Excel
• Eksportuj arkusze Excel do wielu formatów, w tym XLS/XLSX/CSV/TSV/JSON, a nawet HTML
• Szyfrowanie i deszyfrowanie plików XLSM/XLTX/XLSX za pomocą haseł w celu zwiększenia bezpieczeństwa
• Importuj arkusz Excel jako obiekty System.Data.DataSet i System.Data.DataTable w celu płynnej integracji z bazą danych
• Formuły w pliku Excel są przeliczane automatycznie przy każdej edycji arkusza
• Intuicyjne ustawienia zakresu komórek z prostą składnią WorkSheet["A1:B10"] do wybierania zakresów
• Sortowanie zakresów komórek, kolumn i wierszy za pomocą wbudowanych metod
• Kompleksowe formatowanie komórek, w tym dostosowanie czcionki, kolorów tła, obramowań i wyrównania oraz formatów numeracji

Czego potrzebuję przed rozpoczęciem importu z Excela?

Aby używać IronXL w języku C# do odczytu plików Excel, upewnij się, że na komputerze zainstalowane są następujące komponenty:

1. Visual Studio — jest to oficjalne środowisko IDE do tworzenia aplikacji C# .NET. Visual Studio zapewnia doskonałe IntelliSense wsparcie i narzędzia do debugowania, które ułatwiają pracę z plikami Excel. Program Visual Studio można pobrać i zainstalować ze strony internetowej firmy Microsoft. Wersja Community Edition jest bezpłatna i wystarczająca dla większości potrzeb programistycznych.

2. Biblioteka IronXL — jest to biblioteka, która ułatwia pracę z arkuszami Excel w określonej ścieżce w języku C#. Przed użyciem należy zainstalować go w programie C#. IronXL można łatwo pobrać ze strony NuGet lub zainstalować bezpośrednio za pomocą interfejsu Zarządzaj pakietami NuGet w narzędziach Visual Studio. Możesz również pobrać plik .NET Excel DLL bezpośrednio, jeśli wolisz ręczną instalację.

W przypadku wdrożeń produkcyjnych konieczne będzie zastosowanie klucza licencyjnego w celu usunięcia znaków wodnych i włączenia pełnej funkcjonalności. Rozwój i testowanie można przeprowadzić przy użyciu wersji próbnej.

Jakie przestrzenie nazw powinienem dodać do mojego kodu?

Po zainstalowaniu Visual Studio i IronXL należy odwołać się do zestawu IronXL, aby używać IronXL w kodzie źródłowym. Dodaj następujący wiersz kodu na początku pliku w nowym projekcie, w którym będą używane funkcje IronXL:

using IronXL;

using IronXL;

Imports IronXL

Ten pojedynczy import przestrzeni nazw zapewnia dostęp do wszystkich podstawowych funkcji potrzebnych do obsługi programu Excel. Jeśli pracujesz z konkretnymi funkcjami programu Excel, takimi jak wykresy lub formatowanie warunkówe, może być konieczne zaimportowanie dodatkowych przestrzeni nazw z biblioteki IronXL.

Jak załadować i otworzyć plik Excel?

// Supported Excel spreadsheet formats for reading include: XLSX, XLS, CSV, and TSV
WorkBook workbook = WorkBook.Load("test.xlsx");

// You can also load from a stream
using (var stream = File.OpenRead("test.xlsx"))
{
    WorkBook streamWorkbook = WorkBook.Load(stream);
}

// Or load CSV files with custom delimiters
WorkBook csvWorkbook = WorkBook.LoadCSV("data.csv", delimiter: ",");

// Supported Excel spreadsheet formats for reading include: XLSX, XLS, CSV, and TSV
WorkBook workbook = WorkBook.Load("test.xlsx");

// You can also load from a stream
using (var stream = File.OpenRead("test.xlsx"))
{
    WorkBook streamWorkbook = WorkBook.Load(stream);
}

// Or load CSV files with custom delimiters
WorkBook csvWorkbook = WorkBook.LoadCSV("data.csv", delimiter: ",");

' Supported Excel spreadsheet formats for reading include: XLSX, XLS, CSV, and TSV
Dim workbook As WorkBook = WorkBook.Load("test.xlsx")

' You can also load from a stream
Using stream = File.OpenRead("test.xlsx")
    Dim streamWorkbook As WorkBook = WorkBook.Load(stream)
End Using

' Or load CSV files with custom delimiters
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("data.csv", delimiter:=",")

// Get the first worksheet
WorkSheet sheet = workbook.WorkSheets.First();

// Or access by worksheet name
WorkSheet namedSheet = workbook.GetWorkSheet("Sheet1");

// Or by index (zero-based)
WorkSheet indexedSheet = workbook.WorkSheets[0];

// Get the first worksheet
WorkSheet sheet = workbook.WorkSheets.First();

// Or access by worksheet name
WorkSheet namedSheet = workbook.GetWorkSheet("Sheet1");

// Or by index (zero-based)
WorkSheet indexedSheet = workbook.WorkSheets[0];

' Get the first worksheet
Dim sheet As WorkSheet = workbook.WorkSheets.First()

' Or access by worksheet name
Dim namedSheet As WorkSheet = workbook.GetWorkSheet("Sheet1")

' Or by index (zero-based)
Dim indexedSheet As WorkSheet = workbook.WorkSheets(0)

Jak odczytać konkretne wartości komórek po zaimportowaniu?

Po zaimportowaniu pliku Excel jest on gotowy do odczytu danych. Odczytywanie danych z plików Excel w języku C# przy użyciu IronXL jest bardzo proste i łatwe. Wartości komórek programu Excel można odczytać, po prostu podając numer odwołania do komórki w standardowej notacji programu Excel (np. "A1", "B2" itp.). Biblioteka zapewnia wiele sposobów uzyskiwania dostępu do wartości komórek w zależności od oczekiwanego typu danych.

Poniższy kod pobiera wartość komórki o numerze odniesienia "C2":

// Select cells easily in Excel-notation and return the value
int cellValue = sheet["C2"].IntValue;

// Display the value
Console.WriteLine(cellValue);

// You can also access different data types
string textValue = sheet["A2"].StringValue;
decimal decimalValue = sheet["C2"].DecimalValue;
double doubleValue = sheet["C2"].DoubleValue;
DateTime dateValue = sheet["D2"].DateTimeValue;
bool boolValue = sheet["E2"].BoolValue;

// Check if cell is empty
bool isEmpty = sheet["F2"].IsEmpty;

// Select cells easily in Excel-notation and return the value
int cellValue = sheet["C2"].IntValue;

// Display the value
Console.WriteLine(cellValue);

// You can also access different data types
string textValue = sheet["A2"].StringValue;
decimal decimalValue = sheet["C2"].DecimalValue;
double doubleValue = sheet["C2"].DoubleValue;
DateTime dateValue = sheet["D2"].DateTimeValue;
bool boolValue = sheet["E2"].BoolValue;

// Check if cell is empty
bool isEmpty = sheet["F2"].IsEmpty;

' Select cells easily in Excel-notation and return the value
Dim cellValue As Integer = sheet("C2").IntValue

' Display the value
Console.WriteLine(cellValue)

' You can also access different data types
Dim textValue As String = sheet("A2").StringValue
Dim decimalValue As Decimal = sheet("C2").DecimalValue
Dim doubleValue As Double = sheet("C2").DoubleValue
Dim dateValue As DateTime = sheet("D2").DateTimeValue
Dim boolValue As Boolean = sheet("E2").BoolValue

' Check if cell is empty
Dim isEmpty As Boolean = sheet("F2").IsEmpty

Oto wynik:

Wynik konsoli debugowania po pomyślnym odczytaniu pliku Excel w języku C#. Program zakończył działanie i czeka na polecenie użytkownika, aby się zamknąć.

Teraz odczytajmy dane z zakresu komórek w otwartym pliku Excel. IronXL ułatwia pracę z zakresami komórek przy użyciu znanej notacji programu Excel. Kod wygląda następująco:

// Read from a range of cells elegantly.
foreach (var cell in sheet["A2:A6"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// You can also work with entire rows or columns
var row = sheet.GetRow(2); // Get row 3 (0-indexed)
foreach (var cell in row)
{
    Console.WriteLine($"Row cell value: {cell.Value}");
}

// Or get a column
var column = sheet.GetColumn(0); // Get column A
foreach (var cell in column)
{
    Console.WriteLine($"Column A value: {cell.Value}");
}

// Read from a range of cells elegantly.
foreach (var cell in sheet["A2:A6"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// You can also work with entire rows or columns
var row = sheet.GetRow(2); // Get row 3 (0-indexed)
foreach (var cell in row)
{
    Console.WriteLine($"Row cell value: {cell.Value}");
}

// Or get a column
var column = sheet.GetColumn(0); // Get column A
foreach (var cell in column)
{
    Console.WriteLine($"Column A value: {cell.Value}");
}

' Read from a range of cells elegantly.
For Each cell In sheet("A2:A6")
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
Next

' You can also work with entire rows or columns
Dim row = sheet.GetRow(2) ' Get row 3 (0-indexed)
For Each cell In row
    Console.WriteLine($"Row cell value: {cell.Value}")
Next

' Or get a column
Dim column = sheet.GetColumn(0) ' Get column A
For Each cell In column
    Console.WriteLine($"Column A value: {cell.Value}")
Next

Kod jest bardzo prosty, przejrzysty i zrozumiały. Zakres komórek można odwołać za pomocą prostej składni, jak pokazano w pętli foreach: sheet["A2:A6"], a każda komórka może być iterowana w celu uzyskania jej wartości. Tutaj zobaczysz nazwy z kolumny A od wiersza 2 do wiersza 6 na wyjściu konsoli:

Wynik konsoli pokazujący pomyślne odczytanie zakresu komórek Excela (A2:A6) zawierających nazwy przy użyciu języka C#

Aby uzyskać więcej informacji na temat odczytu i zapisu wartości komórek, zapoznaj się z tym samouczkiem dotyczącym odczytu plików Excel w języku C#. Możesz również zapoznać się z zaawansowanymi funkcjami, takimi jak stosowanie formuł lub praca z nazwanymi zakresami.

Jak zaimportować całe arkusze naraz?

WorkBook workbook = WorkBook.Load("test.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

// Traverse all rows of Excel WorkSheet
for (int i = 0; i < sheet.Rows.Count(); i++)
{
    // Traverse all columns of specific Row
    for (int j = 0; j < sheet.Columns.Count(); j++)
    {
        // Get the values
        string val = sheet.Rows[i].Columns[j].Value.ToString();
        Console.Write("{0}\t", val);
    }
    Console.WriteLine();
}

// Alternative method using LINQ for more efficient processing
var allData = sheet.Rows.SelectMany(row => 
    row.Columns.Select(col => col.Value?.ToString() ?? "")).ToList();

WorkBook workbook = WorkBook.Load("test.xlsx");
WorkSheet sheet = workbook.WorkSheets.First();

// Traverse all rows of Excel WorkSheet
for (int i = 0; i < sheet.Rows.Count(); i++)
{
    // Traverse all columns of specific Row
    for (int j = 0; j < sheet.Columns.Count(); j++)
    {
        // Get the values
        string val = sheet.Rows[i].Columns[j].Value.ToString();
        Console.Write("{0}\t", val);
    }
    Console.WriteLine();
}

// Alternative method using LINQ for more efficient processing
var allData = sheet.Rows.SelectMany(row => 
    row.Columns.Select(col => col.Value?.ToString() ?? "")).ToList();

Dim workbook As WorkBook = WorkBook.Load("test.xlsx")
Dim sheet As WorkSheet = workbook.WorkSheets.First()

' Traverse all rows of Excel WorkSheet
For i As Integer = 0 To sheet.Rows.Count() - 1
    ' Traverse all columns of specific Row
    For j As Integer = 0 To sheet.Columns.Count() - 1
        ' Get the values
        Dim val As String = sheet.Rows(i).Columns(j).Value.ToString()
        Console.Write("{0}" & vbTab, val)
    Next
    Console.WriteLine()
Next

' Alternative method using LINQ for more efficient processing
Dim allData = sheet.Rows.SelectMany(Function(row) 
    row.Columns.Select(Function(col) If(col.Value?.ToString(), ""))).ToList()

// Convert worksheet to DataTable for easier manipulation
DataTable dataTable = sheet.ToDataTable(true); // true = first row contains headers

// Process data using DataTable methods
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

// Convert worksheet to DataTable for easier manipulation
DataTable dataTable = sheet.ToDataTable(true); // true = first row contains headers

// Process data using DataTable methods
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

' Convert worksheet to DataTable for easier manipulation
Dim dataTable As DataTable = sheet.ToDataTable(True) ' True = first row contains headers

' Process data using DataTable methods
For Each row As DataRow In dataTable.Rows
    For Each item In row.ItemArray
        Console.Write($"{item}" & vbTab)
    Next
    Console.WriteLine()
Next

Jakie są kolejne kroki po zaimportowaniu plików Excel?

W tym artykułe pokazano, jak zaimportować i odczytać plik Excel w języku C# bez zainstalowanego programu Microsoft Excel. Obejmowało to wiele sposobów odczytu danych z arkusza kalkulacyjnego Excel, od pojedynczych komórek po całe arkusze. IronXL pomaga również tworzyć pliki Excel w języku C# bez konieczności instalowania programu Excel.

Po pomyślnym zaimportowaniu danych z Excela warto zapoznać się z dodatkowymi funkcjami:

• Przetwarzanie danych: sortowanie zakresów komórek, stosowanie filtrów lub grupowanie wierszy i kolumn
• Walidacja danych: Wprowadź reguły walidacji danych, aby zapewnić ich integralność
• Formatowanie: zastosuj stylizację komórek, formatowanie warunkówe lub formaty liczb
• Wykresy i elementy wizualne: Twórz wykresy lub dodawaj obrazy, aby uatrakcyjnić prezentację danych
• Bezpieczeństwo: Zabezpiecz skoroszyty lub poszczególne arkusze hasłem

IronXL zapewnia kompleksowe rozwiązanie do programowego wykonywania wszystkich zadań związanych z dokumentami Microsoft Excel. Możesz wykonywać obliczenia formuł, sortować ciągi znaków lub liczby, przycinać i dołączać, wyszukiwać i zamieniać, łączyć i rozdzielać komórki, zapisywać pliki i wiele więcej. Można edytować wartości komórek, a także ustawiać formaty danych w komórkach oraz weryfikować dane w arkuszu kalkulacyjnym. Obsługuje również pliki CSV i pomaga w płynnej pracy z danymi programu Excel.

W przypadku aplikacji Enterprise warto rozważyć opcje wdrażania na różnych platformach, w tym kontenerach Docker, Azure Functions i AWS Lambda.

IronXL jest dostępny w ramach bezpłatnej wersji próbnej, a licencję na użytkowanie komercyjne w pakiecie Lite można nabyć już od $799. Biblioteka oferuje doskonałą dokumentację, samouczki i przykłady kodu, które pomogą Ci szybko rozpocząć pracę z plikami Excel w aplikacjach C#.