C# Eksport DataGridView do Excel: Kompletny przewodnik z formatowaniem | IronXL

Eksportowanie danych DataGridView do pliku Excel jest jednym z najczęstszych zadań w tworzeniu aplikacji Windows Forms. Podczas tworzenia aplikacji biznesowych wyświetlających dane tabelaryczne — czy to raporty sprzedaży, zapisy magazynowe, czy listy klientów — użytkownicy oczekują, że po kliknięciu przycisku otrzymają poprawnie sformatowany plik Excel, który będą mogli udostępnić lub poddać dalszej analizie. Wyzwaniem jest zrobienie tego w sposób przejrzysty, bez konieczności instalowania programu Microsoft Excel na każdym komputerze użytkownika końcowego i bez zmagania się z kodem czyszczącym interoperacyjność COM, który powoduje wycieki pamięci lub ulega cichym awariom. Ten przewodnik przeprowadzi Cię przez cały proces eksportowania DataGridView do Excela w języku C# przy użyciu IronXL, obejmując wszystko od konfiguracji projektu po zaawansowane formatowanie komórek, dzięki czemu otrzymasz kod gotowy do użycia w środowisku produkcyjnym.
!{--01001100010010010100001001010010010000010101001001011001010111110100011101000101010101000101111101010011010101000100000101010010010101000100010101000100010111110101011101001001010100010010000101111101010000010100100100111101000100010101010100001101010100010111110101010001010010010010010100000101001100010111110100001001001100010011110100001101001011--}
Jak skonfigurować projekt Windows Forms do eksportu do DataGridView?
Tradycyjne podejścia do eksportowania danych DataGridView opierały się na Microsoft Interop — należało otworzyć okno "Dodaj odwołanie", przejść do zakładki COM, wybrać bibliotekę obiektów Microsoft Excel i napisać niestabilny kod wywołujący Marshal.ReleaseComObject, aby uniknąć wycieków pamięci. Ten wzorzec wymaga zainstalowania programu Microsoft Excel na każdym komputerze, na którym działa aplikacja, działa wolno w przypadku dużych zbiorów danych i często generuje błędy COMException w środowiskach wdrożeniowych, w których brakuje licencji pakietu Office. Własne wytyczne firmy Microsoft dotyczące automatyzacji biurowej wyraźnie zalecają korzystanie z bibliotek innych firm w scenariuszach po stronie serwera i scenariuszach zautomatyzowanych.
IronXL eliminuje wszystkie te zależności. Jest to biblioteka czysto .NET, która odczytuje i zapisuje pliki .xlsx, .xls, .csv oraz .ods bez konieczności korzystania z pakietu Microsoft Office ani rejestracji COM. Instalujesz go za pomocą NuGet i od razu możesz zacząć pisać kod.
Instalacja IronXL za pośrednictwem NuGet
Zacznij od utworzenia nowego projektu aplikacji Windows Forms w Visual Studio, przeznaczonego dla platformy .NET 10. Dodaj kontrolkę DataGridView oraz Button do obszaru formularza. Nazwij przycisk btnExport i nadaj mu etykietę "Eksportuj do Excela". Następnie otwórz konsolę NuGet Package Manager Console i uruchom:
Install-Package IronXl.Excel
Install-Package IronXl.Excel
Dodaj wymagańe przestrzenie nazw na początku pliku formularza:
using IronXL;
using System.Data;
using IronXL;
using System.Data;
Imports IronXL
Imports System.Data
Te dwie przestrzenie nazw obejmują wszystkie typy IronXL potrzebne do odczytu i zapisu skoroszytów Excel oraz standardowe typy System.Data do pracy z obiektami DataTable, które łączą DataGridView z potokiem eksportu.
Jak załadować przykładowe dane do kontrolki DataGridView?
Przed stworzeniem logiki eksportu należy wypełnić DataGridView reprezentatywnymi danymi. Zdarzenie Form1_Load jest właściwym miejscem do powiązania DataTable jako źródła danych. W rzeczywistej aplikacji wysyłałbyś zapytanie do bazy danych lub wywołał usługę; tutaj na stałe zakodowany DataTable jasno ilustruje strukturę. Przegląd kontrolki DataGridView w Microsoft Docs zawiera dodatkowe informacje na temat sposobu zarządzania źródłami danych przez tę kontrolkę.
Powiązanie tabeli danych (DataTable) z widokiem siatki danych (DataGridView)
void Form1_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add("ProductID", typeof(int));
dt.Columns.Add("ProductName", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));
dt.Rows.Add(1, "Laptop", 999.99m, 50);
dt.Rows.Add(2, "Mouse", 29.99m, 200);
dt.Rows.Add(3, "Keyboard", 79.99m, 150);
dt.Rows.Add(4, "Monitor", 349.99m, 75);
dt.Rows.Add(5, "Webcam", 89.99m, 120);
dataGridView1.DataSource = dt;
}
void Form1_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add("ProductID", typeof(int));
dt.Columns.Add("ProductName", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));
dt.Rows.Add(1, "Laptop", 999.99m, 50);
dt.Rows.Add(2, "Mouse", 29.99m, 200);
dt.Rows.Add(3, "Keyboard", 79.99m, 150);
dt.Rows.Add(4, "Monitor", 349.99m, 75);
dt.Rows.Add(5, "Webcam", 89.99m, 120);
dataGridView1.DataSource = dt;
}
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Dim dt As New DataTable()
dt.Columns.Add("ProductID", GetType(Integer))
dt.Columns.Add("ProductName", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("Stock", GetType(Integer))
dt.Rows.Add(1, "Laptop", 999.99D, 50)
dt.Rows.Add(2, "Mouse", 29.99D, 200)
dt.Rows.Add(3, "Keyboard", 79.99D, 150)
dt.Rows.Add(4, "Monitor", 349.99D, 75)
dt.Rows.Add(5, "Webcam", 89.99D, 120)
dataGridView1.DataSource = dt
End Sub
W tym kodzie zastosowano styl instrukcji najwyższego poziomu dla sygnatury procedury obsługi zdarzenia. DataTable ma cztery kolumny typu — liczbę całkowitą, ciąg znaków, liczbę dziesiętną i liczbę całkowitą — które IronXL zachowa podczas zapisywania w skoroszycie programu Excel. Typ kolumn ma znaczenie, ponieważ IronXL zapisuje kolumny numeryczne jako komórki numeryczne, a nie tekstowe, co pozwala użytkownikom sortować i sumować wartości w Excelu bez konieczności zmiany formatowania.

DataGridView automatycznie renderuje wiersz nagłówka kolumny na podstawie nazw kolumn DataTable. Podczas eksportu chcesz, aby ten wiersz nagłówkowy został zachowany w pliku Excel, co oznacza, że kod eksportu musi traktować nagłówki oddzielnie od wierszy danych — następna sekcja dotyczy właśnie tego.
W przypadku zastosowań produkcyjnych ten sam wzorzec ma zastosowanie niezależnie od tego, czy DataTable pochodzi z Entity Framework, Dapper, ADO.NET czy jakiejkolwiek innej warstwy dostępu do danych. Powiązanie DataGridView jest oddzielone od kodu eksportu, dzięki czemu można zamienić źródło danych bez ingerencji w logikę eksportu.
Jak wyeksportować dane z DataGridView do pliku Excel?
Główna logika eksportu działa w ramach procedury obsługi kliknięcia przycisku. IronXL udostępnia metodę LoadFromDataTable w WorkSheet, która automatycznie obsługuje mapowanie kolumn do komórek. Najczystszym podejściem jest wyodrębnienie DataTable z DataGridView i przekazanie go bezpośrednio. Open XML SDK, który stanowi podstawę formatu .xlsx, jest udokumentówany przez firmę Microsoft i potwierdza, dłączego czyste rozwiązania .NET, takie jak IronXL, przewyższają Interop pod względem generowania programowego.
Obsługa eksportu po kliknięciu przycisku
void btnExport_Click(object sender, EventArgs e)
{
try
{
DataTable dt = new DataTable();
foreach (DataGridViewColumn column in dataGridView1.Columns)
dt.Columns.Add(column.HeaderText);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
DataRow dataRow = dt.NewRow();
for (int i = 0; i < dataGridView1.Columns.Count; i++)
dataRow[i] = row.Cells[i].Value ?? DBNull.Value;
dt.Rows.Add(dataRow);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Product Data";
worksheet.LoadFromDataTable(dt, true);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show($"Exported successfully to:\n{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void btnExport_Click(object sender, EventArgs e)
{
try
{
DataTable dt = new DataTable();
foreach (DataGridViewColumn column in dataGridView1.Columns)
dt.Columns.Add(column.HeaderText);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
DataRow dataRow = dt.NewRow();
for (int i = 0; i < dataGridView1.Columns.Count; i++)
dataRow[i] = row.Cells[i].Value ?? DBNull.Value;
dt.Rows.Add(dataRow);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Product Data";
worksheet.LoadFromDataTable(dt, true);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show($"Exported successfully to:\n{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms
Public Sub btnExport_Click(sender As Object, e As EventArgs)
Try
Dim dt As New DataTable()
For Each column As DataGridViewColumn In dataGridView1.Columns
dt.Columns.Add(column.HeaderText)
Next
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
Dim dataRow As DataRow = dt.NewRow()
For i As Integer = 0 To dataGridView1.Columns.Count - 1
dataRow(i) = If(row.Cells(i).Value, DBNull.Value)
Next
dt.Rows.Add(dataRow)
Next
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Product Data"
worksheet.LoadFromDataTable(dt, True)
Dim outputPath As String = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
)
workbook.SaveAs(outputPath)
MessageBox.Show($"Exported successfully to:{Environment.NewLine}{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information)
Catch ex As Exception
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
End Sub

Wywołanie LoadFromDataTable(dt, true) przyjmuje DataTable oraz flagę logiczną, która nakazuje IronXL zapisanie nazw kolumn jako pierwszego wiersza w Excelu — stają się one komórkami nagłówka. Zeszyt jest zapisywany na pulpicie użytkownika przy użyciu Environment.SpecialFolder.Desktop zamiast stałej ścieżki, co sprawia, że kod jest przenośny między kontami użytkowników.
Sprawdź null (?? DBNull.Value) prevents a NullReferenceException, gdy komórka nie zawiera żadnej wartości. Jest to ważne w przypadku danych rzeczywistych, gdzie pola opcjonalne mogą być puste. IronXL zapisuje DBNull jako pustą komórkę zamiast ciągu znaków "DBNull", dzięki czemu wynik pozostaje przejrzysty.
Aby uzyskać więcej informacji na temat odczytywania danych z plików Excel do DataGridView, zapoznaj się z dokumentacją IronXL DataTable, która opisuje operację odwrotną oraz sposób konwersji plików Excel do DataSet w przypadku skoroszytów zawierających wiele arkuszy.
Jak zastosować profesjonalne formatowanie w wyeksportowanym pliku Excel?
Zwykłe dane w pliku Excel są funkcjonalne, ale profesjonalnie sformatowany wynik — pogrubione nagłówki, szerokość kolumn dopasowana do treści, naprzemienne kolory tła wierszy — stanowi różnicę między narzędziem, któremu użytkownicy ufają, a takim, które eksportują i natychmiast ręcznie formatują. IronXL udostępnia bogaty interfejs API do stylizacji komórek, obejmujący czcionki, kolory, obramowania, formaty liczb i wyrównanie. Specyfikacja OOXML dotycząca stylów arkuszy kalkulacyjnych definiuje format bazowy, w którym zapisuje pliki IronXL, co daje pewność, że pliki wyjściowe otworzą się poprawnie w każdej zgodnej aplikacji.
Stosowanie stylów nagłówków i naprzemiennych kolorów wierszy
void ExportWithFormatting(object sender, EventArgs e)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Formatted Export";
string[] headers = { "ID", "Product Name", "Price", "Stock" };
// Write and style header row
for (int col = 0; col < headers.Length; col++)
{
char colLetter = (char)('A' + col);
string cellAddress = $"{colLetter}1";
worksheet.SetCellValue(0, col, headers[col]);
worksheet[cellAddress].Style.Font.Bold = true;
worksheet[cellAddress].Style.Font.Height = 12;
worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
worksheet[cellAddress].Style.Font.Color = "#FFFFFF";
worksheet[cellAddress].Style.HorizontalAlignment =
IronXl.Styles.HorizontalAlignment.Center;
}
// Write data rows with alternating background colors
int rowIndex = 1;
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
worksheet.SetCellValue(rowIndex, col,
row.Cells[col].Value?.ToString() ?? string.Empty);
}
if (rowIndex % 2 == 0)
{
string rangeAddress = $"A{rowIndex + 1}:D{rowIndex + 1}";
worksheet[rangeAddress].Style.SetBackgroundColor("#D6DCE5");
}
rowIndex++;
}
// Format the Price column as currency
worksheet["C2:C100"].Style.Format = "$#,##0.00";
// Auto-fit column widths
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
worksheet.AutoSizeColumn(3);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"FormattedExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show("Formatted export complete.", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
void ExportWithFormatting(object sender, EventArgs e)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Formatted Export";
string[] headers = { "ID", "Product Name", "Price", "Stock" };
// Write and style header row
for (int col = 0; col < headers.Length; col++)
{
char colLetter = (char)('A' + col);
string cellAddress = $"{colLetter}1";
worksheet.SetCellValue(0, col, headers[col]);
worksheet[cellAddress].Style.Font.Bold = true;
worksheet[cellAddress].Style.Font.Height = 12;
worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
worksheet[cellAddress].Style.Font.Color = "#FFFFFF";
worksheet[cellAddress].Style.HorizontalAlignment =
IronXl.Styles.HorizontalAlignment.Center;
}
// Write data rows with alternating background colors
int rowIndex = 1;
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
worksheet.SetCellValue(rowIndex, col,
row.Cells[col].Value?.ToString() ?? string.Empty);
}
if (rowIndex % 2 == 0)
{
string rangeAddress = $"A{rowIndex + 1}:D{rowIndex + 1}";
worksheet[rangeAddress].Style.SetBackgroundColor("#D6DCE5");
}
rowIndex++;
}
// Format the Price column as currency
worksheet["C2:C100"].Style.Format = "$#,##0.00";
// Auto-fit column widths
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
worksheet.AutoSizeColumn(3);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"FormattedExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show("Formatted export complete.", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
Imports System
Imports System.IO
Imports System.Windows.Forms
Imports IronXL
Sub ExportWithFormatting(sender As Object, e As EventArgs)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Formatted Export"
Dim headers As String() = {"ID", "Product Name", "Price", "Stock"}
' Write and style header row
For col As Integer = 0 To headers.Length - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
Dim cellAddress As String = $"{colLetter}1"
worksheet.SetCellValue(0, col, headers(col))
worksheet(cellAddress).Style.Font.Bold = True
worksheet(cellAddress).Style.Font.Height = 12
worksheet(cellAddress).Style.SetBackgroundColor("#4472C4")
worksheet(cellAddress).Style.Font.Color = "#FFFFFF"
worksheet(cellAddress).Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
Next
' Write data rows with alternating background colors
Dim rowIndex As Integer = 1
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
For col As Integer = 0 To dataGridView1.Columns.Count - 1
worksheet.SetCellValue(rowIndex, col, If(row.Cells(col).Value?.ToString(), String.Empty))
Next
If rowIndex Mod 2 = 0 Then
Dim rangeAddress As String = $"A{rowIndex + 1}:D{rowIndex + 1}"
worksheet(rangeAddress).Style.SetBackgroundColor("#D6DCE5")
End If
rowIndex += 1
Next
' Format the Price column as currency
worksheet("C2:C100").Style.Format = "$#,##0.00"
' Auto-fit column widths
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)
worksheet.AutoSizeColumn(3)
Dim outputPath As String = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "FormattedExport.xlsx")
workbook.SaveAs(outputPath)
MessageBox.Show("Formatted export complete.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information)
End Sub

Kod formatowania wykorzystuje kilka technik. Wiersz nagłówka ma niebieskie tło (#4472C4) z białym tekstem, pogrubioną czcionką o rozmiarze 12 punktów i wyrównaniem do środka — standardowy styl arkusza kalkulacyjnego. Wersy danych przeplatają się między białym a jasnoszarym (#D6DCE5) co drugi wers, co ułatwia użytkownikom czytanie szerokich tabel bez gubienia się w tekście. W kolumnie "Cena" użyto wbudowanego formatu walutowego programu Excel ($#,##0.00), dzięki czemu wartości są wyświetlane w arkuszu kalkulacyjnym ze znakiem dolara i dwoma miejscami po przecinku, bez zmiany podstawowych danych liczbowych. AutoSizeColumn dopasowuje każdą kolumnę do jej najdłuższej wartości, dzięki czemu żadna treść nie jest ucięta.
Możesz rozszerzyć ten wzorzec o stylizację obramowań komórek, formatowanie warunkówe i reguły walidacji danych. W przypadku raportów, które muszą być zgodne z szablonem firmowym, można również ustawić układ strony i obszar drukowania, tak aby wyeksportowany plik był gotowy do druku bez konieczności dostosowywania.
Jak radzisz sobie z dużymi zbiorami danych i optymalizacją wydajności?
Gdy DataGridView jest powiązany z tysiącami wierszy, iteracja komórka po komórce staje się zauważalnie powolna. Dwie optymalizacje znacznie poprawiają wydajność. Po pierwsze, należy używać LoadFromDataTable zamiast wywołań SetCellValue w poszczególnych komórkach. Po drugie, jeśli źródłem danych jest DataTable, należy przekazać je bezpośrednio do IronXL zamiast wyodrębniać wartości z wierszy DataGridView:
void ExportLargeDataset(DataTable sourceTable)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, true);
// Apply header styling after load
int colCount = sourceTable.Columns.Count;
for (int col = 0; col < colCount; col++)
{
char colLetter = (char)('A' + col);
worksheet[$"{colLetter}1"].Style.Font.Bold = true;
worksheet[$"{colLetter}1"].Style.SetBackgroundColor("#4472C4");
worksheet[$"{colLetter}1"].Style.Font.Color = "#FFFFFF";
}
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
));
}
void ExportLargeDataset(DataTable sourceTable)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, true);
// Apply header styling after load
int colCount = sourceTable.Columns.Count;
for (int col = 0; col < colCount; col++)
{
char colLetter = (char)('A' + col);
worksheet[$"{colLetter}1"].Style.Font.Bold = true;
worksheet[$"{colLetter}1"].Style.SetBackgroundColor("#4472C4");
worksheet[$"{colLetter}1"].Style.Font.Color = "#FFFFFF";
}
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
));
}
Option Strict On
Sub ExportLargeDataset(sourceTable As DataTable)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, True)
' Apply header styling after load
Dim colCount As Integer = sourceTable.Columns.Count
For col As Integer = 0 To colCount - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
worksheet($"{colLetter}1").Style.Font.Bold = True
worksheet($"{colLetter}1").Style.SetBackgroundColor("#4472C4")
worksheet($"{colLetter}1").Style.Font.Color = "#FFFFFF"
Next
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
))
End Sub
W przypadku zbiorów danych zawierających ponad 10 000 wierszy uruchomienie eksportu w wątku w tle pozwala zachować responsywność interfejsu użytkownika. Należy zawrzeć logikę eksportu w Task.Run i przekazać wywołanie zwrotne MessageBox.Show do wątku interfejsu użytkownika za pomocą Invoke. IronXL jest bezpieczny dla wątków w przypadku operacji zapisu na oddzielnych instancjach WorkBook, dzięki czemu w razie potrzeby można uruchamiać wiele eksportów jednocześnie.
Dodatkowe zasoby dotyczące wydajności:
Jak wypada IronXL w porównaniu z Microsoft Interop w zakresie eksportu DataGridView?
Wielu programistów zaczyna od Microsoft Excel Interop, ponieważ jest on dostarczany wraz z pakietem Office i nie wymaga żadnych dodatkowych pakietów. Jednak Interop wiąże się z rzeczywistymi kosztami, które szybko ujawniają się w środowiskach produkcyjnych. Poniższa tabela podsumowuje kluczowe różnice:
| Możliwości | IronXL | Microsoft Interop |
|---|---|---|
| Wymagana jest instalacja programu Microsoft Excel | Nie | Tak |
| Działa w środowiskach serwerowych / chmurowych | Tak | Nie (nieobsługiwane przez Microsoft) |
| Konieczne jest wyczyszczenie obiektów COM | Nie | Tak (Marshal.ReleaseComObject) |
| Wydajność przy dużych zbiorach danych | Szybki (czysty .NET) | Powolne (obciążenie związane z marshallingiem COM) |
| Metoda instalacji | NuGet | Odwołanie do COM / Instalacja pakietu Office |
| Obsługiwane wersje .NET | .NET 4.6.2 -- .NET 10 | Tylko .NET Framework (ograniczone) |
| Obsługa formatów XLSX, CSV, ODS | Tak | Pliki XLSX/XLS tylko za pośrednictwem programu Excel |
Własna dokumentacja firmy Microsoft ostrzega przed używaniem Office Interop na serwerach lub w kontach usługowych, powołując się na kwestie stabilności i licencji. IronXL działa poprawnie w usłudze Azure App Service, na hostach usług Windows, w kontenerach Docker oraz w każdym innym środowisku bezinterfejsowym, w którym uruchomienie aplikacji desktopowej, takiej jak Excel, nie jest możliwe.
Dla zespołów już korzystających z Interop, które chcą przeprowadzić migrację, API IronXL jest na tyle zbliżone, że większość operacji WorkBook i WorkSheet można przetłumaczyć bezpośrednio. Przewodnik migracji IronXL obejmuje typowe wzorce Interop i ich odpowiedniki w IronXL.
Jakie są Twoje kolejne kroki?
Eksportowanie danych DataGridView do programu Excel przy użyciu IronXL wymaga jedynie zainstalowania pakietu NuGet i napisania kilku wierszy kodu, zastępując niestabilne podejście oparte na interoperacyjności COM czystym, łatwym w utrzymaniu rozwiązaniem, które działa w każdym środowisku wdrożeniowym. Omówione tutaj techniki — podstawowy eksport, sformatowane dane wyjściowe, optymalizacja dużych zbiorów danych oraz tabela porównawcza — zapewniają wszystko, co jest potrzebne do wdrożenia tej funkcji w produkcyjnej aplikacji Windows Forms.
W tym miejscu zapoznaj się z powiązanymi funkcjami:
- Twórz pliki Excel od podstaw w języku C# — programowo buduj skoroszyty bez źródła danych
- Wczytanie plików Excel do tabeli danych (DataTable) — operacja odwrotna do importowania danych z Excela z powrotem do aplikacji
- Zastosuj formatowanie warunkówe — automatycznie zaznaczaj komórki na podstawie ich wartości
- Ustawianie danych wykresów w Excelu — osadzanie wykresów w eksportowanych skoroszytach
- Zabezpiecz pliki Excel hasłem — zabezpiecz eksportowane raporty przed ich rozpowszechnieniem
- Eksport do formatu CSV — gdy odbiorcy potrzebują formatu pliku płaskiego zamiast
.xlsx
Rozpocznij bezpłatny okres próbny IronXL, aby przetestować pełen zestaw funkcji w swoim projekcie, lub zapoznaj się z opcjami licencyjnymi IronXL, gdy będziesz gotowy do wdrożenia produkcyjnego.
Często Zadawane Pytania
Jak mogę wyeksportować dane z DataGridView do Excela w języku C#?
Zainstaluj IronXL za pomocą NuGet, wyodrębnij tabelę danych (DataTable) z widoku siatki danych (DataGridView), utwórz skoroszyt (WorkBook) i arkusz (WorkSheet), wywołaj metodę worksheet.LoadFromDataTable(dt, true), a następnie zapisz za pomocą workbook.SaveAs.
Jakie opcje formatowania są dostępne podczas eksportowania DataGridView do programu Excel?
IronXL obsługuje pogrubione czcionki, kolory tła, kolory czcionek, wyrównanie poziome, formaty liczb (np. waluty), automatyczne dopasowywanie szerokości kolumn, style obramowań oraz formatowanie warunkowe.
Czy do eksportowania danych z DataGridView muszę mieć zainstalowany program Microsoft Excel?
Nie. Biblioteka IronXL oparta wyłącznie na platformie .NET, która generuje pliki Excel bez konieczności posiadania pakietu Microsoft Office lub rejestracji COM na komputerze.
Czy mogę formatować nagłówki podczas eksportowania DataGridView do Excela?
Tak. Po napisaniu wiersza nagłówka należy uzyskać dostęp do każdej komórki nagłówka według adresu i ustawić właściwości Style.Font.Bold, Style.SetBackgroundColor oraz Style.Font.Color.
Jak zastosować naprzemienne kolory wierszy w programie Excel podczas eksportowania z DataGridView?
Śledź indeks wiersza podczas iteracji wierszy DataGridView, a dla wierszy parzystych zastosuj styl zakresu, używając worksheet[rangeAddress].Style.SetBackgroundColor z wybranym kolorem szesnastkowym.
Jak radzić sobie z dużymi zbiorami danych podczas eksportowania DataGridView do Excela?
Przekaż podstawową tabelę DataTable bezpośrednio do metody worksheet.LoadFromDataTable zamiast iterować komórki pojedynczo. W przypadku bardzo dużych zbiorów uruchom eksport w wątku w tle za pomocą metody Task.Run.
Jak IronXL wypada w porównaniu z Microsoft Excel Interop w zakresie eksportu do DataGridView?
IronXL nie wymaga programu Microsoft Excel, działa w środowiskach serwerowych i chmurowych, nie wymaga kodu czyszczącego COM i działa znacznie szybciej w przypadku dużych zbiorów danych.




