Przejdź do treści stopki
KORZYSTANIE Z IRONXL

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

Eksport z C# DataGridView do Excela z zachowaniem formatowania: Kompletny przewodnik: Obraz 1 – Eksport z C# DataGridView do Excela z zachowaniem formatowania

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
SHELL

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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.

Eksportowanie danych z C# DataGridView do Excela z zachowaniem formatowania: Kompletny przewodnik: Obraz 2 – Interfejs użytkownika formularza

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
$vbLabelText   $csharpLabel

Eksportowanie danych z C# DataGridView do Excela z zachowaniem formatowania: Kompletny przewodnik: Obraz 3 – Wygenerowany plik Excel

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
$vbLabelText   $csharpLabel

Eksportowanie danych z C# DataGridView do Excela z zachowaniem formatowania: Kompletny przewodnik: Ilustracja 4 – Wynik wygenerowanego sformatowanego pliku Excel

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
$vbLabelText   $csharpLabel

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:

IronXL a Microsoft Excel Interop do eksportu DataGridView
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:

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.

Jordi Bardia
Inżynier oprogramowania
Jordi jest najbardziej biegły w Pythonie, C# i C++. Kiedy nie wykorzystuje swoich umiejętności w Iron Software, programuje gry. Dzieląc odpowiedzialność za testowanie produktów, rozwój produktów i badania, Jordi wnosi ogromną wartość do ciągłej poprawy produktów. Różnorodne doświadczenia ...
Czytaj więcej

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie