Eksportowanie danych z GridView do Excela z zachowaniem kolorów, czcionek, naprzemiennego tła wierszy i obramowań to wymóg, który pojawia się w niemal każdej aplikacji opartej na danych, napisanej w ASP.NET lub Windows Forms. Tradycyjne podejście -- użycie HtmlTextWriter i StringWriter, aby renderować kontrolkę jako HTML -- tworzy pliki, które zawierają ostrzeżenia o formacie w Excelu i zawodzą cicho dla użytkowników. IronXL rozwiązuje ten problem, generując natywne pliki XLSX całkowicie w języku C#, bez zależności od pakietu Microsoft Office, co zapewnia precyzyjną kontrolę nad stylem każdej komórki.
Przed napisaniem jakiegokolwiek kodu eksportującego zainstaluj IronXL z NuGet. Otwórz konsolę menedżera pakietów i uruchom:
IronXL obsługuje .NET 8, .NET 9 i .NET 10, a także .NET Framework 4.6.2 i nowsze wersje. Po instalacji dodaj następujące dyrektywy using do dowolnego pliku, który wykonuje operacje Excel:
using IronXL;
using IronXL.Styles;Imports IronXL
Imports IronXL.StylesNie jest wymagane żadne dodatkowe środowisko uruchomieniowe ani integracja z pakietem Office. Biblioteka zapisuje natywne pliki binarne XLSX, które otwierają się poprawnie w programach Microsoft Excel, LibreOffice Calc i Google Sheets.
Aplikacje Windows Forms używają kontrolki DataGridView zamiast opartej na sieci GridView. Wzorzec eksportu jest taki sam w obu przypadkach: wyodrębnij wartości z wierszy i komórek, utwórz skoroszyt IronXL, zastosuj style, a następnie zapisz lub strumieniuj wynik.
Najbardziej niezawodne podejście rzutuje właściwość DataSource kontrolki na DataTable, aby uniknąć iteracji wizualnych wierszy, które mogą być filtrowane lub stronicowane:
using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;
using System.Windows.Forms;
DataTable dt = (DataTable)dataGridView1.DataSource;
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;
// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
var cell = sheet.GetCellAt(0, col);
cell.Style.Font.Bold = true;
cell.Style.SetBackgroundColor("#4472C4");
cell.Style.Font.Color = "#FFFFFF";
cell.Style.BottomBorder.Type = BorderType.Thin;
}
// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
sheet.SetCellValue(row + 1, col, value);
var cell = sheet.GetCellAt(row + 1, col);
cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
cell.Style.BottomBorder.Type = BorderType.Thin;
}
}
// Save via dialog
using var saveDialog = new SaveFileDialog
{
Filter = "Excel Files|*.xlsx",
FileName = "GridViewExport.xlsx"
};
if (saveDialog.ShowDialog() == DialogResult.OK)
{
workBook.SaveAs(saveDialog.FileName);
MessageBox.Show("Export successful.", "Export",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms
Dim dt As DataTable = DirectCast(dataGridView1.DataSource, DataTable)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Header row -- bold, blue background, white text
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Dim cell = sheet.GetCellAt(0, col)
cell.Style.Font.Bold = True
cell.Style.SetBackgroundColor("#4472C4")
cell.Style.Font.Color = "#FFFFFF"
cell.Style.BottomBorder.Type = BorderType.Thin
Next
' Data rows -- alternating row color
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
Dim value As String = If(dt.Rows(row)(col)?.ToString(), String.Empty)
sheet.SetCellValue(row + 1, col, value)
Dim cell = sheet.GetCellAt(row + 1, col)
cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#D6DCE5", "#FFFFFF"))
cell.Style.BottomBorder.Type = BorderType.Thin
Next
Next
' Save via dialog
Using saveDialog As New SaveFileDialog With {
.Filter = "Excel Files|*.xlsx",
.FileName = "GridViewExport.xlsx"
}
If saveDialog.ShowDialog() = DialogResult.OK Then
workBook.SaveAs(saveDialog.FileName)
MessageBox.Show("Export successful.", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information)
End If
End UsingWorkBook.Create inicjalizuje nowy skoroszyt w pamięci w formacie XLSX. DefaultWorkSheet zwraca pierwszy arkusz, który można przemianować za pomocą właściwości Name przed zapisaniem. SetCellValue akceptuje ciągi, liczby całkowite, liczby podwójnej precyzji oraz wartości DateTime -- IronXL wybiera automatycznie poprawny typ komórki.
Naprzemienny wzorzec kolorów wierszy -- row % 2 == 0 wybiera #D6DCE5, w przeciwnym razie #FFFFFF -- odzwierciedla styl tabeli z paskami wbudowany w Excel. Możesz zastąpić dowolnym sześcioznakowym kodem koloru hex, który pasuje do systemu projektowego Twojej aplikacji.
Aplikacje internetowe wymagają innego mechanizmu dostarczania. Zamiast zapisywać do systemu plików, serializujesz skoroszyt do MemoryStream i zapisujesz go w odpowiedzi HTTP z poprawnymi nagłówkami, aby przeglądarka traktowała to jako pobieranie pliku.
Ważny krok przedstartowy dla stronicowanych GridView: wyłącz paginację (AllowPaging = false) i ponownie powiąż źródło danych przed eksportem, aby każde rekordy -- nie tylko obecna strona -- zostały uchwycone.
using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;
// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();
DataTable dt = (DataTable)GridView1.DataSource;
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;
// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
var cell = sheet.GetCellAt(0, col);
cell.Style.Font.Bold = true;
cell.Style.SetBackgroundColor("#2E75B6");
cell.Style.Font.Color = "#FFFFFF";
cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
cell.Style.BottomBorder.Type = BorderType.Medium;
}
// Data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
var cell = sheet.GetCellAt(row + 1, col);
cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
cell.Style.BottomBorder.Type = BorderType.Thin;
cell.Style.LeftBorder.Type = BorderType.Thin;
cell.Style.RightBorder.Type = BorderType.Thin;
}
}
// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Web.UI
' Disable paging so all rows are captured
GridView1.AllowPaging = False
GridView1.DataBind()
Dim dt As DataTable = CType(GridView1.DataSource, DataTable)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Header row
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Dim cell = sheet.GetCellAt(0, col)
cell.Style.Font.Bold = True
cell.Style.SetBackgroundColor("#2E75B6")
cell.Style.Font.Color = "#FFFFFF"
cell.Style.HorizontalAlignment = HorizontalAlignment.Center
cell.Style.BottomBorder.Type = BorderType.Medium
Next
' Data rows
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
Dim cell = sheet.GetCellAt(row + 1, col)
cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#DEEAF1", "#FFFFFF"))
cell.Style.BottomBorder.Type = BorderType.Thin
cell.Style.LeftBorder.Type = BorderType.Thin
cell.Style.RightBorder.Type = BorderType.Thin
Next
Next
' Stream to browser
Dim fileBytes As Byte() = workBook.ToByteArray()
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()Response.AddHeader z content-disposition: attachment wymusza dialog pobierania pliku we wszystkich nowoczesnych przeglądarkach. Typ MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet jest zarejestrowanym typem dla plików XLSX i zapobiega próbom przeglądarki wyświetlania treści binarnych w trybie online.
Dla aplikacji ASP.NET Core zastąp Response.BinaryWrite z File(fileBytes, contentType, fileName) w akcji kontrolera -- logika tworzenia skoroszytu jest identyczna.
Formatowanie warunkowe wyróżnia komórki spełniające określone kryteria — na przykład zaznaczając daty przeterminowane na czerwono lub wartości poniżej progu na pomarańczowo. IronXL stosuje formatowanie warunkowe na poziomie komórek podczas tworzenia skoroszytu:
// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;
for (int row = 0; row < dt.Rows.Count; row++)
{
// Highlight past-due dates
if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
{
DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
var dueDateCell = sheet.GetCellAt(row + 1, 3);
if (dueDate < today)
{
dueDateCell.Style.SetBackgroundColor("#FF0000");
dueDateCell.Style.Font.Color = "#FFFFFF";
dueDateCell.Style.Font.Bold = true;
}
}
// Highlight amounts below threshold
if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
{
decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
var amountCell = sheet.GetCellAt(row + 1, 4);
if (amount < 100m)
{
amountCell.Style.SetBackgroundColor("#FFC000");
}
}
}Imports System
' Assume "DueDate" is column index 3 and "Amount" is column index 4
Dim today As DateTime = DateTime.Today
For row As Integer = 0 To dt.Rows.Count - 1
' Highlight past-due dates
If dt.Columns.Contains("DueDate") AndAlso dt.Rows(row)("DueDate") IsNot DBNull.Value Then
Dim dueDate As DateTime = Convert.ToDateTime(dt.Rows(row)("DueDate"))
Dim dueDateCell = sheet.GetCellAt(row + 1, 3)
If dueDate < today Then
dueDateCell.Style.SetBackgroundColor("#FF0000")
dueDateCell.Style.Font.Color = "#FFFFFF"
dueDateCell.Style.Font.Bold = True
End If
End If
' Highlight amounts below threshold
If dt.Columns.Contains("Amount") AndAlso dt.Rows(row)("Amount") IsNot DBNull.Value Then
Dim amount As Decimal = Convert.ToDecimal(dt.Rows(row)("Amount"))
Dim amountCell = sheet.GetCellAt(row + 1, 4)
If amount < 100D Then
amountCell.Style.SetBackgroundColor("#FFC000")
End If
End If
Next rowTen wzorzec jest modułowy — można dodać tyle warunków, ile wymagają Twoje potrzeby w zakresie raportowania. Ponieważ IronXL działa na zasadzie komórkowej, można łączyć formatowanie warunkowe z logiką naprzemiennego koloru wierszy, stosując styl warunkowy po podstawowym stylu wiersza.
Profesjonalnie sformatowany eksport do Excela zawiera odpowiednie szerokości kolumn i zablokowany wiersz nagłówka, dzięki czemu nazwy kolumn pozostają widoczne, gdy użytkownicy przewijają duże zbiory danych.
IronXL ujawnia szerokość kolumn przez akcesor kolumny WorkSheet i zamrażanie nagłówka przez metodę FreezeRows:
// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
// Set column width in character units (1 unit ≈ one default character width)
sheet.SetColumnWidth(col, 20);
}
// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);
// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);' Auto-size columns 0 through the last column index
For col As Integer = 0 To dt.Columns.Count - 1
' Set column width in character units (1 unit ≈ one default character width)
sheet.SetColumnWidth(col, 20)
Next
' Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1)
' Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20)W przypadku zastosowań produkcyjnych warto rozważyć obliczenie szerokości na podstawie maksymalnej liczby znaków w każdej kolumnie zamiast stosowania stałej wartości. Iteruj wartości kolumny DataTable, zmierz długość ciągu i pomnóż przez współczynnik szerokości znaku odpowiedni do wybranego rozmiaru czcionki.
Można również zastosować kolor tła do komórek programu Excel przy użyciu języka C# niezależnie od logiki pasmowania wierszy, co pozwala na bardziej precyzyjne stylizowanie.
Wiele aplikacji .NET zapełnia dane za pośrednictwem wywołań serwisowych lub zapytań do bazy danych i przechowuje je w DataTable bez wiązania ich z kontrolką UI. Można eksportować DataTable bezpośrednio do Excela, nie tworząc wcale GridView.
Jest to najbardziej wydajna ścieżka dla zadań w tle, zaplanowanych raportów i punktów końcowych API, które wymagają generowania plików Excel na serwerze:
using IronXL;
using IronXL.Styles;
using System.Data;
public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.CreateWorkSheet(sheetName);
// Header
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
var cell = sheet.GetCellAt(0, col);
cell.Style.Font.Bold = true;
cell.Style.SetBackgroundColor("#4472C4");
cell.Style.Font.Color = "#FFFFFF";
}
// Data
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
}
}
return workBook.ToByteArray();
}Imports IronXL
Imports IronXL.Styles
Imports System.Data
Public Shared Function DataTableToExcelBytes(dt As DataTable, Optional sheetName As String = "Report") As Byte()
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.CreateWorkSheet(sheetName)
' Header
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Dim cell = sheet.GetCellAt(0, col)
cell.Style.Font.Bold = True
cell.Style.SetBackgroundColor("#4472C4")
cell.Style.Font.Color = "#FFFFFF"
Next
' Data
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
Next
Next
Return workBook.ToByteArray()
End FunctionTa metoda zwraca byte[], który można zapisać na dysku, strumieniować z punktu końcowego API, dołączyć do e-maila lub przechowywać w pamięci. Aby zapoznać się z powiązanymi technikami, zobacz przewodnik dotyczący eksportowania tabeli danych (DataTable) do programu Excel oraz samouczek dotyczący najszybszego sposobu eksportowania tabeli danych (DataTable) do programu Excel.
Eksportowanie dziesiątek tysięcy wierszy do programu Excel wymaga zwrócenia uwagi na alokację pamięci. Tworzenie nowego obiektu typu komórka dla każdej komórki w dużej siatce jest najczęstszym wąskim gardłem wydajności. W miarę możliwości należy ponownie wykorzystywać definicje stylów, ustawiając style na obiektach zakresu zamiast na poszczególnych komórkach:
| Rozmiar zbioru danych | Zalecane podejście | Kluczowe kwestie |
|---|---|---|
| Do 5000 wierszy | Pętla stylizacji komórka po komórce | Prosty kod, znikome obciążenie |
| 5 000 — 50 000 wierszy | Zastosowanie stylu na poziomie zakresu | Znacznie zmniejsza alokację obiektów |
| Ponad 50 000 wierszy | Bezpośredni eksport z DataTable, minimalna stylizacja | Ogranicz operacje na poszczególnych komórkach; jeśli to możliwe, korzystaj ze strumieniowania |
Dla stronicowanych GridView, zawsze ustaw AllowPaging = false i ponownie powiąż przed eksportem. Paginacja ogranicza liczbę widocznych wierszy w kontrolce, więc eksport z paginacją przechwytuje tylko bieżącą stronę, a nie cały zbiór danych — co często jest przyczyną błędów związanych z niekompletnym eksportem.
Można również zapoznać się z przewodnikiem na temat eksportowania listy obiektów do Excela w C#, aby poznać wzorce działające z kolekcjami silnie typowanymi, zamiast nietypowych wierszy DataTable.
Aplikacje ASP.NET Core i Blazor nie mają kontrolki Web Forms GridView, ale podstawowe wyzwanie związane z eksportem danych jest takie samo: pobierz kolekcję obiektów lub DataTable, zbuduj stylowy skoroszyt i dostarcz plik. Kod tworzenia skoroszytu jest identyczny; zmienia się jedynie mechanizm dostarczania.
W aplikacji Blazor uruchom pobieranie pliku za pomocą interoperacyjności JavaScript:
// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;
public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
var cell = sheet.GetCellAt(0, col);
cell.Style.Font.Bold = true;
cell.Style.SetBackgroundColor("#4472C4");
cell.Style.Font.Color = "#FFFFFF";
}
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
}
}
byte[] fileBytes = workBook.ToByteArray();
string base64 = Convert.ToBase64String(fileBytes);
await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}Imports IronXL
Imports System.Data
Imports Microsoft.JSInterop
Public Async Function ExportToExcelAsync(dt As DataTable, js As IJSRuntime) As Task
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Dim cell = sheet.GetCellAt(0, col)
cell.Style.Font.Bold = True
cell.Style.SetBackgroundColor("#4472C4")
cell.Style.Font.Color = "#FFFFFF"
Next
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
Next
Next
Dim fileBytes As Byte() = workBook.ToByteArray()
Dim base64 As String = Convert.ToBase64String(fileBytes)
Await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
End FunctionPełny opis wzorca pobierania w Blazorze znajduje się w samouczku dotyczącym eksportu z Blazora do Excela. Aby zapoznać się z podejściem opartym na kontrolerze ASP.NET Core, zobacz samouczek dotyczący eksportu do programu Excel w ASP.NET Core.
IronXL ujawnia szczegółowe kontrolki czcionek i granic poprzez obiekt Style na każdej komórce. Pełen zakres stylów czcionek programu Excel w języku C# obejmuje pogrubienie, kursywę, podkreślenie, rozmiar i kolor. Typy granic dostępne poprzez BorderType obejmują cienkie, średnie, grube, przerywane, kropkowane, podwójne oraz kilka wariantów z cienkimi liniami.
W przypadku scałanych wierszy nagłówkowych lub podsumowujących stopek IronXL obsługuje również scałanie komórek w programie Excel przy użyciu języka C# — jest to przydatne, gdy chcesz, aby pojedyncza komórka tytułowa obejmowała wiele kolumn nad tabelą danych.
Aby automatycznie dopasować szerokość kolumn po wprowadzeniu danych, zapoznaj się z przewodnikiem dotyczącym automatycznego dopasowywania komórek w programie Excel przy użyciu języka C#, w którym opisano zalecane podejście.
Tradycyjna technika eksportu ASP.NET -- nadpisywanie VerifyRenderingInServerForm, tworzenie StringWriter i HtmlTextWriter oraz zapis kontroli renderowanej do odpowiedzi -- tworzy dokument HTML z rozszerzeniem .xls. Program Microsoft Excel otwiera takie pliki z ostrzeżeniem o kompatybilności, ponieważ plik nie jest w rzeczywistości w formacie binarnym Excel lub OOXML. Style są ograniczone do wbudowanego CSS, który Excel częściowo interpretuje. Formatowanie warunkowe jest niemożliwe. Użytkownicy korzystający z platform innych niż Windows lub z pakietu LibreOffice widzą pogorszoną jakość wyników.
IronXL zapisuje bezpośrednio w formacie Open XML Spreadsheet (OOXML). Rezultatem jest odpowiedni plik .xlsx -- identyczny z tym, co Excel tworzy sam w sobie -- który otwiera się bez ostrzeżeń w Excelu, LibreOffice, Google Sheets i Numbers na macOS. Formatowanie jest zakodowane jako style arkusza kalkulacyjnego, a nie atrybuty HTML, dzięki czemu zachowuje się podczas przesyłania i wyświetlania na różnych platformach.
| Metoda | Format pliku | Ostrzeżenia dotyczące formatowania | Pełna obsługa stylów | Wymagane biuro |
|---|---|---|---|---|
| HtmlTextWriter + StringWriter | HTML udający plik XLS | Tak | Nie | Nie |
| Interop Office (COM) | Natywny XLS/XLSX | Nie | Tak | Tak |
| IronXL | Natywny XLSX/XLS | Nie | Tak | Nie |
Oficjalna dokumentacja Microsoftu dotycząca Open XML SDK wyjaśnia format, na którym opiera się IronXL. Specyfikacja OOXML utrzymywana przez ECMA International definiuje standard gwarantujący kompatybilność między aplikacjami. Dokumentacja kontrolki ASP.NET GridView w serwisie Microsoft Docs opisuje model kontrolki, z którego odczytują dane powyższe wzorce eksportu.
Dysponujesz teraz wzorcami niezbędnymi do eksportowania danych z GridView i DataGridView do poprawnie sformatowanych plików XLSX przy użyciu IronXL — obejmującymi modele dostarczania Windows Forms, ASP.NET Web Forms, ASP.NET Core i Blazor.
Więcej informacji:
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.
