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
dotnet add package IronXl.Excel

Install-Package IronXl.Excel
dotnet add 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 typowanych, funkcji agregujących oraz wszystkich innych typów 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 rozdzielone przecinkami, a IronXL zwraca ten sam obiekt WorkBook, po którym Twój kod już potrafi nawigować, dzięki czemu logika odczytu danych pozostaje spójna niezależnie od formatu źródłowego.

IronXL automatycznie rozpoznaje format pliku na podstawie rozszerzenia pliku po wywołaniu 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 stanowi punkt 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, obejmujący większość plików jednostronicowych. Gdy plik zawiera wiele arkuszy, GetWorkSheet pobiera według nazwy, a WorkSheets[n] pobiera według indeksu zaczynającego się od zera. Dokumentacja API WorkBook opisuje wszystkie przeciążenia i właściwości obiektu workbook.

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 wymagańe 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 została sformatowana w programie Excel — jest to przydatne, gdy potrzebny jest sformatowany ciąg liczbowy, a nie surowa wartość liczbowa. 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 odniesieniu do 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ę obiektów komórek, którą można wyliczać. Sprawdzanie string.IsNullOrEmpty płynnie pomija puste wiersze. Właściwość Rows — opisana w przewodniku po zakresach danych arkusza — przechodzi przez arkusz po jednym wierszu na raz i udostępnia komórki każdego wiersza bez konieczności wcześniejszej znajomości liczby 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ą wymagańe 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 oraz Avg automatycznie pomijają puste komórki i w tle zajmują się konwersją liczb. Łączenie zapytań LINQ w zakresie pozwala uzyskać filtrowane agregaty — sumy częściowe według działów, sumy w zakresie dat oraz liczbę warunkówą — 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 zostanie opróżniona, dzięki czemu czytnik dostosowuje się do arkuszy kalkulacyjnych o dowolnej długości bez konieczności stosowania sztywnego, zakodowanego na stałe liczby wierszy. Zapisywanie wartości odbywa się przy użyciu tej samej składni adresów komórek, co odczyt, a SaveAs zapisuje zmiany w nowym pliku, dzięki czemu oryginał pozostaje nienaruszony. Blok try/catch obsługuje brakujące pliki, zablokowane skoroszyty i uszkodzone dane — wszystkie scenariusze, które występują w środowiskach produkcyjnych, gdzie pliki wejściowe pochodzą ze źródeł zewnętrznych.

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żna uzyskać do niego dostęp bezpośrednio poprzez 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 plików CSV wykorzystuje dedykowaną metodę zoptymalizowaną pod kątem plików tekstowych, zwracającą WorkSheet, którą można przeglądać za pomocą tego samego interfejsu 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. Rozpocznij bezpłatny okres próbny, 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.