ASP.NET Eksport do Excela: Porownanie IronXL, ClosedXML i EPPlus
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.
Rozpocznij bezpłatny okres próbny, aby zobaczyć, jak IronXL radzi sobie z generowaniem plików Excel w aplikacjach ASP.NET Core.
Jakie są popularne metody eksportowania danych do Excela w 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 wymagańego 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.
Poniższa tabela podsumowuje kluczowe różnice:
| 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 |
Jak zainstalować IronXL w projekcie ASP.NET Core?
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.
dotnet add package IronXl.Exceldotnet add package IronXl.ExcelAlternatywnie można użyć konsoli menedżera pakietów w Visual Studio:
Install-Package IronXl.ExcelInstall-Package IronXl.ExcelPo zainstalowaniu pakietu dodaj using IronXL; do dowolnej klasy kontrolera lub usługi, która musi generować pliki Excel. W przypadku podstawowych scenariuszy eksportu nie jest wymagańa żadna dodatkowa konfiguracja. Aby zapoznać się z opcjami licencjonowania i wdrażania, odwiedź stronę licencyjną IronXL.
Jak działa tradycyjne podejście do eksportu w GridView?
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 w celu ustawienia nazwy pliku i zapisuje wynik w formacie HTML bezpośrednio.
// 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 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 SubWynik dotychczasowy
Ta metoda wymaga nadpisania VerifyRenderingInServerForm w celu ominięcia walidacji 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. W przypadku każdego nowego projektu opartego na .NET Core należy unikać tego wzorca na rzecz odpowiedniej biblioteki Excel.
W jaki sposób IronXL upraszcza generowanie plików Excel w ASP.NET Core?
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);
}
}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 ClassWynik IronXL
WorkBook.Create tworzy nowy dokument Excel w pamięci. CreateWorkSheet dodaje zakładkę o określonej nazwie, którą użytkownicy widzą na dole okna programu Excel. Wartości komórek są przypisywane przy użyciu notacji zakresu w stylu Excela ("A1", "B2"), którą większość programistów C# uważa za czytelna i łatwą w utrzymaniu.
Metoda ToByteArray() konwertuje gotowy skoroszyt na tablicę bajtów, którą metoda odpowiedzi .NET Core File() przesyła strumieniowo bezpośrednio do przeglądarki użytkownika z prawidłowymi nagłówkami typu MIME i dyspozycji treś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");// Export as CSV instead of XLSX
workbook.SaveAsCsv("output.csv");W sytuacjach, gdy konieczne jest wyeksportowanie danych z arkusza jako JSON lub XML, IronXL udostępnia metody SaveAsJson i SaveAsXml — funkcje niedostępne w bibliotekach ClosedXML lub EPPlus. Dodatkowe wzorce można znaleźć w przykładach kodu IronXL i Dokumentacji API.
W jaki sposób IronXL obsługuje integrację tabel danych i baz danych?
Wiele aplikacji .NET Core pobiera dane z serwera SQL lub innej relacyjnej bazy danych przed ich eksportem. IronXL zapewnia doskonałą obsługę ładowania DataTable bezpośrednio do arkusza, eliminując konieczność ręcznego iterowania wierszy.
Poniższy przykład wysyła zapytanie do bazy danych przy użyciu ADO.NET i wypełnia arkusz Excel wynikami 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");
}
}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 wczytywania istniejących plików Excel do DataTable, zapoznaj się z instrukcją obsługi IronXL dotyczącą wczytywania plików Excel.
Jak wypadają w porównaniu ClosedXML i EPPlus?
ClosedXML otacza pakiet Microsoft Open XML SDK przystępnym interfejsem API. Zainstaluj z NuGet:
Install-Package ClosedXMLInstall-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");
}
}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 ClassWynik w formacie ClosedXML
ClosedXML wykorzystuje adresowanie komórek oparte na liczbach całkowitych (Cell(row, col)) zamiast notacji łańcuchowej zakresu stosowanej przez IronXL. Oba podejścia generują poprawne pliki XLSX. ClosedXML jest udostępniane na licencji MIT, dzięki czemu nadaje się do projektów open source bez obaw związanych z licencjami komercyjnymi. Repozytorium ClosedXML na GitHubie umożliwia śledzenie zgłoszeń i zawiera przykłady udostępnione przez społeczność.
EPPlus oferuje podobną funkcjonalność w ramach licencji Polyform Nien-Komercjalne do użytku niekomercyjnego, przy czym do wdrożeń produkcyjnych wymagańa jest licencja komercyjna. Przed użyciem w produkcie komercyjnym zapoznaj się z opisem licencji EPPlus. 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 | W zestawie z licencją | 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 |
Jak wybrać odpowiednią bibliotekę do swojego projektu?
Wybór odpowiedniej biblioteki do eksportu do Excela zależy od trzech czynników: wymagańych 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 szczegółowo opisuje wszystkie interfejsy API, a zespół wsparcia technicznego odpowiada bezpośrednio na pytania posiadaczy 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ń dotyczących redystrybucji, a API jest dobrze udokumentówane dzięki zasobom społeczności.
Wybierz EPPlus, jeśli istniejąca baza kodu już korzysta z EPPlus, a migracja do innej biblioteki kosztowałaby więcej niż zakup licencji komercyjnej.
Dla zespołów oceniających IronXL w porównaniu z alternatywnymi rozwiązaniami, Licencja Trial IronXL umożliwia przetestowanie wszystkich funkcji przed podjęciem decyzji o zakupie. Dodatkowe przykłady kodu dotyczące odczytu i zapisu plików Excel są dostępne na stronie z przykładami IronXL.
Jakie są Twoje kolejne kroki?
Po zapoznaniu się z dostępnymi metodami eksportu do Excela dla ASP.NET Core możesz wykonać następujące kroki, aby przejść dalej:
- Zainstaluj IronXL za pomocą
dotnet add package IronXl.Exceli zapoznaj się z przewodnikiem dla początkujących, aby utworzyć swój pierwszy skoroszyt. - Porównaj wzorce kodu, przeglądając stronę z przykładami IronXL w poszukiwaniu scenariuszy pasujących do Twojego przypadku użycia, takich jak eksport bazy danych, skoroszyty wielarkowe lub raporty stylizowane.
- Zapoznaj się z opcjami licencyjnymi, odwiedzając stronę licencyjną IronXL, aby zrozumieć możliwości wdrożeń w środowisku programistycznym, testowym i produkcyjnym.
- Jeśli Twoja aplikacja wymaga eksportowania danych w wielu formatach z tego samego kodu źródłowego, sprawdź inne formaty, testując metody
SaveAsCsv,SaveAsJsoniSaveAsXml. - Przejdź z kodu legacy, identyfikując wszelkie istniejące wzorce
Response.ContentType = "application/vnd.ms-excel"w swoim rozwiązaniu i zastępując je tworzeniem skoroszytów IronXL, eliminując w ten sposób ostrzeżenia dotyczące formatu dla użytkowników.
W przypadku wdrożeń produkcyjnych należy zakupić licencję, aby uzyskać dostęp do profesjonalnego wsparcia i zapewnić zgodność z warunkami licencji IronXL.
Często Zadawane Pytania
Jakie są kluczowe funkcje IronXL do eksportowania do Excela w ASP.NET Core?
IronXL generuje autentyczne pliki XLSX, CSV, JSON i XML bez konieczności korzystania z pakietu Microsoft Office. Zapewnia intuicyjny interfejs API do zarządzania skoroszytami i arkuszami, stylizacją na poziomie komórek, obliczaniem formuł oraz integracją z DataTable, a wszystko to w ramach standardowego kodu zarządzanego .NET.
Jak IronXL wypada w porównaniu z ClosedXML w przypadku projektów ASP.NET Core?
IronXL obsługuje wiele formatów eksportu (XLSX, CSV, JSON, XML) i oferuje profesjonalne wsparcie w ramach licencji komercyjnej. ClosedXML tworzy poprawne pliki XLSX na licencji MIT, dzięki czemu doskonale nadaje się do projektów open source, które wymagają jedynie eksportu do arkusza kalkulacyjnego.
Czy IronXL nadaje się do tworzenia raportów Excel z baz danych w ASP.NET?
Tak. IronXL współpracuje bezpośrednio z obiektami DataTable i wynikami zapytań ADO.NET, co ułatwia wypełnianie arkuszy z serwera SQL lub innych relacyjnych baz danych oraz przesyłanie wynikowego pliku do przeglądarki.
Jakie są zalety korzystania z IronXL w porównaniu z EPPlus?
IronXL natywnie obsługuje eksport do formatów CSV, JSON i XML, zapewnia profesjonalne wsparcie techniczne w ramach każdej licencji komercyjnej i nie nakłada ograniczeń dotyczących użytkowania niekomercyjnego. EPPlus wymaga oddzielnej licencji komercyjnej do użytku produkcyjnego i nie oferuje natywnego eksportu do wielu formatów.
Czy IronXL może efektywnie obsługiwać duże zbiory danych?
IronXL jest przeznaczony do zadań po stronie serwera i obsługuje duże zbiory danych bez konieczności korzystania z programu Microsoft Excel lub interoperacyjności COM. W przypadku bardzo dużych eksportów strumieniowe przesyłanie tablicy bajtów bezpośrednio przez odpowiedź ASP.NET Core File() pozwala uniknąć buforowania całego pliku w pamięci.
Czy IronXL wymaga zainstalowania pakietu Microsoft Office w celu eksportowania danych do programu Excel?
Nie. IronXL działa całkowicie w zarządzanym kodzie .NET i nie jest zależny od Microsoft Office, COM Interop ani automatyzacji Office. Działa na systemach Windows, Linux i macOS wszędzie tam, gdzie obsługiwany jest .NET.
Rozpocznij za DARMO
Rozpocznij za DARMO
Zarezerwuj darmowe Demo na żywo
Nie wymaga karty kredytowej ani tworzenia konta
