IronXL pozwala otwierac i odczytywac pliki Excel w C# bez zainstalowanego Microsoft Office — wystarczy zainstalowac pakiet NuGet, zaladowac skoroszyt za pomoca WorkBook.Load("file.xlsx"), a nastepnie uzyskac dostep do dowolnego arkusza, komorki lub zakresu z typowanymi wartosciami i automatyczna detekcja formatu.

Jeśli kiedykolwiek próbowałeś otworzyć pliki Excel programowo bez Microsoft Office, wiesz, jak skomplikowane może być tradycyjne podejście Interop. Interop opiera się na zainstalowanej aplikacji Excel, wymaga złożonych referencji COM i często powoduje konflikty wersji — szczególnie na serwerach lub w środowiskach chmurowych, gdzie Office nie jest dostępny.

IronXL to nowoczesna biblioteka .NET, która pozwala czytać pliki XLSX, XLS, CSV i TSV bez potrzeby zależności od Office. Możesz pisać czysty, niezawodny kod C#, przetwarzać pliki Excel na Windows, Linux albo w chmurze, i ominąć wszelkie problemy związane z automatyzacją COM. Ten przewodnik przeprowadza przez wszystko, od instalacji po wzorce gotowe do produkcji do otwierania i czytania zeszytów Excel.

Jak zainstalować IronXL w projekcie .NET?

Rozpoczęcie zajmuje tylko kilka sekund. Otwórz swój projekt i użyj jednego z poniższych menedżerów pakietów:

Install-Package IronXL.Excel

Alternatywnie otwórz Visual Studio, kliknij prawym przyciskiem projekt, wybierz "Zarządzaj pakietami NuGet", wyszukaj "IronXL" i kliknij Zainstaluj. Przewodnik instalacji obejmuje wszystkie obsługiwane środowiska, w tym Docker i Azure.

Po zainstalowaniu dodaj przestrzeń nazw na początku pliku:

using IronXL;

using IronXL;

Imports IronXL

Imports IronXL

Ta pojedyncza linia to wszystko, co potrzebujesz. Nie ma złożonych referencji COM, zależności Office ani określonych dla wersji zestawów. Aby uzyskać klucz oceniania za darmo, odwiedź stronę licencji próby IronXL.

Dlaczego IronXL jest łatwiejsze niż tradycyjne Interop?

Tradycyjne Interop Excel wymaga zainstalowanego Microsoft Office na każdej maszynie, która uruchamia twój kod. To jest niepraktyczne dla wdrożeń serwerowych, funkcji AWS Lambda i aplikacji kontenerowych. IronXL zajmuje się całym parsowaniem plików Excel wewnętrznie, dostarczając czyste API, które działa bez żadnych zewnętrznych zależności.

Z Interop, nalezy rowniez ostroznie zarzadzac życiorysami obiektow COM, aby zapobiec wyciekom pamieci — kazdy obiekt Application, Workbook i Worksheet musi byc jawnie zwolniony, w przeciwnym razie procesy Excela kumulują sie w tle. IronXL używa standardowego zbierania pamięci .NET, więc nigdy nie musisz myśleć o sprzątaniu COM.

Biblioteka obsługuje .NET Framework 4.6.2 i nowsze, jak również .NET 5, 6, 7, 8 i 10. Działa na Windows, macOS i Linux bez modyfikacji. Jeśli celujesz w scenariusze międzyplatformowe, to samo czyni IronXL znacznie lepiej pasującym niż Office Interop, który jest tylko dla Windows.

Jak zweryfikować, że instalacja działa?

Po instalacji, utwórz prosty test, ładując dowolny plik Excel i drukując wartość komórki. Jeśli projekt buduje się bez błędów, a wynik odpowiada oczekiwanym danym, konfiguracja jest zakończona. Dokumentacja IronXL zawiera sekcję szybkiego startu, która przeprowadza ten krok weryfikacji szczegółowo.

Częsty błąd podczas konfiguracji to zapomnienie o zastosowaniu klucza licencyjnego przed załadowaniem zeszytu w produkcji. W trybie próby biblioteka dodaje mały znak wodny do wszystkich wygenerowanych plików. Ustaw IronXL.License.LicenseKey podczas uruchamiania aplikacji, aby wszystkie operacje dzialaly pod prawidlowa licencja od poczatku.

Jak otworzyć zeszyt Excel i przeczytać wartości komórek?

Podstawowe API jest proste. Załaduj zeszyt, wybierz arkusz, i uzyskaj dostęp do komórek przez adres lub iterację.

using IronXL;

// Load any Excel file -- XLSX, XLS, CSV, or TSV
WorkBook workbook = WorkBook.Load("example.xlsx");

// Access the second worksheet (zero-indexed)
WorkSheet worksheet = workbook.WorkSheets[1];

// Read a specific cell value
decimal revenue = worksheet["E2"].DecimalValue;
Console.WriteLine($"Order Total: {revenue}");

// Iterate over a range of cells
foreach (var cell in worksheet["C2:C6"])
{
    Console.WriteLine($"Product: {cell.Text}");
}

using IronXL;

// Load any Excel file -- XLSX, XLS, CSV, or TSV
WorkBook workbook = WorkBook.Load("example.xlsx");

// Access the second worksheet (zero-indexed)
WorkSheet worksheet = workbook.WorkSheets[1];

// Read a specific cell value
decimal revenue = worksheet["E2"].DecimalValue;
Console.WriteLine($"Order Total: {revenue}");

// Iterate over a range of cells
foreach (var cell in worksheet["C2:C6"])
{
    Console.WriteLine($"Product: {cell.Text}");
}

Imports IronXL

' Load any Excel file -- XLSX, XLS, CSV, or TSV
Dim workbook As WorkBook = WorkBook.Load("example.xlsx")

' Access the second worksheet (zero-indexed)
Dim worksheet As WorkSheet = workbook.WorkSheets(1)

' Read a specific cell value
Dim revenue As Decimal = worksheet("E2").DecimalValue
Console.WriteLine($"Order Total: {revenue}")

' Iterate over a range of cells
For Each cell In worksheet("C2:C6")
    Console.WriteLine($"Product: {cell.Text}")
Next

Imports IronXL

' Load any Excel file -- XLSX, XLS, CSV, or TSV
Dim workbook As WorkBook = WorkBook.Load("example.xlsx")

' Access the second worksheet (zero-indexed)
Dim worksheet As WorkSheet = workbook.WorkSheets(1)

' Read a specific cell value
Dim revenue As Decimal = worksheet("E2").DecimalValue
Console.WriteLine($"Order Total: {revenue}")

' Iterate over a range of cells
For Each cell In worksheet("C2:C6")
    Console.WriteLine($"Product: {cell.Text}")
Next

WorkBook.Load() automatycznie wykrywa format pliku — nie trzeba okreslac, czy plik jest XLS, czy XLSX. Dostęp do arkuszy uzyskuj wedlug indeksu lub nazwy, uzywajac workbook.GetWorkSheet("Sheet1"). Kazda komorka udostepnia typowane wlasciwosci takie jak IntValue, DecimalValue, Data i godzinaValue i Text.

Dla więcej opcji otwierania plików, zobacz przewodnik jak otworzyć zeszyt.

Jak uzyskać dostęp do arkuszy po nazwie?

Używanie nazw arkuszy jest bardziej zrównoważone niż indeksów numerycznych, szczególnie gdy zeszyty są edytowane przez innych. Poniższy przykład pokazuje, jak wyszukać arkusz po nazwie i iterować przez wszystkie arkusze:

using IronXL;

WorkBook workbook = WorkBook.Load("inventory.xlsx");

// Access worksheet by exact name
WorkSheet salesSheet = workbook.GetWorkSheet("Sales Data");
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}");

// Iterate all worksheets in the workbook
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    if (sheet.Name.Contains("Inventory"))
    {
        Console.WriteLine($"Found inventory sheet: {sheet.Name}");
    }
}

using IronXL;

WorkBook workbook = WorkBook.Load("inventory.xlsx");

// Access worksheet by exact name
WorkSheet salesSheet = workbook.GetWorkSheet("Sales Data");
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}");

// Iterate all worksheets in the workbook
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    if (sheet.Name.Contains("Inventory"))
    {
        Console.WriteLine($"Found inventory sheet: {sheet.Name}");
    }
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")

' Access worksheet by exact name
Dim salesSheet As WorkSheet = workbook.GetWorkSheet("Sales Data")
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}")

' Iterate all worksheets in the workbook
For Each sheet As WorkSheet In workbook.WorkSheets
    If sheet.Name.Contains("Inventory") Then
        Console.WriteLine($"Found inventory sheet: {sheet.Name}")
    End If
Next

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")

' Access worksheet by exact name
Dim salesSheet As WorkSheet = workbook.GetWorkSheet("Sales Data")
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}")

' Iterate all worksheets in the workbook
For Each sheet As WorkSheet In workbook.WorkSheets
    If sheet.Name.Contains("Inventory") Then
        Console.WriteLine($"Found inventory sheet: {sheet.Name}")
    End If
Next

Przewodnik czytania plików Excel wyjaśnia dodatkowe wzorce dostępu do arkuszy, włączając pracę z zeszytami, które mają dynamicznie generowane nazwy arkuszy.

Jak czytać różne typy danych z komórek Excel?

IronXL udostępnia typowe akcesory do każdego popularnego typu danych Excel. Możesz czytać stringi, liczby całkowite, wartości dziesiętne, daty, booleany i wyniki formuł bez żadnego ręcznego parsowania.

using IronXL;

WorkBook wb = WorkBook.Load(@"C:\Data\Inventory.xlsx");
WorkSheet ws = wb.GetWorkSheet("Products");

// Read different data types directly
string productName = ws["A2"].StringValue;
int quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
Data i godzina updated   = ws["D2"].Data i godzinaValue;

// Use aggregate functions on ranges for performance
decimal totalStock = ws["B2:B100"].Sum();
decimal maxPrice   = ws["C2:C100"].Max();

Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}");

using IronXL;

WorkBook wb = WorkBook.Load(@"C:\Data\Inventory.xlsx");
WorkSheet ws = wb.GetWorkSheet("Products");

// Read different data types directly
string productName = ws["A2"].StringValue;
int quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
Data i godzina updated   = ws["D2"].Data i godzinaValue;

// Use aggregate functions on ranges for performance
decimal totalStock = ws["B2:B100"].Sum();
decimal maxPrice   = ws["C2:C100"].Max();

Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}");

Tabela poniżej podsumowuje dostępne typowe akcesory:

Dla pełnych szczegółów dotyczących czytania i pisania danych komórek, zobacz przewodnik formatowania komórek i przewodnik jak importować dane.

Jak bezpiecznie obsłużyć puste lub null komórki?

Puste komórki są powszechne w rzeczywistych plikach Excel. Uzyj wlasciwosci IsEmpty lub sprawdz Value pod katem null przed odczytem typowanych akcesorow:

using IronXL;

WorkBook workbook = WorkBook.Load("data.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;

// Check if a cell is empty before reading
if (!ws["A1"].IsEmpty)
{
    Console.WriteLine(ws["A1"].StringValue);
}

// Provide a fallback value using a null-coalescing pattern
string cellText = ws["A1"].StringValue ?? "Default Value";

// Iterate a range and skip empty cells
foreach (var cell in ws["A1:A20"])
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine(cell.Text);
    }
}

using IronXL;

WorkBook workbook = WorkBook.Load("data.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;

// Check if a cell is empty before reading
if (!ws["A1"].IsEmpty)
{
    Console.WriteLine(ws["A1"].StringValue);
}

// Provide a fallback value using a null-coalescing pattern
string cellText = ws["A1"].StringValue ?? "Default Value";

// Iterate a range and skip empty cells
foreach (var cell in ws["A1:A20"])
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine(cell.Text);
    }
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Check if a cell is empty before reading
If Not ws("A1").IsEmpty Then
    Console.WriteLine(ws("A1").StringValue)
End If

' Provide a fallback value using a null-coalescing pattern
Dim cellText As String = If(ws("A1").StringValue, "Default Value")

' Iterate a range and skip empty cells
For Each cell In ws("A1:A20")
    If Not cell.IsEmpty Then
        Console.WriteLine(cell.Text)
    End If
Next

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Check if a cell is empty before reading
If Not ws("A1").IsEmpty Then
    Console.WriteLine(ws("A1").StringValue)
End If

' Provide a fallback value using a null-coalescing pattern
Dim cellText As String = If(ws("A1").StringValue, "Default Value")

' Iterate a range and skip empty cells
For Each cell In ws("A1:A20")
    If Not cell.IsEmpty Then
        Console.WriteLine(cell.Text)
    End If
Next

Dokumentacja odczytu pliku Excel zawiera dodatkowe wzorce dotyczące obsługi rzadkich danych, w tym sposób wykrywania ostatniego używanego wiersza i kolumny w arkuszu.

Innym zagadnieniem przy pracy z pustymi komórkami jest różnica między naprawdę pustą komórką a komórką, która posiada pusty ciąg znaków. IsEmpty zwraca prawde tylko wtedy, gdy komorka nie zawiera zadnej wartosci, podczas gdy StringValue zwraca pusty lancuch zarowno dla pustych komorek, jak i komorek jawnie ustawionych na "". Jesli twoje dane maja komorki sformatowane jako tekst, ktore wydaja sie puste, sprawdz zarowno IsEmpty, jak i string.IsNullOrWhiteSpace(cell.StringValue), aby uzyskac najdokladniejszy wynik.

Jak zbudować gotowy do produkcji odczyt plików Excel?

Reader Excel używany w rzeczywistym świecie wymaga walidacji plików, obsługi błędów, wsparcia dla wielu arkuszy oraz opcjonalnego generowania wyników. Poniższy przykład demonstruje wszystkie te wzorce w jednej klasie:

using IronXL;
using System.IO;

// Validate and load the file
static List<string> CheckLowStock(string filePath)
{
    var lowStockItems = new List<string>();

    if (!File.Exists(filePath))
    {
        Console.WriteLine($"File not found: {filePath}");
        return lowStockItems;
    }

    string ext = Path.GetExtension(filePath).ToLower();
    if (ext is not (".xlsx" or ".xls" or ".csv"))
    {
        Console.WriteLine($"Unsupported file type: {ext}");
        return lowStockItems;
    }

    try
    {
        WorkBook workbook = WorkBook.Load(filePath);

        foreach (WorkSheet sheet in workbook.WorkSheets)
        {
            Console.WriteLine($"Checking sheet: {sheet.Name}");

            for (int row = 2; row <= sheet.RowCount; row++)
            {
                string itemName  = sheet[$"A{row}"].StringValue;
                int stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !string.IsNullOrEmpty(itemName))
                {
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})");
                }
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error reading Excel file: {ex.Message}");
    }

    return lowStockItems;
}

// Export results to a new workbook
static void ExportReport(List<string> items, string outputPath)
{
    WorkBook report     = WorkBook.Create();
    WorkSheet sheet     = report.CreateWorkSheet("Low Stock Report");

    sheet["A1"].Value   = "Item Description";
    sheet["B1"].Value   = "Source Sheet";

    sheet["A1:B1"].Style.Font.Bold        = true;
    sheet["A1:B1"].Style.BackgroundColor  = "#4472C4";
    sheet["A1:B1"].Style.Font.Color       = "#FFFFFF";

    int rowIndex = 2;
    foreach (string item in items)
    {
        sheet[$"A{rowIndex}"].Value = item;
        rowIndex++;
    }

    report.SaveAs(outputPath);
    Console.WriteLine($"Report saved to: {outputPath}");
}

// Run
var lowStockItems = CheckLowStock("inventory.xlsx");
ExportReport(lowStockItems, "low-stock-report.xlsx");

using IronXL;
using System.IO;

// Validate and load the file
static List<string> CheckLowStock(string filePath)
{
    var lowStockItems = new List<string>();

    if (!File.Exists(filePath))
    {
        Console.WriteLine($"File not found: {filePath}");
        return lowStockItems;
    }

    string ext = Path.GetExtension(filePath).ToLower();
    if (ext is not (".xlsx" or ".xls" or ".csv"))
    {
        Console.WriteLine($"Unsupported file type: {ext}");
        return lowStockItems;
    }

    try
    {
        WorkBook workbook = WorkBook.Load(filePath);

        foreach (WorkSheet sheet in workbook.WorkSheets)
        {
            Console.WriteLine($"Checking sheet: {sheet.Name}");

            for (int row = 2; row <= sheet.RowCount; row++)
            {
                string itemName  = sheet[$"A{row}"].StringValue;
                int stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !string.IsNullOrEmpty(itemName))
                {
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})");
                }
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error reading Excel file: {ex.Message}");
    }

    return lowStockItems;
}

// Export results to a new workbook
static void ExportReport(List<string> items, string outputPath)
{
    WorkBook report     = WorkBook.Create();
    WorkSheet sheet     = report.CreateWorkSheet("Low Stock Report");

    sheet["A1"].Value   = "Item Description";
    sheet["B1"].Value   = "Source Sheet";

    sheet["A1:B1"].Style.Font.Bold        = true;
    sheet["A1:B1"].Style.BackgroundColor  = "#4472C4";
    sheet["A1:B1"].Style.Font.Color       = "#FFFFFF";

    int rowIndex = 2;
    foreach (string item in items)
    {
        sheet[$"A{rowIndex}"].Value = item;
        rowIndex++;
    }

    report.SaveAs(outputPath);
    Console.WriteLine($"Report saved to: {outputPath}");
}

// Run
var lowStockItems = CheckLowStock("inventory.xlsx");
ExportReport(lowStockItems, "low-stock-report.xlsx");

Imports IronXL
Imports System.IO

' Validate and load the file
Private Shared Function CheckLowStock(filePath As String) As List(Of String)
    Dim lowStockItems As New List(Of String)()

    If Not File.Exists(filePath) Then
        Console.WriteLine($"File not found: {filePath}")
        Return lowStockItems
    End If

    Dim ext As String = Path.GetExtension(filePath).ToLower()
    If ext <> ".xlsx" AndAlso ext <> ".xls" AndAlso ext <> ".csv" Then
        Console.WriteLine($"Unsupported file type: {ext}")
        Return lowStockItems
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Load(filePath)

        For Each sheet As WorkSheet In workbook.WorkSheets
            Console.WriteLine($"Checking sheet: {sheet.Name}")

            For row As Integer = 2 To sheet.RowCount
                Dim itemName As String = sheet($"A{row}").StringValue
                Dim stockLevel As Integer = sheet($"B{row}").IntValue

                If stockLevel < 10 AndAlso Not String.IsNullOrEmpty(itemName) Then
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})")
                End If
            Next
        Next
    Catch ex As Exception
        Console.WriteLine($"Error reading Excel file: {ex.Message}")
    End Try

    Return lowStockItems
End Function

' Export results to a new workbook
Private Shared Sub ExportReport(items As List(Of String), outputPath As String)
    Dim report As WorkBook = WorkBook.Create()
    Dim sheet As WorkSheet = report.CreateWorkSheet("Low Stock Report")

    sheet("A1").Value = "Item Description"
    sheet("B1").Value = "Source Sheet"

    sheet("A1:B1").Style.Font.Bold = True
    sheet("A1:B1").Style.BackgroundColor = "#4472C4"
    sheet("A1:B1").Style.Font.Color = "#FFFFFF"

    Dim rowIndex As Integer = 2
    For Each item As String In items
        sheet($"A{rowIndex}").Value = item
        rowIndex += 1
    Next

    report.SaveAs(outputPath)
    Console.WriteLine($"Report saved to: {outputPath}")
End Sub

' Run
Dim lowStockItems As List(Of String) = CheckLowStock("inventory.xlsx")
ExportReport(lowStockItems, "low-stock-report.xlsx")

Imports IronXL
Imports System.IO

' Validate and load the file
Private Shared Function CheckLowStock(filePath As String) As List(Of String)
    Dim lowStockItems As New List(Of String)()

    If Not File.Exists(filePath) Then
        Console.WriteLine($"File not found: {filePath}")
        Return lowStockItems
    End If

    Dim ext As String = Path.GetExtension(filePath).ToLower()
    If ext <> ".xlsx" AndAlso ext <> ".xls" AndAlso ext <> ".csv" Then
        Console.WriteLine($"Unsupported file type: {ext}")
        Return lowStockItems
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Load(filePath)

        For Each sheet As WorkSheet In workbook.WorkSheets
            Console.WriteLine($"Checking sheet: {sheet.Name}")

            For row As Integer = 2 To sheet.RowCount
                Dim itemName As String = sheet($"A{row}").StringValue
                Dim stockLevel As Integer = sheet($"B{row}").IntValue

                If stockLevel < 10 AndAlso Not String.IsNullOrEmpty(itemName) Then
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})")
                End If
            Next
        Next
    Catch ex As Exception
        Console.WriteLine($"Error reading Excel file: {ex.Message}")
    End Try

    Return lowStockItems
End Function

' Export results to a new workbook
Private Shared Sub ExportReport(items As List(Of String), outputPath As String)
    Dim report As WorkBook = WorkBook.Create()
    Dim sheet As WorkSheet = report.CreateWorkSheet("Low Stock Report")

    sheet("A1").Value = "Item Description"
    sheet("B1").Value = "Source Sheet"

    sheet("A1:B1").Style.Font.Bold = True
    sheet("A1:B1").Style.BackgroundColor = "#4472C4"
    sheet("A1:B1").Style.Font.Color = "#FFFFFF"

    Dim rowIndex As Integer = 2
    For Each item As String In items
        sheet($"A{rowIndex}").Value = item
        rowIndex += 1
    Next

    report.SaveAs(outputPath)
    Console.WriteLine($"Report saved to: {outputPath}")
End Sub

' Run
Dim lowStockItems As List(Of String) = CheckLowStock("inventory.xlsx")
ExportReport(lowStockItems, "low-stock-report.xlsx")

Ten przykład korzysta z wyrażeń najwyższego poziomu i obejmuje cały proces: walidacja ścieżki i rozszerzenia pliku, ładowanie skoroszytu, iteracja po wszystkich arkuszach, stosowanie logiki biznesowej i zapisywanie wyników do nowego pliku. Więcej na temat pisania i zapisywania skoroszytów można znaleźć w przewodniku po zapisie plików Excel oraz poradniku po eksporcie Excel.

Zauwaz, ze metoda ExportReport tworzy nowy skoroszyt za pomoca WorkBook.Create() zamiast modyfikowac plik zrodlowy. Utrzymywanie plikow zrodlowych i plikow wyjsciowych osobno jest dobrym zwyczajem dla potrzeb sladowosci audytow i unikanie przypadkowego nadpisania danych, od ktorych zaleze sa inne procesy. Jesli zamiast tego potrzebujesz dopisac dane do istniejacego skoroszytu, zaladuj go z WorkBook.Load(), dodaj wiersze do odpowiedniego arkusza i wywolaj SaveAs() na nowa sciezke lub nadpisz w miejscu.

Jak efektywnie rozpracowywać duże pliki Excel?

W przypadku plików zawierających tysiące wierszy, funkcje agregujące przewyższają manualne pętle, ponieważ działają wewnętrznie bez materializowania każdej komórki jako osobnego obiektu:

using IronXL;

WorkBook workbook = WorkBook.Load("large-dataset.xlsx");
WorkSheet ws      = workbook.DefaultWorkSheet;

// Fast: aggregate functions operate on the range directly
decimal total   = ws["B2:B5000"].Sum();
decimal average = ws["B2:B5000"].Avg();
int count       = ws["B2:B5000"].Count();

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}");

// Export the worksheet to a DataSet for LINQ or database operations
var dataSet = workbook.ToDataSet();
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}");

using IronXL;

WorkBook workbook = WorkBook.Load("large-dataset.xlsx");
WorkSheet ws      = workbook.DefaultWorkSheet;

// Fast: aggregate functions operate on the range directly
decimal total   = ws["B2:B5000"].Sum();
decimal average = ws["B2:B5000"].Avg();
int count       = ws["B2:B5000"].Count();

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}");

// Export the worksheet to a DataSet for LINQ or database operations
var dataSet = workbook.ToDataSet();
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("large-dataset.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Fast: aggregate functions operate on the range directly
Dim total As Decimal = ws("B2:B5000").Sum()
Dim average As Decimal = ws("B2:B5000").Avg()
Dim count As Integer = ws("B2:B5000").Count()

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}")

' Export the worksheet to a DataSet for LINQ or database operations
Dim dataSet = workbook.ToDataSet()
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}")

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("large-dataset.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Fast: aggregate functions operate on the range directly
Dim total As Decimal = ws("B2:B5000").Sum()
Dim average As Decimal = ws("B2:B5000").Avg()
Dim count As Integer = ws("B2:B5000").Count()

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}")

' Export the worksheet to a DataSet for LINQ or database operations
Dim dataSet = workbook.ToDataSet()
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}")

Konwersja do DataSet jest szczegolnie skuteczna, gdy chcesz wykonywac zapytania LINQ w poprzek wielu arkuszy lub zaladowac dane do relacyjnej bazy danych. Kazdy arkusz staje sie DataTable wewnatrz DataSet, co czyni prace z istniejacym kodem dostepu do danych prostym. Zobacz przewodnik Excel do DataSet dla pełnych szczegółów.

Jak uzyskać Licencję i wdrożyć w produkcji?

IronXL to komercyjna biblioteka z darmową wersją próbną, która pozwala na pełną funkcjonalność podczas rozwoju i testowania. Aby wdrożyć w produkcji, będziesz potrzebować ważnego klucza licencyjnego. Szczegóły dotyczące poziomów licencjonowania, w tym opcji dla deweloperów, zespołów i przedsiębiorstw, znajdziesz na stronie licencjonowania IronXL.

Aby zastosować klucz licencyjny, ustaw go przed jakimkolwiek wywołaniem IronXL:

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Przegląd funkcji IronXL podsumowuje wszystkie możliwości, od odczytu i zapisu plików po tworzenie wykresów, stosowanie formatowania warunkowego i prace z nazwanymi zakresami. Przewodnik tworzenia pliku Excel i łączenia komórek to przydatne punkty wyjścia do pisania nowych skoroszytów.

Dla dyskusji społecznościowych i pytań dotyczących automatyzacji Excela w C#, forum pytań Microsoft Q&A i Stack Overflow są dobrymi zasobami. Oficjalna strona pakietu NuGet udostępnia historię wersji i statystyki pobrań.

Jakie są kluczowe wnioski dotyczące otwierania plików Excel w C#?

IronXL całkowicie eliminuje zależność od Microsoft Office, umożliwiając przetwarzanie plików Excel na serwerach, w kontenerach i w funkcjach chmurowych. API stosuje prosty wzorzec: załaduj skoroszyt, uzyskaj dostęp do arkuszy po nazwie lub indeksie, a także odczytuj komórki za pomocą typowanych akcesorów. Funkcje agregujące, takie jak Sum(), Avg() i Max(), obsługują duze zbiory danych bez obciążenia ręczną iteracja.

Biblioteka obsługuje formaty XLSX, XLS, CSV i TSV, działa na .NET 10 i wszystkich najnowszych wersjach .NET oraz działa wieloplatformowo. Obsluga bledow jest prosta, poniewaz IronXL rzuca standardowe wyjatki .NET, ktore mozna przechwycic za pomoca znanych wzorcow try/catch — brak kodow bledow interopowania COM do deszyfracji. Aby poznać wszystkie dostępne opcje, zacznij od dokumentacji IronXL lub wypróbuj przewodnik otwierania skoroszytów jako szczegółową referencję.

Rozpocznij darmowy okres próbny IronXL, aby ocenić bibliotekę w swoich własnych projektach bez żadnych zobowiązań.

Pierwszy krok:

Zacznij za darmo