Jak czytać pliki Excel w C# używając IronXL

Jak zainstalować IronXL do przetwarzania plików Excel?

Otwórz konsolę menedżera pakietów NuGet w programie Visual Studio i uruchom następujące polecenie, aby dodać IronXL do swojego projektu. Alternatywnie, jeśli wolisz pracować z terminala, użyj polecenia .NET CLI pokazanego w drugim wierszu:

Install-Package IronXL.Excel

Pakiet instaluje się w kilka sekund i dodaje do projektu jedno odwołanie do zestawu zarządzanego. Nie ma rejestracji COM, nie ma zestawów Office Primary Interop Assemblies i nie ma zależności od konkretnej wersji programu Excel, którymi trzeba by się zajmować.

Po instalacji dodaj dyrektywę using na początku każdego pliku, który pracuje z danymi arkusza kalkulacyjnego:

using IronXL;

using IronXL;

Imports IronXL

Ta pojedyncza przestrzeń nazw zapewnia dostęp do WorkBook, WorkSheet, zakresów komórek, właściwości wartości typowanej, funkcji agregujących i każdego innego typu IronXL. Strona NuGet Gallery poświęcona IronXL.Excel zawiera listę wszystkich dostępnych wersji oraz pełne drzewo zależności.

Jakie formaty plików Excel obsługuje IronXL?

Zrozumienie formatów, z którymi musi radzić sobie aplikacja, kształtuje zarówno wywoływane przez Ciebie wywołania API, jak i decyzje dotyczące przechowywania danych, które podejmuje Twój projekt.

XLSX — domyślny format od wersji Excel 2007 — to archiwum ZIP zawierające pliki XML. Obsługuje ponad milion wierszy, bogate formatowanie, tabele przestawne i nazwane zakresy. Większość nowoczesnych potoków danych generuje pliki w formacie XLSX, więc jest to format, z którym spotykasz się najczęściej.

XLS to starszy format binarny używany w programie Excel 2003 i wcześniejszych wersjach. Niektóre systemy Enterprise nadal eksportują pliki XLS, dlatego niezawodna obsługa tego formatu ma znaczenie podczas integracji ze starszą infrastrukturą. IronXL odczytuje pliki XLS bez konieczności wprowadzania jakichkolwiek specjalnych ustawień.

XLSM rozszerza format XLSX o obsługę makr. IronXL odczytuje dane arkusza kalkulacyjnego z plików XLSM, nawet jeśli nie wykonuje osadzonego kodu VBA, co jest prawidłowym zachowaniem w przypadku ekstrakcji danych po stronie serwera.

CSV i TSV to formaty tabelaryczne w postaci zwykłego tekstu, szeroko stosowane do wymiany danych między systemami. WorkBook.LoadCSV obsługuje pliki rozdzielane przecinkami, a IronXL zwraca ten sam obiekt WorkBook, który twój kod już zna, umożliwiając jednolitą logikę odczytu danych niezależnie od formatu źródłowego.

IronXL automatycznie wykrywa format pliku na podstawie rozszerzenia pliku, gdy wywołujesz WorkBook.Load. W większości przypadków nie ma potrzeby wyraźnego określania formatu, co upraszcza kod, który musi obsługiwać dane wejściowe pochodzące z wielu źródeł.

Jak załadować i otworzyć skoroszyt Excel?

Metoda WorkBook.Load jest punktem wejścia dla wszystkich operacji opartych na plikach. Przekaż ścieżkę do pliku, a IronXL zwróci w pełni wypełniony obiekt skoroszytu, który można natychmiast przeszukiwać:

using IronXL;

// Load the workbook; format is detected automatically
WorkBook workbook = WorkBook.Load("Employees.xlsx");

// Access the first worksheet
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a single cell by A1 address
string companyName = sheet["A1"].StringValue;
Console.WriteLine($"Company: {companyName}");

// Access sheets by name or by zero-based index
WorkSheet byName  = workbook.GetWorkSheet("Sales");
WorkSheet byIndex = workbook.WorkSheets[1];

// Load a password-protected file
WorkBook secured = WorkBook.Load("Confidential.xlsx", "p@ssw0rd");

using IronXL;

// Load the workbook; format is detected automatically
WorkBook workbook = WorkBook.Load("Employees.xlsx");

// Access the first worksheet
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a single cell by A1 address
string companyName = sheet["A1"].StringValue;
Console.WriteLine($"Company: {companyName}");

// Access sheets by name or by zero-based index
WorkSheet byName  = workbook.GetWorkSheet("Sales");
WorkSheet byIndex = workbook.WorkSheets[1];

// Load a password-protected file
WorkBook secured = WorkBook.Load("Confidential.xlsx", "p@ssw0rd");

Imports IronXL

' Load the workbook; format is detected automatically
Dim workbook As WorkBook = WorkBook.Load("Employees.xlsx")

' Access the first worksheet
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read a single cell by A1 address
Dim companyName As String = sheet("A1").StringValue
Console.WriteLine($"Company: {companyName}")

' Access sheets by name or by zero-based index
Dim byName As WorkSheet = workbook.GetWorkSheet("Sales")
Dim byIndex As WorkSheet = workbook.WorkSheets(1)

' Load a password-protected file
Dim secured As WorkBook = WorkBook.Load("Confidential.xlsx", "p@ssw0rd")

Właściwość DefaultWorkSheet zwraca pierwszy arkusz, pokrywając większość plików pojedynczego arkusza. Gdy twój plik zawiera wiele arkuszy, GetWorkSheet pobiera je według nazwy, a WorkSheets[n] pobiera je według indeksu zerowego. Dokumentacja API WorkBook opisuje wszystkie przeciążenia i właściwości obiektu workbook.

VB.NET Czytanie plików Excel przy użyciu IronXL: Przewodnik krok po kroku bez Microsoft Office: Obraz 1 - Instalacja

Jak odczytać wartości komórek wpisanych w programie Excel?

Każda komórka w IronXL udostępnia właściwości typowane, które zwracają wartości w dokładnie takim typie danych, jakiego potrzebujesz — nie jest wymagane ręczne parsowanie ani rzutowanie. Właściwości typowane automatycznie obsługują wymuszanie typu na podstawie reprezentacji komórki:

using IronXL;

WorkBook workbook = WorkBook.Load("Employees.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// Extract typed values from row 2
int      employeeId = sheet["A2"].IntValue;
string   name       = sheet["B2"].StringValue;
string   department = sheet["C2"].StringValue;
decimal  salary     = sheet["D2"].DecimalValue;
DateTime hireDate   = sheet["E2"].DateTimeValue;

Console.WriteLine($"ID:         {employeeId}");
Console.WriteLine($"Name:       {name}");
Console.WriteLine($"Department: {department}");
Console.WriteLine($"Salary:     {salary:C}");
Console.WriteLine($"Hired:      {hireDate:d}");

// Use the Text property for the formatted display value
string formattedSalary = sheet["D2"].Text;   // "$75,000.00"
string formattedDate   = sheet["E2"].Text;   // "28/02/2026"

// Guard against empty cells before reading
if (!sheet["B3"].IsEmpty)
{
    string value = sheet["B3"].StringValue;
}

using IronXL;

WorkBook workbook = WorkBook.Load("Employees.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// Extract typed values from row 2
int      employeeId = sheet["A2"].IntValue;
string   name       = sheet["B2"].StringValue;
string   department = sheet["C2"].StringValue;
decimal  salary     = sheet["D2"].DecimalValue;
DateTime hireDate   = sheet["E2"].DateTimeValue;

Console.WriteLine($"ID:         {employeeId}");
Console.WriteLine($"Name:       {name}");
Console.WriteLine($"Department: {department}");
Console.WriteLine($"Salary:     {salary:C}");
Console.WriteLine($"Hired:      {hireDate:d}");

// Use the Text property for the formatted display value
string formattedSalary = sheet["D2"].Text;   // "$75,000.00"
string formattedDate   = sheet["E2"].Text;   // "28/02/2026"

// Guard against empty cells before reading
if (!sheet["B3"].IsEmpty)
{
    string value = sheet["B3"].StringValue;
}

Imports IronXL

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

' Extract typed values from row 2
Dim employeeId As Integer = sheet("A2").IntValue
Dim name As String = sheet("B2").StringValue
Dim department As String = sheet("C2").StringValue
Dim salary As Decimal = sheet("D2").DecimalValue
Dim hireDate As DateTime = sheet("E2").DateTimeValue

Console.WriteLine($"ID:         {employeeId}")
Console.WriteLine($"Name:       {name}")
Console.WriteLine($"Department: {department}")
Console.WriteLine($"Salary:     {salary:C}")
Console.WriteLine($"Hired:      {hireDate:d}")

' Use the Text property for the formatted display value
Dim formattedSalary As String = sheet("D2").Text   ' "$75,000.00"
Dim formattedDate As String = sheet("E2").Text     ' "28/02/2026"

' Guard against empty cells before reading
If Not sheet("B3").IsEmpty Then
    Dim value As String = sheet("B3").StringValue
End If

Właściwość Text zwraca wartość wyświetlaną dokładnie tak, jak jest sformatowana w Excelu -- przydatne, gdy potrzebujesz sformatowanego ciągu liczbowego zamiast surowej wartości liczbowej. W przypadku komórek zawierających formuły Excel, IronXL oblicza wyrażenie i zwraca wynik obliczeń poprzez te same właściwości typowane. Dodatkowe właściwości wartości -- BoolValue, DoubleValue, FloatValue -- pojawiają się w referencji wartości komórki.

Jak iterować po wierszach i kolumnach w Excelu?

Przetwarzanie każdego rekordu w zbiorze danych wymaga iteracji po wierszach i kolumnach. Składnia zakresów w IronXL odpowiada bezpośrednio notacji A1 w Excelu, więc zaznaczanie bloku komórek jest znane każdemu, kto pisał formuły w arkuszach kalkulacyjnych:

using IronXL;

WorkBook workbook = WorkBook.Load("Employees.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// Iterate a single column range
Console.WriteLine("Employee List:");
foreach (var cell in sheet["B2:B100"])
{
    if (!string.IsNullOrEmpty(cell.Text))
        Console.WriteLine($"  - {cell.Text}");
}

// Iterate all rows and all columns using the Rows property
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
        Console.Write(cell.Text.PadRight(15));
    Console.WriteLine();
}

using IronXL;

WorkBook workbook = WorkBook.Load("Employees.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// Iterate a single column range
Console.WriteLine("Employee List:");
foreach (var cell in sheet["B2:B100"])
{
    if (!string.IsNullOrEmpty(cell.Text))
        Console.WriteLine($"  - {cell.Text}");
}

// Iterate all rows and all columns using the Rows property
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
        Console.Write(cell.Text.PadRight(15));
    Console.WriteLine();
}

Imports IronXL

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

' Iterate a single column range
Console.WriteLine("Employee List:")
For Each cell In sheet("B2:B100")
    If Not String.IsNullOrEmpty(cell.Text) Then
        Console.WriteLine($"  - {cell.Text}")
    End If
Next

' Iterate all rows and all columns using the Rows property
For Each row In sheet.Rows
    For Each cell In row
        Console.Write(cell.Text.PadRight(15))
    Next
    Console.WriteLine()
Next

Zakres sheet["B2:B100"] zwraca kolekcję komórek w postaci enum. Sprawdzanie string.IsNullOrEmpty umożliwia pominięcie pustych wierszy w elegancki sposób. Właściwość Rows -- udokumentowana w przewodniku dotyczącym zakresu danych arkusza -- przechodzi przez arkusz wiersz po wierszu i ujawnia komórki każdego wiersza, bez potrzeby wcześniejszej wiedzy o liczbie kolumn.

Jak przeprowadzić obliczenia sumaryczne na danych z Excela?

IronXL zawiera wbudowane funkcje agregujące, które obliczają wyniki bezpośrednio na zakresach komórek — nie są wymagane ręczne pętle sumujące:

using IronXL;

WorkBook workbook = WorkBook.Load("Employees.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// Built-in aggregate methods work on any named range
decimal total   = sheet["D2:D200"].Sum();
decimal highest = sheet["D2:D200"].Max();
decimal lowest  = sheet["D2:D200"].Min();
decimal average = sheet["D2:D200"].Avg();

Console.WriteLine($"Total Payroll:  {total:C}");
Console.WriteLine($"Highest Salary: {highest:C}");
Console.WriteLine($"Lowest Salary:  {lowest:C}");
Console.WriteLine($"Average Salary: {average:C}");

// Combine with LINQ for filtered aggregation
decimal itTotal = sheet["D2:D200"]
    .Where(c => sheet[$"C{c.RowIndex}"].StringValue == "IT")
    .Sum(c => c.DecimalValue);
Console.WriteLine($"IT Department Total: {itTotal:C}");

using IronXL;

WorkBook workbook = WorkBook.Load("Employees.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// Built-in aggregate methods work on any named range
decimal total   = sheet["D2:D200"].Sum();
decimal highest = sheet["D2:D200"].Max();
decimal lowest  = sheet["D2:D200"].Min();
decimal average = sheet["D2:D200"].Avg();

Console.WriteLine($"Total Payroll:  {total:C}");
Console.WriteLine($"Highest Salary: {highest:C}");
Console.WriteLine($"Lowest Salary:  {lowest:C}");
Console.WriteLine($"Average Salary: {average:C}");

// Combine with LINQ for filtered aggregation
decimal itTotal = sheet["D2:D200"]
    .Where(c => sheet[$"C{c.RowIndex}"].StringValue == "IT")
    .Sum(c => c.DecimalValue);
Console.WriteLine($"IT Department Total: {itTotal:C}");

Imports IronXL

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

' Built-in aggregate methods work on any named range
Dim total As Decimal = sheet("D2:D200").Sum()
Dim highest As Decimal = sheet("D2:D200").Max()
Dim lowest As Decimal = sheet("D2:D200").Min()
Dim average As Decimal = sheet("D2:D200").Avg()

Console.WriteLine($"Total Payroll:  {total:C}")
Console.WriteLine($"Highest Salary: {highest:C}")
Console.WriteLine($"Lowest Salary:  {lowest:C}")
Console.WriteLine($"Average Salary: {average:C}")

' Combine with LINQ for filtered aggregation
Dim itTotal As Decimal = sheet("D2:D200") _
    .Where(Function(c) sheet($"C{c.RowIndex}").StringValue = "IT") _
    .Sum(Function(c) c.DecimalValue)
Console.WriteLine($"IT Department Total: {itTotal:C}")

Sum, Min, Max i Avg automatycznie pomijają puste komórki i obsługują konwersję liczbową w tle. Łączenie zapytań LINQ w zakresie pozwala uzyskać filtrowane agregaty — sumy częściowe według działów, sumy w zakresie dat oraz liczbę warunkową — a wszystko to bez opuszczania interfejsu API IronXL.

Jak zbudować kompletny czytnik danych pracowników?

Poniższy przykład łączy wszystkie omówione dotychczas elementy w gotową do użycia aplikację konsolową, która ładuje arkusz kalkulacyjny pracowników, formatuje każdy rekord, sumuje wynagrodzenia, obsługuje zapis zwrotny i płynnie przechwytuje błędy:

using IronXL;

try
{
    WorkBook workbook = WorkBook.Load("Employees.xlsx");
    WorkSheet sheet   = workbook.DefaultWorkSheet;

    Console.WriteLine("=== Employee Data Report ===\n");

    int     rowNumber     = 2;
    decimal totalSalary   = 0m;
    int     employeeCount = 0;

    while (!string.IsNullOrEmpty(sheet[$"A{rowNumber}"].StringValue))
    {
        int      id         = sheet[$"A{rowNumber}"].IntValue;
        string   name       = sheet[$"B{rowNumber}"].StringValue;
        string   department = sheet[$"C{rowNumber}"].StringValue;
        decimal  salary     = sheet[$"D{rowNumber}"].DecimalValue;

        Console.WriteLine($"{id,4}  {name,-20}  {department,-15}  {salary,10:C}");

        totalSalary   += salary;
        employeeCount += 1;
        rowNumber     += 1;
    }

    Console.WriteLine($"\nTotal Employees: {employeeCount}");
    Console.WriteLine($"Total Payroll:   {totalSalary:C}");

    // Write a new record back to the sheet and save
    sheet["A10"].Value = 1010;
    sheet["B10"].Value = "Jane Doe";
    sheet["C10"].Value = "Finance";
    sheet["D10"].Value = 75000;
    workbook.SaveAs("Employees-Updated.xlsx");
}
catch (Exception ex)
{
    Console.WriteLine($"Error reading Excel file: {ex.Message}");
}

using IronXL;

try
{
    WorkBook workbook = WorkBook.Load("Employees.xlsx");
    WorkSheet sheet   = workbook.DefaultWorkSheet;

    Console.WriteLine("=== Employee Data Report ===\n");

    int     rowNumber     = 2;
    decimal totalSalary   = 0m;
    int     employeeCount = 0;

    while (!string.IsNullOrEmpty(sheet[$"A{rowNumber}"].StringValue))
    {
        int      id         = sheet[$"A{rowNumber}"].IntValue;
        string   name       = sheet[$"B{rowNumber}"].StringValue;
        string   department = sheet[$"C{rowNumber}"].StringValue;
        decimal  salary     = sheet[$"D{rowNumber}"].DecimalValue;

        Console.WriteLine($"{id,4}  {name,-20}  {department,-15}  {salary,10:C}");

        totalSalary   += salary;
        employeeCount += 1;
        rowNumber     += 1;
    }

    Console.WriteLine($"\nTotal Employees: {employeeCount}");
    Console.WriteLine($"Total Payroll:   {totalSalary:C}");

    // Write a new record back to the sheet and save
    sheet["A10"].Value = 1010;
    sheet["B10"].Value = "Jane Doe";
    sheet["C10"].Value = "Finance";
    sheet["D10"].Value = 75000;
    workbook.SaveAs("Employees-Updated.xlsx");
}
catch (Exception ex)
{
    Console.WriteLine($"Error reading Excel file: {ex.Message}");
}

Imports IronXL

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

    Console.WriteLine("=== Employee Data Report ===" & vbCrLf)

    Dim rowNumber As Integer = 2
    Dim totalSalary As Decimal = 0D
    Dim employeeCount As Integer = 0

    While Not String.IsNullOrEmpty(sheet($"A{rowNumber}").StringValue)
        Dim id As Integer = sheet($"A{rowNumber}").IntValue
        Dim name As String = sheet($"B{rowNumber}").StringValue
        Dim department As String = sheet($"C{rowNumber}").StringValue
        Dim salary As Decimal = sheet($"D{rowNumber}").DecimalValue

        Console.WriteLine($"{id,4}  {name,-20}  {department,-15}  {salary,10:C}")

        totalSalary += salary
        employeeCount += 1
        rowNumber += 1
    End While

    Console.WriteLine(vbCrLf & $"Total Employees: {employeeCount}")
    Console.WriteLine($"Total Payroll:   {totalSalary:C}")

    ' Write a new record back to the sheet and save
    sheet("A10").Value = 1010
    sheet("B10").Value = "Jane Doe"
    sheet("C10").Value = "Finance"
    sheet("D10").Value = 75000
    workbook.SaveAs("Employees-Updated.xlsx")
Catch ex As Exception
    Console.WriteLine($"Error reading Excel file: {ex.Message}")
End Try

Pętla while kończy się, gdy kolumna A staje się pusta, umożliwiając czytnikowi dostosowanie się do arkuszy kalkulacyjnych o dowolnej długości bez potrzeby wprowadzonego na stałe wiersza. Zapisywanie wartości z powrotem odbywa się za pomocą tej samej składni adresu komórki co odczyt, a SaveAs zapisuje zmiany do nowego pliku, dzięki czemu oryginał pozostaje nietknięty. Blok try/catch obsługuje brakujące pliki, zablokowane skoroszyty i uszkodzone dane -- wszystkie scenariusze, które mogą wystąpić w środowiskach produkcyjnych, gdzie pliki wejściowe pochodzą z zewnętrznych źródeł.

Jak radzisz sobie z zaawansowanymi scenariuszami czytania?

W rzeczywistych projektach pojawia się kilka mniej powszechnych, ale ważnych scenariuszy. Nazwane zakresy, wykrywanie arkuszy i ładowanie plików CSV mają dedykowane wsparcie API.

Zakresy nazwane pozwalają odwoływać się do danych za pomocą logicznej etykiety zamiast adresu komórki. Jeśli autor skoroszytu zdefiniował nazwany zakres o nazwie SalaryTable, możesz uzyskać do niego dostęp bezpośrednio przez GetRangeByName:

var range = workbook.GetRangeByName("SalaryTable");
decimal total = range.Sum();
Console.WriteLine($"Named range total: {total:C}");

var range = workbook.GetRangeByName("SalaryTable");
decimal total = range.Sum();
Console.WriteLine($"Named range total: {total:C}");

Dim range = workbook.GetRangeByName("SalaryTable")
Dim total As Decimal = range.Sum()
Console.WriteLine($"Named range total: {total:C}")

Funkcja discovery arkusza wylicza wszystkie arkusze w skoroszycie, co jest przydatne podczas przetwarzania plików o zmiennej liczbie zakładek:

foreach (WorkSheet ws in workbook.WorkSheets)
    Console.WriteLine($"Sheet: {ws.Name}, Rows: {ws.RowCount}");

foreach (WorkSheet ws in workbook.WorkSheets)
    Console.WriteLine($"Sheet: {ws.Name}, Rows: {ws.RowCount}");

For Each ws As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {ws.Name}, Rows: {ws.RowCount}")
Next

Ładowanie CSV używa dedykowanej metody zoptymalizowanej dla plików tekstowych, zwracającej WorkSheet, którym można nawigować za pomocą tego samego API zakresu:

WorkBook csv    = WorkBook.LoadCSV("data.csv");
WorkSheet first = csv.DefaultWorkSheet;
Console.WriteLine(first["A1"].StringValue);

WorkBook csv    = WorkBook.LoadCSV("data.csv");
WorkSheet first = csv.DefaultWorkSheet;
Console.WriteLine(first["A1"].StringValue);

Dim csv As WorkBook = WorkBook.LoadCSV("data.csv")
Dim first As WorkSheet = csv.DefaultWorkSheet
Console.WriteLine(first("A1").StringValue)

Wzory te obejmują zaawansowane scenariusze odczytu, które pojawiają się w projektach migracji danych, potokach ETL i zautomatyzowanych systemach raportowania. Pełny opis interfejsu API znajduje się w dokumentacji obiektów IronXL.

Dodatkowe wiarygodne źródła:

• Strona główna dokumentacji IronXL
• Jak edytować formuły w Excelu
• Jak korzystać z funkcji matematycznych
• Jak zaznaczyć zakresy
• Specyfikacja ECMA-376 Open XML — autorytatywny standard definiujący format XLSX
• Dokumentacja Microsoft Open XML SDK — materiały referencyjne dotyczące podstawowej struktury plików
• NuGet Gallery -- IronXL.Excel -- strona pakietu z historią wersji i statystykami pobrań

Jakie są Twoje kolejne kroki?

IronXL zamienia odczytywanie plików Excel z pełnego zależności wyzwania Interop w kilka linii prostego kodu C#. Ładowanie skoroszytów, wyodrębnianie wpisanych wartości, iteracja wiersz po wierszu, wykonywanie obliczeń agregacyjnych i obsługa przypadków skrajnych — wszystko to odbywa się zgodnie z tym samym, spójnym wzorcem API — bez konieczności instalowania pakietu Microsoft Office w środowisku wdrożeniowym.

Przejście od samouczka do produkcji:

1. Bezpłatna próba, aby odblokować pełny zestaw funkcji IronXL i przetestować go na własnych plikach Excel przed zakupem licencji.
2. Zapoznaj się z pełną dokumentacją IronXL, aby uzyskać wskazówki dotyczące pisania, formatowania, stylizacji i konwersji arkuszy kalkulacyjnych.
3. Zapoznaj się z dokumentacją obiektów i pełnym API, aby odkryć wszystkie klasy, metody i właściwości dostępne w bibliotece.
4. Zapoznaj się z instrukcją tworzenia arkuszy kalkulacyjnych, jeśli Twój proces pracy wymaga generowania plików wyjściowych, a także odczytu plików wejściowych.
5. Sprawdź indeks wpisów na blogu IronXL, aby znaleźć dodatkowe samouczki dotyczące rzeczywistych scenariuszy, takich jak generowanie raportów, walidacja danych i konsolidacja wielu arkuszy.