Jak eksportować DataGridView do Excel w C# z IronXL

Jak skonfigurować projekt Windows Forms do eksportu do programu Excel?

Windows Forms to podstawowa biblioteka GUI w ekosystemie .NET, szeroko stosowana do tworzenia aplikacji desktopowych. Kontrolka DataGridView jest jednym z najczęściej używanych komponentów: wyświetla, edytuje i zarządza danymi tabelarycznymi z dowolnego źródła, które można powiązać, takiego jak DataTable, wynik zapytania do bazy danych lub lista w pamięci.

Eksportowanie tych danych siatki do programu Excel służy kilku codziennym potrzebom — wysyłaniu raportów do interesariuszy, archiwizowaniu migawek na potrzeby audytu lub przekazywaniu danych do dalszych narzędzi analitycznych. Dwa tradycyjne podejścia to Microsoft Office Interop oraz biblioteki innych producentów. Interop wymaga zainstalowania programu Excel na każdym komputerze, na którym działa aplikacja, co powoduje problemy z cyklem życia obiektów COM i słabą wydajność w środowiskach serwerowych lub chmurowych. Biblioteki takie jak IronXL, ClosedXML i Syncfusion unikają tych problemów, zapisując dane bezpośrednio w formacie plików Open XML bez żadnej zależności od pakietu Office.

W niniejszym przewodniku przedstawiono podejście IronXL w języku C# przeznaczonym dla platformy .NET 10, chociaż IronXL obsługuje platformę .NET Framework 4.6.2 oraz wszystkie nowoczesne wersje Wersji .NET.

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Jak wypełnić DataGridView przykładowymi danymi?

W tym przewodniku formularz zawiera DataGridView o nazwie DataGridView1 oraz przycisk o nazwie btnExport. Tabela jest wypełniana w zdarzeniu Load formularza danymi pracowników przechowywanymi w DataTable:

void Form1_Load(object sender, EventArgs e)
{
    var dt = new DataTable();

    // Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", typeof(int));
    dt.Columns.Add("Name", typeof(string));
    dt.Columns.Add("Department", typeof(string));
    dt.Columns.Add("Salary", typeof(decimal));

    // Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

void Form1_Load(object sender, EventArgs e)
{
    var dt = new DataTable();

    // Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", typeof(int));
    dt.Columns.Add("Name", typeof(string));
    dt.Columns.Add("Department", typeof(string));
    dt.Columns.Add("Salary", typeof(decimal));

    // Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

Option Strict On



Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    Dim dt As New DataTable()

    ' Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", GetType(Integer))
    dt.Columns.Add("Name", GetType(String))
    dt.Columns.Add("Department", GetType(String))
    dt.Columns.Add("Salary", GetType(Decimal))

    ' Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000D)
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000D)
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000D)
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000D)

    DataGridView1.DataSource = dt
End Sub

Każda kolumna jest zdefiniowana za pomocą konkretnego typu .NET, aby porównania liczbowe i formatowanie działały poprawnie w dalszej części. Właściwość DataSource wiąże DataTable bezpośrednio z DataGridView, a siatka automatycznie renderuje wszystkie wiersze po otwarciu formularza. W środowisku produkcyjnym dane te zazwyczaj pochodzą z zapytania do bazy danych, zestawu wyników ORM lub odpowiedzi REST API, a nie z wartości zakodowanych na stałe.

Jak wyeksportować dane z DataGridView do pliku Excel z nagłówkami kolumn?

Logika eksportu znajduje się w procedurze obsługi kliknięcia przycisku. Kod tworzy nowy WorkBook, pobiera domyślny arkusz, zapisuje nagłówki kolumn w pierwszym wierszu, a następnie zapisuje każdy wiersz danych pod nimi:

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers to row index 0
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers to row index 0
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

Private Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers to row index 0
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    ' Write data rows starting at row index 1
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cellValue.ToString())
            End If
        Next
    Next

    Dim outputPath As String = "EmployeeData.xlsx"
    workbook.SaveAs(outputPath)
    MessageBox.Show("Export complete. File saved to: " & outputPath, "Success")
End Sub

Obiekt WorkBook reprezentuje cały plik Excel w pamięci. DefaultWorkSheet zwraca pierwszy arkusz bez konieczności jego wyraźnego tworzenia. Pętla zewnętrzna zapisuje tekst nagłówka z HeaderText w wierszu zerowym. Następnie zagnieżdżona pętla iteruje każdy wiersz danych, sprawdzając, czy nie zawiera wartości null, przed konwersją wartości komórki na ciąg znaków. Przesunięcie row + 1 powoduje przesunięcie danych poniżej wiersza nagłówkowego. SaveAs zapisuje gotowy skoroszyt jako plik Open XML XLSX w określonej ścieżce.

Plik wynikowy otwiera się w programie Excel, Arkuszach Google lub dowolnej aplikacji obsługującej format XLSX. Nagłówki kolumn pojawiają się w pierwszym wierszu, a wszystkie wiersze danych następują w tej samej kolejności, w jakiej pojawiły się w DataGridView.

Jak zastosować formatowanie komórek w wyeksportowanym pliku Excel?

Zwykły zrzut danych jest funkcjonalny, ale nie nadaje się do prezentacji. API stylizacji IronXL pozwala zastosować pogrubione czcionki, kolory tła, kolory tekstu i formaty liczb do dowolnego zakresu komórek przed zapisaniem:

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    // Write column headers
    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

Option Strict On



Sub ExportWithFormatting()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    ' Style the header row: bold white text on blue background
    Dim headerRange = sheet.GetRange("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.SetBackgroundColor("#4472C4")
    headerRange.Style.Font.SetColor("#FFFFFF")

    ' Locate the Salary column index
    Dim salaryColIndex As Integer = -1
    For i As Integer = 0 To DataGridView1.Columns.Count - 1
        If String.Equals(DataGridView1.Columns(i).HeaderText, "Salary", StringComparison.OrdinalIgnoreCase) Then
            salaryColIndex = i
            Exit For
        End If
    Next

    ' Write data rows, preserving numeric types
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue Is Nothing Then Continue For

            Dim targetRow As Integer = row + 1

            If col = salaryColIndex Then
                ' Write salary as a true numeric decimal
                Dim decValue As Decimal
                If Decimal.TryParse(cellValue.ToString(), Globalization.NumberStyles.Number, Globalization.CultureInfo.InvariantCulture, decValue) Then
                    sheet.SetCellValue(targetRow, col, decValue)
                Else
                    sheet.SetCellValue(targetRow, col, cellValue.ToString())
                End If
            Else
                sheet.SetCellValue(targetRow, col, cellValue.ToString())
            End If
        Next
    Next

    ' Apply currency format to the salary column data range
    Dim salaryRange = sheet.GetRange("D2:D5")
    salaryRange.FormatString = "$#,##0"

    workbook.SaveAs("FormattedEmployeeData.xlsx")
End Sub

Metoda GetRange akceptuje standardową notację programu Excel (A1:D1) w celu zaznaczenia ciągłego bloku komórek. Ustawienie Style.Font.Bold, Style.SetBackgroundColor i Style.Font.SetColor powoduje zastosowanie tych formatów do każdej komórki w zaznaczonym zakresie. W przypadku kolumn numerycznych zapisanie wartości jako decimal zamiast ciągu znaków pozwala zachować typ danych, co oznacza, że program Excel może poprawnie zastosować formatowanie liczb, takie jak $#,##0. Komórki przechowywane jako ciągi znaków nie reagują na kody formatowania liczbowego.

Możesz rozszerzyć ten wzorzec, aby zastosować naprzemienne cieniowanie wierszy, automatyczne dopasowanie szerokości kolumn lub zamrożenie okienek, zapoznając się z dokumentacją dotyczącą stylów IronXL.

Jak wyeksportować dane z DataGridView do pliku CSV zamiast XLSX?

Niektóre procesy wymagają danych wyjściowych w formacie CSV w celu zapewnienia kompatybilności ze starszymi systemami lub lekkimi potokami danych. IronXL obsługuje eksport do formatu CSV bez konieczności wprowadzania dodatkowych zmian w głównym kodzie:

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

Sub ExportToCsv()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cell As Object = DataGridView1.Rows(row).Cells(col).Value
            If cell IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cell.ToString())
            End If
        Next
    Next

    ' Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv")
End Sub

Jedyną zmianą w stosunku do eksportu XLSX jest rozszerzenie pliku przekazane do SaveAs. IronXL wykrywa rozszerzenie i automatycznie serializuje skoroszyt w odpowiednim formacie. Ta spójność oznacza, że logika zapisu danych pozostaje identyczna niezależnie od formatu wyjściowego — co stanowi znaczną przewagę nad bibliotekami wymagającymi oddzielnych ścieżek kodu dla każdego formatu.

Eksport do formatu CSV jest szczególnie przydatny, gdy odbiorcą końcowym jest skrypt Python pandas, narzędzie do zbiorczego importu danych z bazy danych lub platforma analityczna, która nie obsługuje plików XLSX w formacie binarnym.

Jak efektywnie radzić sobie z dużymi zbiorami danych w DataGridView?

W przypadku tabel zawierających dziesiątki tysięcy wierszy należy wziąć pod uwagę wydajność. Poniższy wzorzec zmniejsza obciążenie pamięci poprzez skonstruowanie pełnego zestawu danych w jednym przebiegu:

Gdy DataGridView jest powiązany z DataTable, można załadować tabelę bezpośrednio do IronXL za pomocą metody WorkSheet.LoadDataTable, całkowicie pomijając iterację komórka po komórce. To podejście jest szybsze i automatycznie zachowuje wszystkie typy kolumn.

W przypadku tabel nieobsługujących DataTable standardowym podejściem pozostaje wzór komórka po komórce przedstawiony wcześniej. Jeśli chcesz eksportować asynchronicznie, aby interfejs użytkownika pozostawał responsywny podczas dużych eksportów, zawiń logikę eksportu w wywołanie Task.Run i await wynik w wątku w tle. W dokumentacji dotyczącej asynchronicznych operacji na plikach można znaleźć wzorce dotyczące przesyłania wyników z powrotem do wątku interfejsu użytkownika.

Dłączego IronXL jest lepszy niż Office Interop do eksportu DataGridView?

Tradycyjne rozwiązania .NET wykorzystywały Microsoft.Office.Interop.Excel do sterowania uruchomionym procesem programu Excel. Takie podejście powoduje kilka problemów związanych z wdrażaniem i niezawodnością:

• Każdy komputer, na którym działa aplikacja, musi mieć zainstalowaną licencjonowaną kopię programu Microsoft Excel
• Środowiska serwerowe i kontenery w chmurze zazwyczaj nie pozwalają na instalację pakietu Office
• COM Interop wymaga jawnego zwolnienia każdego obiektu, aby uniknąć wycieków pamięci i procesów Excel typu zombie
• Obsługa błędów w środowisku COM jest rozbudowana i niestabilna
• Wydajność szybko spada wraz ze wzrostem liczby wierszy

IronXL zapisuje dane bezpośrednio w formacie pliku OOXML bez uruchamiania żadnego zewnętrznego procesu. Aplikacje są wdrażane jako samodzielne jednostki. API biblioteki jest w pełni zarządzane przez .NET, więc garbage collection automatycznie zarządza pamięcią bez wywołań Marshal.ReleaseComObject. Szybkość jest znacznie wyższa, ponieważ nie dochodzi do komunikacji międzyprocesówej.

Dla zespołów rozważających alternatywne rozwiązania popularną opcją open source jest ClosedXML. IronXL oferuje szerszy zestaw funkcji, w tym konwersję plików PDF, generowanie wykresów oraz wsparcie techniczne, co może mieć wpływ na decyzje zakupowe przedsiębiorstw. Zapoznaj się z opcjami licencyjnymi IronXL, aby dobrać odpowiedni poziom do wielkości zespołu i scenariusza wdrożenia.

Sekcja samouczków IronXL obejmuje odczytywanie istniejących plików Excel, modyfikowanie szablonów, generowanie wykresów oraz stosowanie formatowania warunkówego — wszystkie te możliwości wynikają naturalnie z przedstawionego tutaj wzorca eksportu DataGridView.

Jakie są Twoje kolejne kroki?

Masz teraz działający kod C# do eksportowania DataGridView do sformatowanego pliku Excel przy użyciu IronXL. W tym miejscu należy wziąć pod uwagę następujące wskazówki:

• Dodaj obsługę błędów: Umieść kod eksportu w bloku try/catch i wyświetl przyjazny dla użytkownika komunikat, jeśli plik jest zablokowany lub ścieżka jest nieprawidłowa
• Obsługa wyboru ścieżki pliku: Użyj SaveFileDialog, aby umożliwić użytkownikom wybór lokalizacji wyjściowej i nazwy pliku w czasie wykonywania
• Załaduj rzeczywiste dane: Zastąp przykładowy fragment DataTable zapytaniem do bazy danych przy użyciu ADO.NET Framework lub Entity Framework
• Odczytuj istniejące pliki: Użyj metody WorkBook.Load, aby otworzyć istniejący arkusz kalkulacyjny i zaktualizować go, zamiast zawsze tworzyć nowy
• Eksport do wielu arkuszy: Utwórz dodatkowe obiekty WorkSheet w tym samym WorkBook, aby uporządkować powiązane zbiory danych
• Zastosuj formatowanie warunkówe: Podświetl komórki, które przekraczają progi, korzystając z API formatowania warunkówego IronXL
• Zapoznaj się z opcjami licencyjnymi: dostępna jest bezpłatna wersja próbna; Poziomy licencji obejmują zarówno indywidualnych programistów, jak i wdrożenia Enterprise
• Przejrzyj pełną dokumentację API: Dokumentacja obiektów IronXL opisuje każdą dostępną klasę i metodę