Jak mogę eksportować pliki Excel w aplikacjach Blazor Server?

Możesz używać IronXL do eksportowania plików Excel w aplikacjach Blazor Server poprzez tworzenie, formatowanie i pobieranie plików XLSX bezpośrednio z serwera bez konieczności korzystania z pakietu Microsoft Office.

Czy muszę mieć zainstalowany pakiet Microsoft Office, aby korzystać z IronXL w Blazorze?

Nie, IronXL nie wymaga zainstalowania pakietu Microsoft Office na serwerze w celu tworzenia, formatowania i eksportowania plików Excel w aplikacjach Blazor.

Czy IronXL może integrować się z aplikacjami Blazor?

Tak, IronXL płynnie integruje się z aplikacjami Blazor, umożliwiając łatwe dodawanie funkcji eksportu do Excela.

Jakie są typowe zastosowania eksportowania plików Excel w aplikacjach internetowych?

Typowe zastosowania obejmują generowanie raportów, tworzenie list magazynowych oraz generowanie faktur dla klientów w formacie Excel.

Czy dostępne są przykłady kodu dotyczące eksportowania plików Excel przy użyciu IronXL?

Tak, przewodnik zawiera przykłady kodu, które pomogą Ci zaimplementować funkcje eksportu do Excela w aplikacji Blazor Server przy użyciu IronXL.

Czy można formatować pliki Excel w Blazorze przy użyciu IronXL?

Tak, IronXL umożliwia formatowanie plików Excel, w tym ustawianie stylów, dodawanie formuł i nie tylko, bezpośrednio w aplikacjach Blazor.

Jakie typy plików Excel mogę tworzyć za pomocą IronXL?

Za pomocą IronXL można tworzyć pliki XLSX, które są powszechnie stosowanym formatem plików Excel, kompatybilnym z większością aplikacji do obsługi arkuszy kalkulacyjnych.

Do I need Microsoft Office installed to use IronXL in Blazor?

No, IronXL does not require Microsoft Office to be installed on the server or client. This makes it an efficient solution for applications that need to generate and export Excel files in Blazor Server apps.

What are the licensing options for deploying IronXL in production?

IronXL offers various licensing options for deploying in production environments. Details about these options can be found on Iron Software's website, along with the opportunity to start a free trial.

How does IronXL enhance Blazor applications?

IronXL enhances Blazor applications by simplifying the process of generating Excel files and providing access to a range of advanced Excel features. This enhances the app's functionality and user engagement through professional-grade reporting.

Biblioteka Excel dla C#

Explore Biblioteka IronXL Excel dla C# .NET Bezpłatna próba

Czytaj pliki Excel bez Interop

Zobacz wszystkie przykłady kodu %s

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

KORZYSTANIE Z IRONXL

Blazor Eksport do Excel: Kompletny przewodnik używając IronXL w C#

Curtis Chau

Updated: 5 stycznia 2026

Eksportowanie danych do Excela jest czymś, czego potrzebuje niemal każda aplikacja internetowa, niezależnie od tego, czy służy to generowaniu raportów, list magazynowych czy faktur dla klientów. W aplikacji Blazor Server niezawodne wykonanie tego zadania bez konieczności korzystania z pakietu Microsoft Office może stanowić wyzwanie. Właśnie tu z pomocą przychodzi IronXL. Umożliwia tworzenie, formatowanie i pobieranie plików Excel bezpośrednio z serwera, bez konieczności instalowania pakietu Office, oraz płynnie integruje się z Blazorem. W tym przewodniku zobaczysz, jak łatwo dodać do swojej aplikacji profesjonalne funkcje eksportu do Excela. Zaczynamy.

Pierwsze kroki z IronXL w celu eksportowania danych do programu Excel

Konfiguracja IronXL w aplikacji Blazor Server wymaga minimalnych ustawień. Zacznij od utworzenia nowego projektu Blazor Server w programie Visual Studio 2022 lub nowszym, przeznaczonego dla platformy .NET 6 lub nowszej.

Zainstaluj IronXL za pomocą konsoli NuGet Package Manager Console (zobacz nasz kompletny przewodnik instalacji, aby poznać alternatywne metody):

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Następnie utwórz funkcję pomocniczą JavaScript do pobierania plików. W folderze wwwroot dodaj nowy plik JavaScript o nazwie excelExport.js:

window.downloadFileFromStream = async (fileName, contentStreamReference) => {
    const arrayBuffer = await contentStreamReference.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);
    const anchorElement = document.createElement('a');
    anchorElement.href = url;
    anchorElement.download = fileName ?? 'export.xlsx';
    anchorElement.click();
    anchorElement.remove();
    URL.revokeObjectURL(url);
}

window.downloadFileFromStream = async (fileName, contentStreamReference) => {
    const arrayBuffer = await contentStreamReference.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);
    const anchorElement = document.createElement('a');
    anchorElement.href = url;
    anchorElement.download = fileName ?? 'export.xlsx';
    anchorElement.click();
    anchorElement.remove();
    URL.revokeObjectURL(url);
}

JavaScript

Dolacz ten skrypt w pliku _Host.cshtml:

<script src="~/excelExport.js"></script>

<script src="~/excelExport.js"></script>

HTML

Ta funkcja JavaScript obsługuje mechanizm pobierania po stronie przeglądarki, konwertując strumień bajtów z aplikacji Blazor Server na plik do pobrania. Funkcja tworzy tymczasowy adres URL obiektu blob, uruchamia pobieranie i czyści zasoby, aby zapobiec wyciekom pamięci.

Jak wyeksportować źródło danych do plików Excel za pomocą IronXL?

Stwórz usługę eksportu do Excela, aby obsługiwać logikę biznesową. Usługa ta zawiera funkcjonalność IronXL i zapewnia metody wielokrotnego użytku dla różnych scenariuszy eksportu w implementacji eksportu do Excela w Blazorze:

using IronXL;
using System.IO;
using ExportExcel.Models;
public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        try
        {
            var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            workbook.Metadata.Author = "Sales Department";
            var worksheet = workbook.CreateWorkSheet("Monthly Sales");
            worksheet["A1"].Value = "Date";
            worksheet["B1"].Value = "Product";
            worksheet["C1"].Value = "Quantity";
            worksheet["D1"].Value = "Revenue";
            worksheet["E1"].Value = "Profit Margin";
            var headerRange = worksheet["A1:E1"];
            headerRange.Style.Font.Bold = true;
            headerRange.Style.BackgroundColor = "#4472C4";
            headerRange.Style.Font.Color = "#FFFFFF";
            int row = 2;
            foreach (var sale in salesData)
            {
                worksheet[$"A{row}"].Value = sale.Date.ToString("yyyy-MM-dd");
                worksheet[$"B{row}"].Value = sale.Product ?? "Unknown";
                worksheet[$"C{row}"].Value = sale.Quantity;
                worksheet[$"D{row}"].Value = sale.Revenue;
                worksheet[$"E{row}"].Value = $"=D{row}*0.15";
                row++;
            }
            worksheet.AutoSizeColumn(0, true);
            using var ms = workbook.ToStream();
            return ms.ToArray();
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException("Failed to generate sales report", ex);
        }
    }
}

using IronXL;
using System.IO;
using ExportExcel.Models;
public class ExcelExportService
{
    public byte[] GenerateSalesReport(List<SalesData> salesData)
    {
        try
        {
            var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            workbook.Metadata.Author = "Sales Department";
            var worksheet = workbook.CreateWorkSheet("Monthly Sales");
            worksheet["A1"].Value = "Date";
            worksheet["B1"].Value = "Product";
            worksheet["C1"].Value = "Quantity";
            worksheet["D1"].Value = "Revenue";
            worksheet["E1"].Value = "Profit Margin";
            var headerRange = worksheet["A1:E1"];
            headerRange.Style.Font.Bold = true;
            headerRange.Style.BackgroundColor = "#4472C4";
            headerRange.Style.Font.Color = "#FFFFFF";
            int row = 2;
            foreach (var sale in salesData)
            {
                worksheet[$"A{row}"].Value = sale.Date.ToString("yyyy-MM-dd");
                worksheet[$"B{row}"].Value = sale.Product ?? "Unknown";
                worksheet[$"C{row}"].Value = sale.Quantity;
                worksheet[$"D{row}"].Value = sale.Revenue;
                worksheet[$"E{row}"].Value = $"=D{row}*0.15";
                row++;
            }
            worksheet.AutoSizeColumn(0, true);
            using var ms = workbook.ToStream();
            return ms.ToArray();
        }
        catch (Exception ex)
        {
            throw new InvalidOperationException("Failed to generate sales report", ex);
        }
    }
}

Imports IronXL
Imports System.IO
Imports ExportExcel.Models

Public Class ExcelExportService
    Public Function GenerateSalesReport(salesData As List(Of SalesData)) As Byte()
        Try
            Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            workbook.Metadata.Author = "Sales Department"
            Dim worksheet = workbook.CreateWorkSheet("Monthly Sales")
            worksheet("A1").Value = "Date"
            worksheet("B1").Value = "Product"
            worksheet("C1").Value = "Quantity"
            worksheet("D1").Value = "Revenue"
            worksheet("E1").Value = "Profit Margin"
            Dim headerRange = worksheet("A1:E1")
            headerRange.Style.Font.Bold = True
            headerRange.Style.BackgroundColor = "#4472C4"
            headerRange.Style.Font.Color = "#FFFFFF"
            Dim row As Integer = 2
            For Each sale In salesData
                worksheet($"A{row}").Value = sale.Date.ToString("yyyy-MM-dd")
                worksheet($"B{row}").Value = If(sale.Product, "Unknown")
                worksheet($"C{row}").Value = sale.Quantity
                worksheet($"D{row}").Value = sale.Revenue
                worksheet($"E{row}").Value = $"=D{row}*0.15"
                row += 1
            Next
            worksheet.AutoSizeColumn(0, True)
            Using ms = workbook.ToStream()
                Return ms.ToArray()
            End Using
        Catch ex As Exception
            Throw New InvalidOperationException("Failed to generate sales report", ex)
        End Try
    End Function
End Class

Imports IronXL
Imports System.IO
Imports ExportExcel.Models

Public Class ExcelExportService
    Public Function GenerateSalesReport(salesData As List(Of SalesData)) As Byte()
        Try
            Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
            workbook.Metadata.Author = "Sales Department"
            Dim worksheet = workbook.CreateWorkSheet("Monthly Sales")
            worksheet("A1").Value = "Date"
            worksheet("B1").Value = "Product"
            worksheet("C1").Value = "Quantity"
            worksheet("D1").Value = "Revenue"
            worksheet("E1").Value = "Profit Margin"
            Dim headerRange = worksheet("A1:E1")
            headerRange.Style.Font.Bold = True
            headerRange.Style.BackgroundColor = "#4472C4"
            headerRange.Style.Font.Color = "#FFFFFF"
            Dim row As Integer = 2
            For Each sale In salesData
                worksheet($"A{row}").Value = sale.Date.ToString("yyyy-MM-dd")
                worksheet($"B{row}").Value = If(sale.Product, "Unknown")
                worksheet($"C{row}").Value = sale.Quantity
                worksheet($"D{row}").Value = sale.Revenue
                worksheet($"E{row}").Value = $"=D{row}*0.15"
                row += 1
            Next
            worksheet.AutoSizeColumn(0, True)
            Using ms = workbook.ToStream()
                Return ms.ToArray()
            End Using
        Catch ex As Exception
            Throw New InvalidOperationException("Failed to generate sales report", ex)
        End Try
    End Function
End Class

Ta usługa prezentuje kluczowe funkcje IronXL, w tym tworzenie nowych skoroszytów i arkuszy, dodawanie sformatowanych nagłówków, wypełnianie wierszy danymi zaimportowanymi ze źródła danych, stosowanie formuł oraz obsługę potencjalnych błędów. Metoda AutoSizeColumn zapewnia prawidlowe wyswietlanie kolumn, niezaleznie od dlugosci tresci. Aby uzyskać dostęp do bardziej zaawansowanych opcji formatowania, zapoznaj się z naszym przewodnikiem po stylach komórek.

Jak zaimplementować pobieranie plików w Blazorze?

Utwórz komponent Razor, który korzysta z usługi eksportu i obsługuje interakcje użytkownika:

@page "/excel-export"
@using ExportExcel.Models
@inject ExcelExportService ExcelService
@inject IJSRuntime JS
<h3>Excel Export Dashboard</h3>
<div class="export-section">
    <button class="btn btn-primary" @onclick="ExportSalesReport" disabled="@isExporting">
        @if (isExporting)
        {
            <span>Generating...</span>
        }
        else
        {
            <span>Export Sales Report</span>
        }
    </button>
    @if (!string.IsNullOrEmpty(errorMessage))
    {
        <div class="alert alert-danger mt-2">@errorMessage</div>
    }
</div>
@code {
    private bool isExporting = false;
    private string errorMessage = "";
    private async Task ExportSalesReport()
    {
        try
        {
            isExporting = true;
            errorMessage = "";
            var salesData = GetSalesData();
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync("downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef);
        }
        catch (Exception ex)
        {
            errorMessage = "Export failed. Please try again.";
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        return new List<SalesData>
        {
            new() { Date = DateTime.Now, Product = "Widget A",
                   Quantity = 100, Revenue = 5000 },
            new() { Date = DateTime.Now.AddDays(-1), Product = "Widget B",
                   Quantity = 75, Revenue = 3750 }
        };
    }
}

@page "/excel-export"
@using ExportExcel.Models
@inject ExcelExportService ExcelService
@inject IJSRuntime JS
<h3>Excel Export Dashboard</h3>
<div class="export-section">
    <button class="btn btn-primary" @onclick="ExportSalesReport" disabled="@isExporting">
        @if (isExporting)
        {
            <span>Generating...</span>
        }
        else
        {
            <span>Export Sales Report</span>
        }
    </button>
    @if (!string.IsNullOrEmpty(errorMessage))
    {
        <div class="alert alert-danger mt-2">@errorMessage</div>
    }
</div>
@code {
    private bool isExporting = false;
    private string errorMessage = "";
    private async Task ExportSalesReport()
    {
        try
        {
            isExporting = true;
            errorMessage = "";
            var salesData = GetSalesData();
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            using var stream = new MemoryStream(fileBytes);
            using var streamRef = new DotNetStreamReference(stream);
            await JS.InvokeVoidAsync("downloadFileFromStream",
                $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef);
        }
        catch (Exception ex)
        {
            errorMessage = "Export failed. Please try again.";
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        return new List<SalesData>
        {
            new() { Date = DateTime.Now, Product = "Widget A",
                   Quantity = 100, Revenue = 5000 },
            new() { Date = DateTime.Now.AddDays(-1), Product = "Widget B",
                   Quantity = 75, Revenue = 3750 }
        };
    }
}

Text

Ten komponent zapewnia użytkownikowi informacje zwrotne podczas eksportu, płynnie radzi sobie z błędami i generuje nazwy plików z oznaczeniem czasu. Wrapper DotNetStreamReference umozliwia wydajne przesylanie danych binarnych do JavaScript.

Wynik

Po uruchomieniu kodu zobaczymy naszą stronę z przyciskiem, który będzie służył do obsługi procesu eksportowania.

Blazor Eksport do Excela: Kompletny przewodnik po uzyciu IronXL w C#: Obrazek 1 - Przykladowa strona Blazor

Po kliknięciu przycisku dane zostaną zapisane w nowym dokumencie Excel, a wyeksportowany plik zostanie pobrany.

Blazor Eksport do Excela: Kompletny przewodnik po uzyciu IronXL w C#: Obrazek 2 - Dane wyeksportowane do pliku Excel

Jakie zaawansowane funkcje IronXL może dodać do Twojego eksportu do Excela?

IronXL obsługuje zaawansowane funkcje programu Excel, umożliwiające tworzenie profesjonalnie wyglądających eksportów. W przypadku scenariusza zarządzania zapasami można dodać formatowanie warunkowe i wiele arkuszy:

using IronXL;
using ExportExcel.Models;
using System.IO;
namespace ExportExcel.Services
{
    public class InventoryExportService
    {
        public byte[] GenerateInventoryReport(List<InventoryItem> items)
        {
            var workbook = WorkBook.Create();
            var details = workbook.CreateWorkSheet("Inventory Details");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2;
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                if (item.Quantity < item.ReorderLevel)
                {
                    details[$"C{row}"].Style.BackgroundColor = "#FFB6B6";
                }
            }
            using var stream = workbook.ToStream();
            return stream.ToArray();
        }
    }
}

using IronXL;
using ExportExcel.Models;
using System.IO;
namespace ExportExcel.Services
{
    public class InventoryExportService
    {
        public byte[] GenerateInventoryReport(List<InventoryItem> items)
        {
            var workbook = WorkBook.Create();
            var details = workbook.CreateWorkSheet("Inventory Details");
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2;
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                if (item.Quantity < item.ReorderLevel)
                {
                    details[$"C{row}"].Style.BackgroundColor = "#FFB6B6";
                }
            }
            using var stream = workbook.ToStream();
            return stream.ToArray();
        }
    }
}

Imports IronXL
Imports ExportExcel.Models
Imports System.IO

Namespace ExportExcel.Services
    Public Class InventoryExportService
        Public Function GenerateInventoryReport(items As List(Of InventoryItem)) As Byte()
            Dim workbook = WorkBook.Create()
            Dim details = workbook.CreateWorkSheet("Inventory Details")
            details("A1").Value = "SKU"
            details("B1").Value = "Name"
            details("C1").Value = "Quantity"
            Dim headerRange = details("A1:C1")
            headerRange.Style.Font.Bold = True
            For i As Integer = 0 To items.Count - 1
                Dim row = i + 2
                Dim item = items(i)
                details($"A{row}").Value = item.SKU
                details($"B{row}").Value = item.Name
                details($"C{row}").Value = item.Quantity
                If item.Quantity < item.ReorderLevel Then
                    details($"C{row}").Style.BackgroundColor = "#FFB6B6"
                End If
            Next
            Using stream = workbook.ToStream()
                Return stream.ToArray()
            End Using
        End Function
    End Class
End Namespace

Imports IronXL
Imports ExportExcel.Models
Imports System.IO

Namespace ExportExcel.Services
    Public Class InventoryExportService
        Public Function GenerateInventoryReport(items As List(Of InventoryItem)) As Byte()
            Dim workbook = WorkBook.Create()
            Dim details = workbook.CreateWorkSheet("Inventory Details")
            details("A1").Value = "SKU"
            details("B1").Value = "Name"
            details("C1").Value = "Quantity"
            Dim headerRange = details("A1:C1")
            headerRange.Style.Font.Bold = True
            For i As Integer = 0 To items.Count - 1
                Dim row = i + 2
                Dim item = items(i)
                details($"A{row}").Value = item.SKU
                details($"B{row}").Value = item.Name
                details($"C{row}").Value = item.Quantity
                If item.Quantity < item.ReorderLevel Then
                    details($"C{row}").Style.BackgroundColor = "#FFB6B6"
                End If
            Next
            Using stream = workbook.ToStream()
                Return stream.ToArray()
            End Using
        End Function
    End Class
End Namespace

IronXL bez trudu obsługuje wiele arkuszy, stosuje formatowanie warunkowe oparte na regułach biznesowych oraz w razie potrzeby obsługuje zaawansowane funkcje programu Excel, takie jak tabele przestawne i wykresy. Szczegółową dokumentację API można znaleźć w naszym obszernym przewodniku referencyjnym.

Blazor Eksport do Excela: Kompletny przewodnik po uzyciu IronXL w C#: Obrazek 3 - Przyklad zaawansowanych funkcji

Wnioski

IronXL zmienia generowanie plików Excel w aplikacjach Blazor Server ze skomplikowanego wyzwania w proste zadanie. Jego intuicyjny interfejs API eliminuje konieczność instalowania pakietu Microsoft Office, zapewniając jednocześnie dostęp do zaawansowanych funkcji programu Excel. Od prostego eksportu danych po złożone, wielarkuszowe raporty z formułami i formatowaniem — IronXL radzi sobie ze wszystkim, zapewniając doskonałą wydajność i niezawodność.

Chcesz wzbogacić swoje aplikacje Blazor o profesjonalne funkcje eksportu do Excela? Rozpocznij bezpłatny okres próbny IronXL już dziś lub zapoznaj się z naszymi opcjami licencyjnymi dotyczącymi wdrożenia produkcyjnego.

Curtis Chau

Czat z zespołem inżynierów teraz

Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.

...

Czytaj więcej