Przejdź do treści stopki
KORZYSTANIE Z IRONXL

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

C# DataGridView Export do Excela z formatowaniem: Kompletna przewodnik: Obraz 1 - C# DataGridView Export do Excela z formatowaniem

Eksportowanie danych DataGridView do pliku Excel jest jednym z najczestszych zadan w Windows Forms development. 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 cie przez kompletny proces eksportowania DataGridView do Excela w C# uzywajac IronXL, obejmujac wszystko od konfiguracji projektu do zaawansowanego formatowania komorek, tak aby koncowy rezultat byl gotowy do produkcji.

Zacznij z IronXL teraz.
green arrow pointer

Jak skonfigurować projekt Windows Forms do eksportu do DataGridView?

Tradycyjne podejscia do eksportowania danych DataGridView opieraly sie na Microsoft Interop -- otwierasz Dodaj Odwolanie, przechodzisz do zakladki COM, wybierasz Microsoft Excel Object Library i piszesz niestabilny kod, który wzywa Marshal.ReleaseComObject, aby uniknac wycieków pamieci. Ten wzorzec wymaga zainstalowanego Microsoft Excel na kazdym komputerze, na którym dziala aplikacja, dziala powoli z duzymi zbiorami danych i czesto generuje bledy COMException w srodowiskach wdrozeniowych, które nie maja licencji 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 czysta biblioteka .NET, która czyta i zapisuje pliki .xlsx, .xls, .csv i .ods, bez Microsoft Office i jakiejkolwiek 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 Windows Forms App w Visual Studio przeznaczonego na .NET 10. Dodaj kontrolke DataGridView oraz Button do powierzchni formularza. Nazwij przycisk btnExport i nadaj mu etykiete "Eksportuj do Excela". Następnie otwórz konsolę NuGet Package Manager Console i uruchom:

Install-Package IronXL.Excel

Dodaj wymagane 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 obejmuja wszystkie typy IronXL potrzebne do odczytu i zapisu skoroszytow Excel, oraz standardowe typy System.Data do pracy z obiektami DataTable, które lacza twoj DataGridView z kanalem eksportu.

Jak załadować przykładowe dane do kontrolki DataGridView?

Przed budowa logiki eksportu, uzupelnij swoj DataGridView dane reprezentatywne. Wydarzenie Form1_Load jest odpowiednim miejscem na powiazanie DataTable jako zrodlo danych. W prawdziwej aplikacji zapytalbys baze danych lub wywolalbys usluge; tutaj zakodowany na sztywno DataTable ilustruje structure jasno. 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 typowane kolumny -- calkowita, lancuch znaków, dziesietna i calkowita -- które IronXL zachowa podczas zapisywania do skoroszytu 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.

C# DataGridView Export do Excela z formatowaniem: Kompletna przewodnik: Obraz 2 - UI dla formularza

DataGridView automatycznie renderuje wiersz naglowków kolumn z 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.

Do uzytku produkcyjnego, ten sam wzorzec stosuje sie niezaleznie od tego, czy DataTable pochodzi z Entity Framework, Dapper, ADO.NET czy dowolnej innej warstwy dostepu do danych. Wiazanie DataGridView jest rozlaczne z kodem eksportu, wiec mozesz zmienic zrodlo danych bez ingerencji w logike eksportu.

Jak wyeksportować dane z DataGridView do pliku Excel?

Główna logika eksportu działa w ramach procedury obsługi kliknięcia przycisku. IronXL zapewnia metode LoadFromDataTable na WorkSheet, która automatycznie obsluguje mapowanie kolumna-komórka. Najczystsze podejscie polega na wyciagnieciu DataTable z DataGridView i przekazaniu go bezposrednio. Open XML SDK, które jest podstawa formatu .xlsx, jest dokumentowane przez Microsoft i potwierdza, dlaczego czyste rozwiazania .NET, takie jak IronXL, przewyzszaja Interop dla programowego generowania.

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

C# DataGridView Export do Excela z formatowaniem: Kompletna przewodnik: Obraz 3 - Wygenerowany plik Excel

Wywolanie LoadFromDataTable(dt, true) wymaga DataTable i flagi logicznej, która informuje IronXL o zapisaniu nazw kolumn jako pierwszy wiersz Excel -- te staja sie twoimi komórkami naglowkowymi. Skoroszyt jest zapisywany na Pulpicie uzytkownika z uzyciem Environment.SpecialFolder.Desktop zamiast zakodowanej na sztywno sciezki, co sprawia, ze ​​kod jest przenosny miedzy kontami uzytkowników.

Sprawdzenie null (?? DBNull.Value) prevents a NullReferenceException gdy komórka nie zawiera zadnej wartosci. Jest to ważne w przypadku danych rzeczywistych, gdzie pola opcjonalne mogą być puste. IronXL zapisuje DBNull jako pusta komórke zamiast napisu "DBNull", dzieki czemu wynik pozostaje czysty.

Aby uzyskac wiecej szczególów na temat odczytu danych z plików Excel do DataGridView, zobacz dokumentacje IronXL DataTable, która obejmuje operacje odwrotna i jak konwertowac Excel na DataSet dla skoroszytów wieloarkuszowych.

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);
}
Option Strict On



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

C# DataGridView Export do Excela z formatowaniem: Kompletna przewodnik: Obraz 4 - Wynik wygenerowanego sformatowanego pliku Excel

Kod formatowania wykorzystuje kilka technik. Naglowek otrzymuje niebieskie tlo (#4472C4) z bialym tekstem, czcionka pogrubiona o 12 punktów i wycentrowanym wyrównaniem -- standardowy styl arkuszów kalkulacyjnych dla firm. Wiersze danych naprzemiennie sa biale i jasnoszare (#D6DCE5) dla co drugiego wiersza, co ulatwia uzytkownikom czytanie szerokich tabel bez tracenia miejsca. Kolumna Cena uzywa wbudowanego formatu walutowego Excela ($#,##0.00), wiec wartosci wyswietlaja sie z symbolami dolara i dwoma miejscami dziesietnymi w arkuszu, bez zmiany podstawowych danych liczbowych. AutoSizeColumn dopasowuje kazda kolumne do jej najdluzszej wartosci, aby zaden zawartosc nie byla ucieta.

Możesz rozszerzyć ten wzorzec dalej za pomocą stylizacji obramowania komórek, warunkowego formatowania, i reguł 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 wiazane z tysiacami wierszy, iteracja komórka po komórce staje sie wyraznie wolna. Dwie optymalizacje znacznie poprawiają wydajność. Najpierw, uzyj LoadFromDataTable zamiast wywolan SetCellValue dla kazdej komórki. Po drugie, jesli twoim zrodlom danych jest DataTable, przekaż to bezposrednio do IronXL zamiast wyciagania wartosci przez wiersze 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

Dla zestawów danych z wiecej niz 10 000 wierszy uruchomienie eksportu na wątku w tle sprawia, ze UI pozostaje responsywne. Owiń logike eksportu w Task.Run i wykonaj wywolanie MessageBox.Show z powrotem do watku UI uzywajac Invoke. IronXL jest bezpieczny dla operacji zapisu na osobnych instancjach WorkBook, wiec mozesz uruchamiac wiele eksportów rownoczesnie, jesli zajdzie taka potrzeba.

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ż korzystajacych z Interopu, którzy chca migrowac, API IronXL mapuje sie wystarczajaco blisko, aby wiekszosc operacji WorkBook i WorkSheet byla przenoszalna bezposrednio. Przewodnik migracji IronXL obejmuje typowe wzorce Interop i ich odpowiedniki w IronXL.

Jakie są Twoje kolejne kroki?

Eksportowanie danych DataGridView do Excela przy uzyciu IronXL wymaga tylko zainstalowania pakietu NuGet i kilku linii kodu, zastepujac kruchy podejscie COM interop czystym, latwym do utrzymania rozwiazaniem, dzialajacym w kazdym srodowisku wdrozeniowym. 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.

Curtis Chau
Autor tekstów technicznych

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ę...

Czytaj więcej

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie