Eksportowanie danych do programu Excel jest standardowym wymaganiem w aplikacjach internetowych ASP.NET Core. Niezależnie od tego, czy generujesz raporty sprzedaży, umożliwiasz użytkownikom pobieranie zawartości GridView, czy tworzysz pliki CSV na podstawie zapytań do bazy danych, wybrane podejście decyduje o tym, czy wynikowy plik otworzy się poprawnie w programie Microsoft Excel, czy też wywoła ostrzeżenia dotyczące formatu. W tym artykułe porównano najpopularniejsze metody eksportu do Excela dostępne dla programistów C# — tradycyjne strumieniowanie oparte na HTML oraz nowoczesne rozwiązania biblioteczne, w tym IronXL, ClosedXML i EPPlus — aby umożliwić wybór odpowiedniego narzędzia do danego projektu.
Bezpłatna próba, aby zobaczyć, jak IronXL radzi sobie z generowaniem plików Excel w aplikacjach ASP.NET Core.
Programiści .NET Core mają do wyboru kilka ścieżek podczas dodawania funkcji eksportu do Excela. Każde z tych rozwiązań różni się pod względem jakości pliku wyjściowego, nakładu pracy wymaganego do jego wdrożenia oraz konsekwencji licencyjnych dla projektów komercyjnych.
Tradycyjne przesyłanie strumieniowe typu MIME jest najstarszą techniką. Serwer ustawia nagłówek Content-Type odpowiedzi na application/vnd.ms-excel i zapisuje tabelę HTML do strumienia wyjściowego. Przeglądarka interpretuje to jako plik Excel do pobrania, ale plik zawiera znaczniki HTML zamiast prawdziwych danych arkusza kalkulacyjnego. Program Microsoft Excel wykrywa niezgodność i wyświetla ostrzeżenie dotyczące formatu przed otwarciem pliku. Ta metoda nie obsługuje formuł, kolumn z wpisanymi danymi ani prawidłowego formatowania komórek.
Rozwiązania oparte na bibliotekach dodają pakiet NuGet, który tworzy autentyczne pliki XLSX przy użyciu formatu Open XML zdefiniowanego przez Microsoft. Dostępne opcje to IronXL, ClosedXML i EPPlus. Wszystkie trzy generują poprawne pliki Excel, które otwierają się bez ostrzeżeń, obsługują formatowanie na poziomie komórek i współpracują z .NET Core. Oficjalna dokumentacja .NET dotycząca pobierania plików obejmuje podstawowe mechanizmy ASP.NET Core wykorzystywane we wszystkich tych podejściach.
Tabela poniżej podsumowuje kluczowe róznice:
| Funkcja | Typ MIME / HTML | ClosedXML | EPPlus | IronXL |
|---|---|---|---|---|
| Oryginalny plik wyjściowy XLSX | Nie | Tak | Tak | Tak |
| Obsługa plików CSV | Podręcznik | Ograniczone | Ograniczone | Język ojczysty |
| Otwiera się bez ostrzeżenia programu Excel | Nie | Tak | Tak | Tak |
| Obsługa formuł | Nie | Tak | Tak | Tak |
| Eksport do formatów JSON i XML | Nie | Nie | Nie | Tak |
| Licencja komercyjna | Nie dotyczy | MIT | Polyform | Komercjalne |
| Obsługa .NET Core | Tak | Tak | Tak | Tak |
Przed napisaniem jakiegokolwiek kodu eksportującego dodaj IronXL do swojego projektu za pomocą menedżera pakietów NuGet lub interfejsu CLI .NET. IronXL nie jest zależny od pakietu Microsoft Office ani interoperacyjności COM, więc instalacja jest prosta na każdym systemie operacyjnym obsługiwanym przez .NET.
Alternatywnie można użyć konsoli menedżera pakietów w Visual Studio:
Po zainstalowaniu pakietu, dodaj using IronXL; do dowolnej klasy kontrolera lub usługi, która potrzebuje generować pliki Excel. W przypadku podstawowych scenariuszy eksportu nie jest wymagana żadna dodatkowa konfiguracja. Aby zapoznać się z opcjami licencjonowania i wdrażania, odwiedź stronę licencyjną IronXL.
W starszych wersjach WebForms i niektórych starszych wzorcach MVC programiści eksportowali dane GridView, renderując je jako HTML i przesyłając strumieniowo do przeglądarki z mylącym nagłówkiem Content-Type. Aplikacja wywołuje Response.AddHeader, aby ustawić nazwę pliku i bezpośrednio zapisuje wyjście HTML.
// Traditional approach -- exports HTML disguised as Excel
public void ExportToExcel(object sender, EventArgs e)
{
Response.Clear();
Response.Buffer = true;
Response.ContentType = "application/vnd.ms-excel";
Response.AddHeader("content-disposition", "attachment;filename=Report.xls");
StringWriter stringWriter = new StringWriter();
HtmlTextWriter htmlTextWriter = new HtmlTextWriter(stringWriter);
// Render grid content as HTML
DataGrid1.RenderControl(htmlTextWriter);
Response.Write(stringWriter.ToString());
Response.End();
}
public override void VerifyRenderingInServerForm(Control control)
{
// Required to prevent server form rendering errors
}' Traditional approach -- exports HTML disguised as Excel
Public Sub ExportToExcel(sender As Object, e As EventArgs)
Response.Clear()
Response.Buffer = True
Response.ContentType = "application/vnd.ms-excel"
Response.AddHeader("content-disposition", "attachment;filename=Report.xls")
Dim stringWriter As New StringWriter()
Dim htmlTextWriter As New HtmlTextWriter(stringWriter)
' Render grid content as HTML
DataGrid1.RenderControl(htmlTextWriter)
Response.Write(stringWriter.ToString())
Response.End()
End Sub
Public Overrides Sub VerifyRenderingInServerForm(control As Control)
' Required to prevent server form rendering errors
End Sub
Ta metoda wymaga zastąpienia VerifyRenderingInServerForm, aby ominąć weryfikację po stronie serwera. Wygenerowany plik zawiera kod HTML zamiast prawdziwych danych arkusza kalkulacyjnego, więc program Microsoft Excel wyświetla ostrzeżenie o formacie, gdy użytkownik go otwiera. Wynik nie może obsługiwać formuł arkusza kalkulacyjnego, kolumn danych wpisanych ręcznie ani formatowania na poziomie komórek. Dla jakiegokolwiek nowego rozwoju ASP.NET Core, tego wzorca należy unikać na rzecz odpowiedniej biblioteki Excel.
IronXL udostępnia API do tworzenia autentycznych plików XLSX bez konieczności korzystania z pakietu Microsoft Office lub interoperacyjności COM. Biblioteka IronXL tworzy obiekty skoroszytów całkowicie w kodzie zarządzanym, dzięki czemu działa na systemach Linux, macOS i Windows bez dodatkowych zależności.
Poniższy przykład tworzy skoroszyt, wypełnia arkusz danymi dotyczącymi sprzedaży, stosuje pogrubienie w wierszu nagłówkowym i przesyła plik do przeglądarki:
using IronXL;
using Microsoft.AspNetCore.Mvc;
public class ExportController : Controller
{
[HttpPost]
public IActionResult ExportReport()
{
// Create workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");
// Add header row
worksheet["A1"].Value = "Product";
worksheet["B1"].Value = "Quantity";
worksheet["C1"].Value = "Revenue";
// Populate data rows
worksheet["A2"].Value = "Widget A";
worksheet["B2"].Value = 150;
worksheet["C2"].Value = 4500.00;
worksheet["A3"].Value = "Widget B";
worksheet["B3"].Value = 230;
worksheet["C3"].Value = 6900.00;
// Apply bold formatting to headers
var headerRange = worksheet["A1:C1"];
headerRange.Style.Font.Bold = true;
// Stream file to browser
byte[] fileBytes = workbook.ToByteArray();
string filename = $"SalesReport_{DateTime.Niew:yyyyMMdd}.xlsx";
return File(fileBytes,
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
filename);
}
}Imports IronXL
Imports Microsoft.AspNetCore.Mvc
Public Class ExportController
Inherits Controller
<HttpPost>
Public Function ExportReport() As IActionResult
' Create workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Sales Data")
' Add header row
worksheet("A1").Value = "Product"
worksheet("B1").Value = "Quantity"
worksheet("C1").Value = "Revenue"
' Populate data rows
worksheet("A2").Value = "Widget A"
worksheet("B2").Value = 150
worksheet("C2").Value = 4500.0
worksheet("A3").Value = "Widget B"
worksheet("B3").Value = 230
worksheet("C3").Value = 6900.0
' Apply bold formatting to headers
Dim headerRange = worksheet("A1:C1")
headerRange.Style.Font.Bold = True
' Stream file to browser
Dim fileBytes As Byte() = workbook.ToByteArray()
Dim filename As String = $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx"
Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", filename)
End Function
End Class
WorkBook.Create konstruuje nowy dokument Excel w pamięci. CreateWorkSheet dodaje nazwany arkusz widoczny przez użytkowników na dole okna Excela. Wartości komórek są przypisywane przy użyciu notacji zakresu w stylu Excela ("A1", "B2"), która dla większości programistów C# jest czytelna i łatwa w utrzymaniu.
Metoda ToByteArray() konwertuje gotowy skoroszyt na tablicę bajtów, którą metoda odpowiedzi File() ASP.NET Core przesyła bezpośrednio do przeglądarki użytkownika z odpowiednim typem MIME i nagłówkami dyspozycji zawartości. Pobrany plik otwiera się w programie Excel bez żadnych ostrzeżeń dotyczących formatowania.
IronXL obsługuje również eksport do formatu CSV za pomocą metody SaveAsCsv:
// Export as CSV instead of XLSX
workbook.SaveAsCsv("output.csv");netW scenariuszach, gdy trzeba wyeksportować dane arkusza jako JSON lub XML, IronXL oferuje metody SaveAsJson i SaveAsXml — funkcje niedostępne w ClosedXML ani EPPlus. Dodatkowe wzorce można znaleźć w przykładach kodu IronXL i Dokumentacji API.
Wiele aplikacji .NET Core pobiera dane z serwera SQL lub innej relacyjnej bazy danych przed ich eksportem. IronXL zapewnia pierwszorzędne wsparcie dla bezpośredniego ładowania DataTable do arkusza, eliminując potrzebę ręcznego iterowania wierszy.
Przykład poniżej wykonuje zapytanie do bazy danych za pomocą ADO.NET i wypełnia arkusz Excela wynikowym DataTable:
using IronXL;
using System.Data;
using System.Data.SqlClient;
using Microsoft.AspNetCore.Mvc;
public class ReportController : Controller
{
private readonly string _connectionString;
public ReportController(IConfiguration config)
{
_connectionString = config.GetConnectionString("DefaultConnection");
}
[HttpGet]
public IActionResult DownloadReport()
{
DataTable table = new DataTable();
using (SqlConnection connection = new SqlConnection(_connectionString))
{
string query = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders";
using SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
adapter.Fill(table);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Orders");
// Write column headers from DataTable schema
for (int col = 0; col < table.Columns.Count; col++)
{
worksheet[0, col].Value = table.Columns[col].ColumnName;
}
// Write data rows
for (int row = 0; row < table.Rows.Count; row++)
{
for (int col = 0; col < table.Columns.Count; col++)
{
worksheet[row + 1, col].Value = table.Rows[row][col].ToString();
}
}
byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes,
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"Orders.xlsx");
}
}Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Imports Microsoft.AspNetCore.Mvc
Public Class ReportController
Inherits Controller
Private ReadOnly _connectionString As String
Public Sub New(config As IConfiguration)
_connectionString = config.GetConnectionString("DefaultConnection")
End Sub
<HttpGet>
Public Function DownloadReport() As IActionResult
Dim table As New DataTable()
Using connection As New SqlConnection(_connectionString)
Dim query As String = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders"
Using adapter As New SqlDataAdapter(query, connection)
adapter.Fill(table)
End Using
End Using
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Orders")
' Write column headers from DataTable schema
For col As Integer = 0 To table.Columns.Count - 1
worksheet(0, col).Value = table.Columns(col).ColumnName
Next
' Write data rows
For row As Integer = 0 To table.Rows.Count - 1
For col As Integer = 0 To table.Columns.Count - 1
worksheet(row + 1, col).Value = table.Rows(row)(col).ToString()
Next
Next
Dim fileBytes As Byte() = workbook.ToByteArray()
Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Orders.xlsx")
End Function
End ClassTen wzorzec sprawia, że kontroler jest zwięzły i łatwy do testowania. Zapytania do bazy danych i tworzenie skoroszytów są wyraźnie oddzielone, co ułatwia wymianę źródła danych lub dodawanie dodatkowych arkuszy na potrzeby danych podsumowujących. Aby uzyskać wskazówki dotyczące czytania istniejących plików Excel do DataTable, zobacz przewodnik jak odczytywać pliki Excel w IronXL.
ClosedXML otacza pakiet Microsoft Open XML SDK przystępnym interfejsem API. Zainstaluj z NuGet:
Install-Package ClosedXMLPoniższy przykład przedstawia typową operację eksportu ClosedXML:
using ClosedXML.Excel;
using Microsoft.AspNetCore.Mvc;
public class ExportController : Controller
{
[HttpGet]
public IActionResult ExportWithClosedXML()
{
using var workbook = new XLWorkbook();
var worksheet = workbook.AddWorksheet("Data");
worksheet.Cell(1, 1).Value = "Name";
worksheet.Cell(1, 2).Value = "Amount";
worksheet.Cell(2, 1).Value = "Alpha";
worksheet.Cell(2, 2).Value = 1200;
using var stream = new MemoryStream();
workbook.SaveAs(stream);
return File(stream.ToArray(),
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"export.xlsx");
}
}Imports ClosedXML.Excel
Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Public Class ExportController
Inherits Controller
<HttpGet>
Public Function ExportWithClosedXML() As IActionResult
Using workbook As New XLWorkbook()
Dim worksheet = workbook.AddWorksheet("Data")
worksheet.Cell(1, 1).Value = "Name"
worksheet.Cell(1, 2).Value = "Amount"
worksheet.Cell(2, 1).Value = "Alpha"
worksheet.Cell(2, 2).Value = 1200
Using stream As New MemoryStream()
workbook.SaveAs(stream)
Return File(stream.ToArray(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "export.xlsx")
End Using
End Using
End Function
End Class
ClosedXML używa adresowania komórek opartego na liczbach całkowitych (Cell(row, col)) zamiast notacji ciągów zakresu stosowanej przez IronXL. Oba podejścia generują poprawne pliki XLSX. ClosedXML jest wydany na zasadach licencji MIT, czyniąc go odpowiednim do projektów open-source bez obaw o licencjonowanie komercyjne. Repozytorium ClosedXML na GitHubie umożliwia śledzenie zgłoszeń i zawiera przykłady udostępnione przez społeczność.
EPPlus oferuje podobna funkcjonalnosc na podstawie swojej licencji Polyform Nien-Comercial do użytku niekomercyjnego, z wymagana licencją komercyjna do wdrożeń produkcyjnych. Zapoznaj sie z przeglądem licencji EPPlus przed użyciem go w produkcie komercyjnym. Zarówno EPPlus, jak i ClosedXML generują poprawne pliki Excel, ale żadne z nich nie oferuje natywnego eksportu do formatów CSV, JSON lub XML w taki sposób, jak robi to IronXL.
Poniższa tabela zawiera porównanie konkretnych funkcji istotnych dla produkcyjnych aplikacji ASP.NET Core:
| Możliwości | IronXL | ClosedXML | EPPlus |
|---|---|---|---|
| Eksport do formatów CSV, JSON i XML | Język ojczysty | Niedostępne | Niedostępne |
| Integracja z DataTable | Tak | Tak | Tak |
| Wsparcie techniczne | Dolaczone z licencja | Tylko dla społeczności | Poziom płatny |
| Zależność od pakietu Microsoft Office | Niene | Niene | Niene |
| Wielopłatformowość (.NET na Linuksie) | Tak | Tak | Tak |
| Rodzaj licencji | Komercjalne | MIT | Polyform / Komercyjne |
Wybór odpowiedniej biblioteki do eksportu do Excela zależy od trzech czynników: wymaganych formatów wyjściowych, ograniczeń licencyjnych projektu oraz tego, czy potrzebne jest profesjonalne wsparcie.
Wybierz IronXL, jeśli Twoja aplikacja wymaga obsługi wielu formatów wyjściowych (XLSX, CSV, JSON, XML), jeśli tworzysz produkt komercyjny wymagający gwarantowanego kanału wsparcia lub jeśli potrzebujesz zaawansowanych funkcji programu Excel, takich jak obliczanie formuł, stylizacja komórek lub generowanie wykresów. Dokumentacja IronXL pokrywa każdy API surface w detalach, a zespol wsparcia odpowiada bezpośrednio posiadaczom licencji. Zapoznaj się z blogiem IronXL, aby uzyskać dodatkowe wzorce i samouczki.
Wybierz ClosedXML, jeśli Twój projekt jest open-source lub niekomercyjny i wymaga wyłącznie plików XLSX. Licencja MIT nie nakłada żadnych ograniczeń na redystrybucje, a API jest dobrze udokumentowane poprzez zasoby spolecznosci.
Wybierz EPPlus, kiedy istniejąca baza kod (codebase) juz uzywa EPPlus i migracja do innej biblioteki kosztowalaby więcej niż zakup licencji komercyjnej.
Dla zespołów oceniających IronXL przeciwko jego alternatywom, licencja probna IronXL pozwala na pelnofunkcyjne testowanie przed zaangazowaniem się w zakup. Dodatkowe przykłady kodu dotyczące odczytu i zapisu plików Excel są dostępne na stronie z przykładami IronXL.
Po zapoznaniu się z dostępnymi metodami eksportu do Excela dla ASP.NET Core możesz wykonać następujące kroki, aby przejść dalej:
dotnet add package IronXL.Excel i przejdź przez przewodnik wprowadzający, aby stworzyć swój pierwszy skoroszyt.SaveAsCsv, SaveAsJson i SaveAsXml, jeśli Twoja aplikacja wymaga eksportowania danych w wielu formatach z tej samej bazy kodu.Response.ContentType = "application/vnd.ms-excel" w Twoim rozwiązaniu i zastępując je tworzeniem skoroszytów IronXL, eliminując ostrzeżenia o formacie dla Twoich użytkowników.Dla wdrożeń produkcyjnych, kup licencje, aby odblokować profesjonalne wsparcie i zapewnić zgodność z warunkami licencji IronXL.
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.
