Tworzenie interfejsu API programu Excel dla platformy .NET Core jest proste dzięki IronXL. Zainstaluj pakiet, utwórz WorkBook, wypełnij komórki i zwróć strumień bezpośrednio - bez wymogu korzystania z Microsoft Office.

Install-Package IronXL.Excel

IronXL obsługuje tworzenie plików XLSX, import danych, eksport do wielu formatów oraz stylizację komórek całkowicie w zarządzanym kodzie .NET. Działa na systemach Windows, Linux i macOS, co czyni go praktycznym wyborem dla każdego interfejsu API .NET Core, który wymaga programowej obsługi programu Excel.

Jak zainstalować IronXL w projekcie .NET Core?

Dodaj IronXL do dowolnego projektu .NET 10 za pomocą konsoli NuGet Package Manager:

Install-Package IronXL.Excel

Można też zainstalować przez interfejs użytkownika Visual Studio NuGet, wyszukując IronXL. The package name on NuGet is IronXL.Excel.

Po instalacji dodaj using IronXL; do dowolnego pliku, który tworzy lub odczytuje skoroszyty. Na komputerze hosta nie są wymagane żadne biblioteki interoperacyjności Office, rejestracja COM ani instalacja programu Microsoft Excel — IronXL jest całkowicie samowystarczalny.

IronXL jest przeznaczony dla .NET Standard 2.0 i nowszych wersji, co oznacza, że ta sama biblioteka działa w projektach .NET Core, .NET 5/6/7/8/9/10 oraz .NET Framework. Dokumentacja IronXL szczegółowo opisuje wszystkie obsługiwane środowiska.

Jak programowo tworzyć pliki Excel w .NET Core?

Tworzenie dokumentów Excel od podstaw wymaga zaledwie kilku wierszy kodu dzięki intuicyjnemu API IronXL. Biblioteka zapewnia pełną kontrolę nad skoroszytami, arkuszami, stylami komórek i formułami dzięki przejrzystemu modelowi obiektowemu.

Oto akcja kontrolera, która tworzy nowy skoroszyt Excel z sformatowanymi danymi, demonstruje zarządzanie arkuszami i stosuje style komórek:

using IronXL;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ExcelController : ControllerBase
{
    [HttpGet("create-report")]
    public IActionResult CreateSalesReport()
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Set header labels in the first row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Q1 Sales";
        worksheet["C1"].Value = "Q2 Sales";
        worksheet["D1"].Value = "Total";

        // Bold headers and apply a blue background with white text
        worksheet["A1:D1"].Style.Font.Bold = true;
        worksheet["A1:D1"].Style.SetBackgroundColor("#4472C4");
        worksheet["A1:D1"].Style.Font.SetColor("#FFFFFF");

        // Add data rows
        worksheet["A2"].Value = "Widget Pro";
        worksheet["B2"].Value = 15000;
        worksheet["C2"].Value = 18500;
        worksheet["D2"].Formula = "=B2+C2";

        worksheet["A3"].Value = "Gadget Plus";
        worksheet["B3"].Value = 22000;
        worksheet["C3"].Value = 24000;
        worksheet["D3"].Formula = "=B3+C3";

        // Apply currency number format to sales columns
        worksheet["B2:D3"].Style.Format = "$#,##0";

        // Stream the XLSX file back to the caller
        var stream = workbook.ToStream();
        return File(
            stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "SalesReport.xlsx");
    }
}

using IronXL;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ExcelController : ControllerBase
{
    [HttpGet("create-report")]
    public IActionResult CreateSalesReport()
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Set header labels in the first row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Q1 Sales";
        worksheet["C1"].Value = "Q2 Sales";
        worksheet["D1"].Value = "Total";

        // Bold headers and apply a blue background with white text
        worksheet["A1:D1"].Style.Font.Bold = true;
        worksheet["A1:D1"].Style.SetBackgroundColor("#4472C4");
        worksheet["A1:D1"].Style.Font.SetColor("#FFFFFF");

        // Add data rows
        worksheet["A2"].Value = "Widget Pro";
        worksheet["B2"].Value = 15000;
        worksheet["C2"].Value = 18500;
        worksheet["D2"].Formula = "=B2+C2";

        worksheet["A3"].Value = "Gadget Plus";
        worksheet["B3"].Value = 22000;
        worksheet["C3"].Value = 24000;
        worksheet["D3"].Formula = "=B3+C3";

        // Apply currency number format to sales columns
        worksheet["B2:D3"].Style.Format = "$#,##0";

        // Stream the XLSX file back to the caller
        var stream = workbook.ToStream();
        return File(
            stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "SalesReport.xlsx");
    }
}

Imports IronXL
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/[controller]")>
Public Class ExcelController
    Inherits ControllerBase

    <HttpGet("create-report")>
    Public Function CreateSalesReport() As IActionResult
        ' Create a new Excel workbook in XLSX format
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Sales Data")

        ' Set header labels in the first row
        worksheet("A1").Value = "Product"
        worksheet("B1").Value = "Q1 Sales"
        worksheet("C1").Value = "Q2 Sales"
        worksheet("D1").Value = "Total"

        ' Bold headers and apply a blue background with white text
        worksheet("A1:D1").Style.Font.Bold = True
        worksheet("A1:D1").Style.SetBackgroundColor("#4472C4")
        worksheet("A1:D1").Style.Font.SetColor("#FFFFFF")

        ' Add data rows
        worksheet("A2").Value = "Widget Pro"
        worksheet("B2").Value = 15000
        worksheet("C2").Value = 18500
        worksheet("D2").Formula = "=B2+C2"

        worksheet("A3").Value = "Gadget Plus"
        worksheet("B3").Value = 22000
        worksheet("C3").Value = 24000
        worksheet("D3").Formula = "=B3+C3"

        ' Apply currency number format to sales columns
        worksheet("B2:D3").Style.Format = "$#,##0"

        ' Stream the XLSX file back to the caller
        Dim stream = workbook.ToStream()
        Return File(
            stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "SalesReport.xlsx")
    End Function
End Class

Imports IronXL
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/[controller]")>
Public Class ExcelController
    Inherits ControllerBase

    <HttpGet("create-report")>
    Public Function CreateSalesReport() As IActionResult
        ' Create a new Excel workbook in XLSX format
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Sales Data")

        ' Set header labels in the first row
        worksheet("A1").Value = "Product"
        worksheet("B1").Value = "Q1 Sales"
        worksheet("C1").Value = "Q2 Sales"
        worksheet("D1").Value = "Total"

        ' Bold headers and apply a blue background with white text
        worksheet("A1:D1").Style.Font.Bold = True
        worksheet("A1:D1").Style.SetBackgroundColor("#4472C4")
        worksheet("A1:D1").Style.Font.SetColor("#FFFFFF")

        ' Add data rows
        worksheet("A2").Value = "Widget Pro"
        worksheet("B2").Value = 15000
        worksheet("C2").Value = 18500
        worksheet("D2").Formula = "=B2+C2"

        worksheet("A3").Value = "Gadget Plus"
        worksheet("B3").Value = 22000
        worksheet("C3").Value = 24000
        worksheet("D3").Formula = "=B3+C3"

        ' Apply currency number format to sales columns
        worksheet("B2:D3").Style.Format = "$#,##0"

        ' Stream the XLSX file back to the caller
        Dim stream = workbook.ToStream()
        Return File(
            stream,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "SalesReport.xlsx")
    End Function
End Class

Plik wyjściowy w formacie Excel

WorkBook.Create() obsługuje zarówno formaty XLSX, jak i XLS. Metoda CreateWorkSheet() dodaje nazwany arkusz, w którym wypełniasz komórki wartościami, stosujesz formuły Excela do obliczeń i kontrolujesz układ przez zakresy komórek. Silnik obliczeniowy IronXL automatycznie oblicza formuły w przypadku zmiany danych w skoroszycie, w tym obsługuje formuły tablicowe stosowane w bardziej złożonych scenariuszach analizy danych.

Style komórek to znacznie więcej niż tylko pogrubienie i kolor. API formatowania komórek pozwala ustawić formaty liczb, obramowania, wyrównanie, rozmiary czcionek i wiele więcej — wszystko to bez ingerencji w warstwę COM. Dzięki temu można je bezpiecznie uruchamiać w kontenerowych środowiskach Linux, gdzie nie ma kontekstu wyświetlania.

Jak dodać wiele arkuszy do skoroszytu?

Jeden skoroszyt może zawierać dowolną liczbę arkuszy. Wywołaj workbook.CreateWorkSheet("SheetName") dla każdej potrzebnej zakładki. Arkusze są dostępne później według nazwy przez workbook.GetWorkSheet("SheetName") lub według indeksu przez workbook.WorkSheets[0].

Ten wzorzec jest przydatny podczas generowania raportów zawierających podsumowanie oraz szczegóły: jeden arkusz zawiera zagregowane sumy, a arkusze podrzędne zawierają surowe wiersze transakcji. Dokumentacja dotycząca zarządzania arkuszami zawiera instrukcje dotyczące zmiany nazw, zmiany kolejności i usuwania arkuszy w czasie wykonywania.

Jaki jest najlepszy sposób odczytu danych z Excela w interfejsach API sieci Web?

Importowanie danych z plików Excel przesłanych przez użytkowników jest niezbędne dla każdej aplikacji internetowej przetwarzającej zawartość arkuszy kalkulacyjnych. IronXL ułatwia bezpośrednie odczytywanie arkuszy kalkulacyjnych Excel — ładuj ze strumienia, iteruj wiersze i pobieraj wpisane wartości z każdej komórki.

[HttpPost("import")]
public IActionResult ImportExcelData(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");

    using var stream = file.OpenReadStream();

    // Load the workbook directly from the upload stream
    WorkBook workbook = WorkBook.Load(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    var records = new List<Dictionary<string, object>>();

    // Start at row 2 to skip the header row
    for (int row = 2; row <= worksheet.RowCount; row++)
    {
        var record = new Dictionary<string, object>
        {
            ["Product"] = worksheet[$"A{row}"].StringValue,
            ["Sales"]   = worksheet[$"B{row}"].DecimalValue,
            ["Date"]    = worksheet[$"C{row}"].DateTimeValue
        };
        records.Add(record);
    }

    return Ok(new {
        message     = "Import successful",
        recordCount = records.Count,
        data        = records
    });
}

[HttpPost("import")]
public IActionResult ImportExcelData(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No file uploaded");

    using var stream = file.OpenReadStream();

    // Load the workbook directly from the upload stream
    WorkBook workbook = WorkBook.Load(stream);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    var records = new List<Dictionary<string, object>>();

    // Start at row 2 to skip the header row
    for (int row = 2; row <= worksheet.RowCount; row++)
    {
        var record = new Dictionary<string, object>
        {
            ["Product"] = worksheet[$"A{row}"].StringValue,
            ["Sales"]   = worksheet[$"B{row}"].DecimalValue,
            ["Date"]    = worksheet[$"C{row}"].DateTimeValue
        };
        records.Add(record);
    }

    return Ok(new {
        message     = "Import successful",
        recordCount = records.Count,
        data        = records
    });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.Collections.Generic
Imports IronXL

<HttpPost("import")>
Public Function ImportExcelData(file As IFormFile) As IActionResult
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded")
    End If

    Using stream = file.OpenReadStream()
        ' Load the workbook directly from the upload stream
        Dim workbook As WorkBook = WorkBook.Load(stream)
        Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

        Dim records As New List(Of Dictionary(Of String, Object))()

        ' Start at row 2 to skip the header row
        For row As Integer = 2 To worksheet.RowCount
            Dim record As New Dictionary(Of String, Object) From {
                {"Product", worksheet($"A{row}").StringValue},
                {"Sales", worksheet($"B{row}").DecimalValue},
                {"Date", worksheet($"C{row}").DateTimeValue}
            }
            records.Add(record)
        Next

        Return Ok(New With {
            .message = "Import successful",
            .recordCount = records.Count,
            .data = records
        })
    End Using
End Function

Imports Microsoft.AspNetCore.Mvc
Imports System.Collections.Generic
Imports IronXL

<HttpPost("import")>
Public Function ImportExcelData(file As IFormFile) As IActionResult
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded")
    End If

    Using stream = file.OpenReadStream()
        ' Load the workbook directly from the upload stream
        Dim workbook As WorkBook = WorkBook.Load(stream)
        Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

        Dim records As New List(Of Dictionary(Of String, Object))()

        ' Start at row 2 to skip the header row
        For row As Integer = 2 To worksheet.RowCount
            Dim record As New Dictionary(Of String, Object) From {
                {"Product", worksheet($"A{row}").StringValue},
                {"Sales", worksheet($"B{row}").DecimalValue},
                {"Date", worksheet($"C{row}").DateTimeValue}
            }
            records.Add(record)
        Next

        Return Ok(New With {
            .message = "Import successful",
            .recordCount = records.Count,
            .data = records
        })
    End Using
End Function

Wynik

WorkBook.Load() otwiera pliki Excel ze strumieni, ścieżek plików lub tablic bajtów. Komórki są dostępne przez składnię indeksatora worksheet["A1"] lub poprzez iterację nazwanej zakresu komórek. IronXL automatycznie obsługuje walidację danych i zapewnia akcesory typów - IntValue, DecimalValue, DateTimeValue, StringValue - dzięki czemu kod konsumujący pozostaje czysty i przewidywalny.

Jak filtrować i sortować zaimportowane dane?

Po załadowaniu skoroszytu wywołaj .SortAscending() lub .SortDescending() na dowolnym obiekcie Range w celu sortowania wierszy. W celu filtrowania należy iterować komórki i oceniać warunki w linii lub przenieść dane do kolekcji LINQ w celu dalszego przetwarzania. Przewodnik dotyczący sortowania i filtrowania przedstawia oba podejścia wraz z praktycznymi przykładami.

Pracujesz z dużymi plikami? IronXL odczytuje tylko te komórki, do których ma dostęp, więc nie ma potrzeby ładowania całego pliku o wielkości kilku megabajtów do pamięci przed wysłaniem zapytania do konkretnej kolumny. To podejście oparte na leniwym dostępie pozwala utrzymać stabilne zużycie pamięci nawet podczas przetwarzania skoroszytów zawierających dziesiątki tysięcy wierszy.

Jak można eksportować dane z Excela do różnych formatów?

Aplikacje często muszą oferować arkusze kalkulacyjne w wielu formatach wyjściowych. IronXL obsługuje eksport do formatów XLSX, XLS, CSV, JSON i HTML za pomocą jednego wywołania metody, bez konieczności stosowania zewnętrznych narzędzi do konwersji.

[HttpGet("export/{format}")]
public IActionResult ExportData(string format)
{
    // Load a pre-designed template workbook
    WorkBook workbook = WorkBook.Load("template.xlsx");

    return format.ToLower() switch
    {
        "xlsx" => File(
            workbook.ToStream(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx"),

        "csv"  => File(
            workbook.ToStream(FileFormat.CSV),
            "text/csv",
            "export.csv"),

        "json" => Ok(workbook.ToJson()),

        _      => BadRequest("Unsupported format")
    };
}

[HttpGet("export/{format}")]
public IActionResult ExportData(string format)
{
    // Load a pre-designed template workbook
    WorkBook workbook = WorkBook.Load("template.xlsx");

    return format.ToLower() switch
    {
        "xlsx" => File(
            workbook.ToStream(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx"),

        "csv"  => File(
            workbook.ToStream(FileFormat.CSV),
            "text/csv",
            "export.csv"),

        "json" => Ok(workbook.ToJson()),

        _      => BadRequest("Unsupported format")
    };
}

Imports Microsoft.AspNetCore.Mvc

<HttpGet("export/{format}")>
Public Function ExportData(format As String) As IActionResult
    ' Load a pre-designed template workbook
    Dim workbook As WorkBook = WorkBook.Load("template.xlsx")

    Select Case format.ToLower()
        Case "xlsx"
            Return File(workbook.ToStream(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "export.xlsx")
        Case "csv"
            Return File(workbook.ToStream(FileFormat.CSV), "text/csv", "export.csv")
        Case "json"
            Return Ok(workbook.ToJson())
        Case Else
            Return BadRequest("Unsupported format")
    End Select
End Function

Imports Microsoft.AspNetCore.Mvc

<HttpGet("export/{format}")>
Public Function ExportData(format As String) As IActionResult
    ' Load a pre-designed template workbook
    Dim workbook As WorkBook = WorkBook.Load("template.xlsx")

    Select Case format.ToLower()
        Case "xlsx"
            Return File(workbook.ToStream(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "export.xlsx")
        Case "csv"
            Return File(workbook.ToStream(FileFormat.CSV), "text/csv", "export.csv")
        Case "json"
            Return Ok(workbook.ToJson())
        Case Else
            Return BadRequest("Unsupported format")
    End Select
End Function

Korzystanie z szablonów Excel o predefiniowanych układach przyspiesza generowanie raportów. Załaduj gotowy skoroszyt, wprowadź dane dynamiczne do nazwanych komórek lub zakresów, a następnie wyślij wynik. Takie podejście sprawdza się w przypadku raportów sprzedaży, faktur i dokumentów dotyczących zgodności, gdzie spójne formatowanie ma większe znaczenie niż elastyczność.

Wsparcie wielopłatformowe IronXL oznacza, że operacje na plikach działają identycznie w systemach Windows, Linux i macOS, dzięki czemu narzędzie nadaje się do wdrożeń kontenerowych .NET Core. Więcej informacji można znaleźć w przewodniku dotyczącym platformy IronXL.

Jak wyeksportować dane do pliku CSV z interfejsu API .NET Core?

Wywołaj workbook.ToStream(FileFormat.CSV) i zwróć go z typem zawartości text/csv, jak pokazano powyżej. Dla skoroszytów z wieloma arkuszami, każdy arkusz może być eksportowany niezależnie, uzyskując dostęp do workbook.WorkSheets[index] i wywołując .ToStream(FileFormat.CSV) na obiekcie arkusza. Dokumentacja eksportu CSV obejmuje obsługę separatorów, kodowania i opcji formatowania dat.

Jak zastosować formatowanie warunkowe i paski danych?

Oprócz podstawowych stylów komórek, IronXL obsługuje reguły formatowania warunkowego — podświetlanie komórek powyżej progu na zielono, oznaczanie wartości ujemnych na czerwono lub stosowanie pasków danych z gradientem, aby trendy były natychmiast widoczne w arkuszu kalkulacyjnym bez konieczności przetwarzania w oddzielnym narzędziu.

Formatowanie warunkowe jest szczególnie przydatne w pulpitach finansowych i raportach KPI, gdzie czytelnicy muszą szybko dostrzegać wartości odstające. Zamiast polegać na tym, że odbiorca sam zastosuje formatowanie po pobraniu, reguły są osadzone w pliku XLSX i są oceniane automatycznie po otwarciu pliku w dowolnej wersji programu Microsoft Excel lub kompatybilnej przeglądarce.

Formatowanie warunkowe jest ustawiane przez właściwość ConditionalFormatting arkusza. Reguły są stosowane do określonego zakresu komórek i obsługują wiele typów warunków: porównania wartości komórek, reguły oparte na formułach, skale kolorów oceniające wartości od niskich do wysokich oraz nakładki pasków danych, które działają jak wykresy słupkowe w komórkach. Specyfikacja Open XML definiuje podstawową strukturę reguł, którą IronXL zapisuje w pliku XLSX.

Aby uzyskać pełną dokumentację dotyczącą stosowania skali kolorów, zestawów ikon i pasków danych, zobacz samouczek formatowania warunkowego w dokumentacji IronXL.

Jak chronić pliki i arkusze programu Excel?

Dystrybucja raportów zawierających dane wrażliwe wymaga warstwy kontroli dostępu. IronXL obsługuje zarówno ochronę hasłem na poziomie skoroszytu, jak i na poziomie arkusza:

• Hasło skoroszytu: Ustaw workbook.Password = "secret" przed wywołaniem .SaveAs(), aby zaszyfrować plik XLSX. Odbiorcy muszą wprowadzić hasło, aby otworzyć go w Excel.
• Ochrona arkusza: Wywołaj worksheet.ProtectSheet("password"), aby zablokować edycję komórek przy jednoczesnym umożliwieniu podglądu arkusza. Specyficzne zakresy można odblokować do wprowadzania danych za pomocą API AllowEditRange.
• Dystrybucja tylko do odczytu: w przypadku dokumentów, które nie powinny być nigdy edytowane, należy połączyć zabezpieczenie arkusza z szyfrowaniem na poziomie pliku.

Pliki XLSX chronione hasłem domyślnie wykorzystują szyfrowanie AES-128, ten sam standard, który stosuje natywny program Excel. Oznacza to, że plik zabezpieczony za pomocą IronXL jest w pełni kompatybilny z wbudowanym w Excel okienkiem wyboru pliku — odbiorca nie potrzebuje żadnej specjalnej przeglądarki.

Te funkcje bezpieczeństwa uzupełniają standardowy model bezpieczeństwa .NET Core i są szczególnie przydatne podczas tworzenia punktów końcowych do raportowania finansowego lub kadrowego. Dokumentacja ochrony pliku zapewnia pełne odniesienie do API.

Jak pracować z formułami programu Excel w środowisku .NET?

Wbudowany silnik kalkulacyjny IronXL ocenia standardowe formuły Excela w czasie działania, dzięki czemu API może zwracać obliczone wartości bez zapisywania na dysk i ponownego otwierania w Excel. Przypisz ciąg formuły do właściwości .Formula dowolnej komórki:

// Sum a column and place the result in a footer row
worksheet[$"B{lastRow}"].Formula = $"=SUM(B2:B{lastRow - 1})";

// Calculate an average across a range
worksheet[$"C{lastRow}"].Formula = $"=AVERAGE(C2:C{lastRow - 1})";

// Retrieve the computed value immediately
decimal total = worksheet[$"B{lastRow}"].DecimalValue;

// Sum a column and place the result in a footer row
worksheet[$"B{lastRow}"].Formula = $"=SUM(B2:B{lastRow - 1})";

// Calculate an average across a range
worksheet[$"C{lastRow}"].Formula = $"=AVERAGE(C2:C{lastRow - 1})";

// Retrieve the computed value immediately
decimal total = worksheet[$"B{lastRow}"].DecimalValue;

' Sum a column and place the result in a footer row
worksheet($"B{lastRow}").Formula = $"=SUM(B2:B{lastRow - 1})"

' Calculate an average across a range
worksheet($"C{lastRow}").Formula = $"=AVERAGE(C2:C{lastRow - 1})"

' Retrieve the computed value immediately
Dim total As Decimal = worksheet($"B{lastRow}").DecimalValue

' Sum a column and place the result in a footer row
worksheet($"B{lastRow}").Formula = $"=SUM(B2:B{lastRow - 1})"

' Calculate an average across a range
worksheet($"C{lastRow}").Formula = $"=AVERAGE(C2:C{lastRow - 1})"

' Retrieve the computed value immediately
Dim total As Decimal = worksheet($"B{lastRow}").DecimalValue

IronXL obsługuje większość standardowych funkcji programu Excel, w tym funkcje matematyczne, statystyczne, tekstowe, datowe i wyszukiwania. Obsługiwane są również formuły tablicowe (semantyka Ctrl+Shift+Enter) dla zaawansowanych scenariuszy. Ponieważ obliczanie formuł odbywa się wewnątrz procesu .NET, nie ma potrzeby korzystania z zewnętrznej usługi obliczeniowej — wyniki są dostępne natychmiast po przypisaniu formuły, co pozwala zachować przewidywalny czas odpowiedzi API nawet podczas obliczeń obejmujących tysiące wierszy. W spisie funkcji obsługiwanych przez formułę wymieniono wszystkie obsługiwane funkcje.

Jakie są Twoje kolejne kroki?

Stworzenie interfejsu API programu Excel za pomocą IronXL zapewnia aplikacjom .NET Core solidne możliwości pracy z arkuszami kalkulacyjnymi. Od tworzenia plików XLSX z sformatowanymi danymi i obliczonymi formułami po importowanie plików przesłanych przez użytkowników i eksportowanie danych w wielu formatach — IronXL obsługuje każdy aspekt programowej manipulacji arkuszami kalkulacyjnymi w sposób wielopłatformowy i bez konieczności korzystania z pakietu Office.

Zapoznaj się z poniższymi zasobami, aby dowiedzieć się więcej:

• Strona produktu IronXL — przegląd funkcji i przewodnik dla początkujących
• Dokumentacja IronXL — pełna dokumentacja API oraz artykuły instruktażowe
• Twórz pliki Excel w C# -- szczegółowy samouczek na temat tworzenia skoroszytów i arkuszy
• Czytaj pliki Excel w C# -- ładowanie, analizowanie i ekstrakcja danych
• Eksport Excel do CSV -- eksport CSV z opcjami kodowania i separatorów
• API formatowania komórek — czcionki, kolory, obramowania i formaty liczb
• Formatowanie warunkowe -- reguły, paski danych, skale kolorów
• Obsługa formuł — odniesienie do obsługiwanych funkcji programu Excel
• Ochrona pliku -- interfejsy api hasła do skoroszytu i arkusza
• Pakiet NuGet — aktualna wersja i historia wersji

Bezpłatna próba, aby przetestować IronXL w rzeczywistym projekcie, lub zapoznaj się z opcjami licencyjnymi, aby znaleźć odpowiedni plan do wdrożenia produkcyjnego.