Ikona wiadomości
Przejdź do treści stopki
  1. IronXL
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. Blazor Export Excel
KORZYSTANIE Z IRONXL

Jak wyeksportować dane do Excela w Blazorze przy użyciu IronXL

Jordi Bardia
Jordi Bardia
Zaktualizowano:

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

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

Dodaj ten skrypt do 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)
        {
        // If the program fails to return file
            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)
        {
        // If the program fails to return file
            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
            ' If the program fails to return file
            Throw New InvalidOperationException("Failed to generate sales report", ex)
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

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 prawidłowe wyświetlanie kolumn niezależnie od długości treści. 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 = "";
            // Generate sample data - replace with actual data source
            var salesData = GetSalesData();
            // Generate Excel file
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            // Trigger download using a memory stream to handle the file
            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.";
            // Log exception details for debugging
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        // Return your actual data here
        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 = "";
            // Generate sample data - replace with actual data source
            var salesData = GetSalesData();
            // Generate Excel file
            var fileBytes = ExcelService.GenerateSalesReport(salesData);
            // Trigger download using a memory stream to handle the file
            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.";
            // Log exception details for debugging
        }
        finally
        {
            isExporting = false;
        }
    }
    private List<SalesData> GetSalesData()
    {
        // Return your actual data here
        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"
@Imports 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 Then
            <span>Generating...</span>
        Else
            <span>Export Sales Report</span>
        End If
    </button>
    @If Not String.IsNullOrEmpty(errorMessage) Then
        <div class="alert alert-danger mt-2">@errorMessage</div>
    End If
</div>
@code {
    Private isExporting As Boolean = False
    Private errorMessage As String = ""
    Private Async Function ExportSalesReport() As Task
        Try
            isExporting = True
            errorMessage = ""
            ' Generate sample data - replace with actual data source
            Dim salesData = GetSalesData()
            ' Generate Excel file
            Dim fileBytes = ExcelService.GenerateSalesReport(salesData)
            ' Trigger download using a memory stream to handle the file
            Using stream As New MemoryStream(fileBytes)
                Using streamRef As New DotNetStreamReference(stream)
                    Await JS.InvokeVoidAsync("downloadFileFromStream", $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx", streamRef)
                End Using
            End Using
        Catch ex As Exception
            errorMessage = "Export failed. Please try again."
            ' Log exception details for debugging
        Finally
            isExporting = False
        End Try
    End Function

    Private Function GetSalesData() As List(Of SalesData)
        ' Return your actual data here
        Return New List(Of SalesData) From {
            New SalesData With {.Date = DateTime.Now, .Product = "Widget A", .Quantity = 100, .Revenue = 5000},
            New SalesData With {.Date = DateTime.Now.AddDays(-1), .Product = "Widget B", .Quantity = 75, .Revenue = 3750}
        }
    End Function
}
$vbLabelText   $csharpLabel

Ten komponent zapewnia użytkownikowi informacje zwrotne podczas eksportu, płynnie radzi sobie z błędami i generuje nazwy plików z oznaczeniem czasu. Owijka DotNetStreamReference umożliwia wydajne przesyłanie strumieniowe 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.

Jak eksportować do Excela w Blazorze przy użyciu IronXL: Rysunek 1 – Przykładowa strona Blazor

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

Jak eksportować do Excela w Blazorze przy użyciu IronXL: Rysunek 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 warunkówe 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");
            // Add headers
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            // Apply bold font for headers
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2; // start from row 2
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                // Highlight low stock items
                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");
            // Add headers
            details["A1"].Value = "SKU";
            details["B1"].Value = "Name";
            details["C1"].Value = "Quantity";
            // Apply bold font for headers
            var headerRange = details["A1:C1"];
            headerRange.Style.Font.Bold = true;
            for (int i = 0; i < items.Count; i++)
            {
                var row = i + 2; // start from row 2
                var item = items[i];
                details[$"A{row}"].Value = item.SKU;
                details[$"B{row}"].Value = item.Name;
                details[$"C{row}"].Value = item.Quantity;
                // Highlight low stock items
                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")
            ' Add headers
            details("A1").Value = "SKU"
            details("B1").Value = "Name"
            details("C1").Value = "Quantity"
            ' Apply bold font for headers
            Dim headerRange = details("A1:C1")
            headerRange.Style.Font.Bold = True
            For i As Integer = 0 To items.Count - 1
                Dim row = i + 2 ' start from row 2
                Dim item = items(i)
                details($"A{row}").Value = item.SKU
                details($"B{row}").Value = item.Name
                details($"C{row}").Value = item.Quantity
                ' Highlight low stock items
                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
$vbLabelText   $csharpLabel

IronXL bez trudu obsługuje wiele arkuszy, stosuje formatowanie warunkówe 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.

Jak eksportować do Excela w Blazorze przy użyciu IronXL: Rysunek 3 – Przykładowy wynik zaawansowanych funkcji

Wnioski

IronXL zmienia generowanie plików Excel w aplikacjach Blazor Server ze skomplikówanego 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 w celu wdrożenia produkcyjnego.

Często Zadawane Pytania

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

Możesz użyć IronXL do eksportowania plików Excel w aplikacji Blazor Server. IronXL pozwala tworzyć, formatować i pobierać pliki Excel bezpośrednio z serwera bez konieczności korzystania z pakietu Microsoft Office.

Czy potrzebuję pakietu Microsoft Office, aby pracować z plikami Excel w Blazorze?

Nie, IronXL umożliwia pracę z plikami Excel bez konieczności posiadania pakietu Microsoft Office. Zapewnia funkcjonalność tworzenia i edycji plików Excel bezpośrednio w aplikacji Blazor.

Jakie są zalety korzystania z IronXL do eksportu do Excela w Blazorze?

IronXL oferuje płynną integrację z Blazorem, umożliwiając łatwe tworzenie, formatowanie i eksportowanie plików Excel. Upraszcza to proces, eliminuje potrzebę korzystania z pakietu Microsoft Office i obsługuje różne formaty Excel.

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

Tak, IronXL płynnie integruje się z komponentami Blazor, umożliwiając łatwe dodanie funkcji eksportu do Excela do Twoich aplikacji.

Czy w Blazorze można formatować pliki Excel za pomocą IronXL?

Tak, IronXL oferuje kompleksowe funkcje do formatowania plików Excel, w tym stylizację komórek, dostosowywanie szerokości kolumn i konfigurowanie złożonych formuł — wszystko to w ramach aplikacji Blazor Server.

Jak radzić sobie z dużymi zbiorami danych podczas eksportowania do Excela w Blazorze?

IronXL został zaprojektowany do wydajnej obsługi dużych zbiorów danych, zapewniając płynne działanie podczas eksportowania obszernych danych do plików Excel w środowisku Blazor Server.

Jakie formaty plików Excel są obsługiwane przez IronXL?

IronXL obsługuje różne formaty plików Excel, w tym XLS, XLSX i CSV, co zapewnia elastyczność w eksportowaniu i pracy z danymi Excel w aplikacjach Blazor.

Czy IronXL może być używany do generowania raportów w Blazorze?

Oczywiście, IronXL idealnie nadaje się do generowania szczegółowych raportów w aplikacjach Blazor. Oferuje solidne funkcje do kompilacji, formatowania i eksportowania danych do profesjonalnych raportów w formacie Excel.

W jaki sposób IronXL zapewnia integralność danych podczas eksportowania plików Excel?

IronXL zapewnia integralność danych poprzez dokładne zachowanie struktury i formatowania danych podczas procesu eksportu, co czyni go niezawodnym rozwiązaniem dla aplikacji Blazor.

Czy istnieje sposób na zautomatyzowanie tworzenia plików Excel w aplikacji Blazor Server przy użyciu IronXL?

Tak, IronXL może służyć do automatyzacji tworzenia i eksportu plików Excel w aplikacjach Blazor Server, co pozwala usprawnić przepływ pracy i zwiększyć wydajność.

Jordi Bardia
Jordi Bardia
  Czat z zespołem inżynierów teraz
Inżynier oprogramowania
Jordi jest najbardziej biegły w Pythonie, C# i C++. Kiedy nie wykorzystuje swoich umiejętności w Iron Software, programuje gry. Dzieląc odpowiedzialność za testowanie produktów, rozwój produktów i badania, Jordi wnosi ogromną wartość do ciągłej poprawy produktów. Różnorodne doświadczenia ...
Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie