Jak otworzyć plik Excel w C# bez Microsoft Office

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

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.

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

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.

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

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}");

Imports IronXL

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

' Read different data types directly
Dim productName As String = ws("A2").StringValue
Dim quantity As Integer = ws("B2").IntValue
Dim price As Decimal = ws("C2").DecimalValue
Dim updated As DateTime = ws("D2").DateTimeValue

' Use aggregate functions on ranges for performance
Dim totalStock As Decimal = ws("B2:B100").Sum()
Dim maxPrice As Decimal = 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.

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

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")

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.

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}")

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"

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

Zacznij z IronXL teraz.

Zacznij za darmo