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.
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):
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);
}Dodaj ten skrypt do pliku _Host.cshtml:
<script src="~/excelExport.js"></script>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.
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);
}
}
}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 ClassTa 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.
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"
@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
}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.
Po uruchomieniu kodu zobaczymy naszą stronę z przyciskiem, który będzie służył do obsługi procesu eksportowania.
Po kliknięciu przycisku dane zostaną zapisane w nowym dokumencie Excel, a wyeksportowany plik zostanie pobrany.
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");
// 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 NamespaceIronXL 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.
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 w celu wdrożenia produkcyjnego.
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.
IronXL jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
API Excel, którego potrzebujesz, bez trudności z Office Interop.
