Eksportuj DataGridView do Excel w C# z IronXL

Dłączego eksport do Excela DataGridView jest niezbędny?

DataGridView Kontrolki mają fundamentalne znaczenie dla aplikacji Windows Forms, wyświetlając dane tabelaryczne, z którymi użytkownicy mają do czynienia na co dzień. Eksportowanie tych danych do programu Excel umożliwia użytkownikom korzystanie z zaawansowanych narzędzi analitycznych programu, tworzenie prezentacji oraz udostępnianie danych współpracownikom, którzy mogą nie mieć dostępu do aplikacji. Ta funkcja eksportu do Excela w języku C# ma kluczowe znaczenie dla procesów tworzenia raportów biznesowych i analizy danych.

Tradycyjne metody eksportu wykorzystujące Microsoft.Office.Interop.Excel wymagają zainstalowania programu Excel na każdym komputerze, na którym działa aplikacja. Stwarza to wyzwania związane z wdrażaniem, zwłaszcza w środowiskach serwerowych lub podczas dystrybucji aplikacji wśród użytkowników nieposiadających licencji Office. Ponadto, jeśli nie podejdzie się do tego ostrożnie, podejścia Interop mogą powodować wycieki pamięci i problemy z czyszczeniem obiektów COM. Wyzwania te stają się szczególnie istotne podczas wdrażania na AWS Lambda lub innych platformach bezserwerowych, gdzie instalacja pakietu Office nie jest możliwa.

Niewoczesne aplikacje .NET wymagają bardziej elastycznych rozwiązań. IronXL odpowiada na te wyzwania, oferując samodzielną bibliotekę IronXL, która generuje pliki Excel bez żadnych zależności od pakietu Microsoft Office. Takie podejście zapewnia spójną funkcjonalność w środowiskach programistycznych, testowych i produkcyjnych, jednocześnie wspierając wdrażanie w kontenerach i na platformach chmurowych.

Jak zainstalować IronXL w projekcie C#?

Otwórz konsolę menedżera pakietów w Visual Studio i uruchom następujące polecenie lub użyj interfejsu CLI .NET:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Szczegółowe opcje instalacji można znaleźć w instrukcji instalacji IronXL NuGet lub wyszukując pakiet bezpośrednio na stronie NuGet.org. Po zainstalowaniu dodaj using IronXL; do plików projektu C#, aby uzyskać dostęp do funkcji eksportu do Excela oferowanych przez bibliotekę. Podczas wdrażania w środowiskach produkcyjnych należy zastosować klucz licencyjny, aby włączyć wszystkie funkcje. Przed zakupem można uzyskać bezpłatną licencję próbną, aby przetestować IronXL.

using IronXL;
using System.Data;
using System.Windows.Forms;

// Create a DataTable with sample product data
var dt = new DataTable();
dt.Columns.Add("Product ID", typeof(int));
dt.Columns.Add("Product Name", typeof(string));
dt.Columns.Add("Category", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99m, 15);
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99m, 50);
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99m, 100);
dt.Rows.Add(1004, "Monitor 27\"", "Electronics", 399.99m, 8);
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99m, 25);

// Bind to DataGridView
var dataGridView1 = new DataGridView();
dataGridView1.DataSource = dt;

// Create new Excel workbook
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Export column headers
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.SetCellValue(0, colIndex, dataGridView1.Columns[colIndex].HeaderText);
}

// Export data rows
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            if (cellValue is decimal or double or int)
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue));
            else
                worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue?.ToString() ?? string.Empty);
        }
    }
}

// Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx");
Console.WriteLine("Export completed successfully!");

using IronXL;
using System.Data;
using System.Windows.Forms;

// Create a DataTable with sample product data
var dt = new DataTable();
dt.Columns.Add("Product ID", typeof(int));
dt.Columns.Add("Product Name", typeof(string));
dt.Columns.Add("Category", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99m, 15);
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99m, 50);
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99m, 100);
dt.Rows.Add(1004, "Monitor 27\"", "Electronics", 399.99m, 8);
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99m, 25);

// Bind to DataGridView
var dataGridView1 = new DataGridView();
dataGridView1.DataSource = dt;

// Create new Excel workbook
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Export column headers
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.SetCellValue(0, colIndex, dataGridView1.Columns[colIndex].HeaderText);
}

// Export data rows
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            if (cellValue is decimal or double or int)
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue));
            else
                worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue?.ToString() ?? string.Empty);
        }
    }
}

// Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx");
Console.WriteLine("Export completed successfully!");

Imports IronXL
Imports System.Data
Imports System.Windows.Forms

' Create a DataTable with sample product data
Dim dt As New DataTable()
dt.Columns.Add("Product ID", GetType(Integer))
dt.Columns.Add("Product Name", GetType(String))
dt.Columns.Add("Category", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("Stock", GetType(Integer))

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99D, 15)
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99D, 50)
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99D, 100)
dt.Rows.Add(1004, "Monitor 27""", "Electronics", 399.99D, 8)
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99D, 25)

' Bind to DataGridView
Dim dataGridView1 As New DataGridView()
dataGridView1.DataSource = dt

' Create new Excel workbook
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Export column headers
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    worksheet.SetCellValue(0, colIndex, dataGridView1.Columns(colIndex).HeaderText)
Next

' Export data rows
For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
    If Not dataGridView1.Rows(rowIndex).IsNewRow Then
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
            If TypeOf cellValue Is Decimal OrElse TypeOf cellValue Is Double OrElse TypeOf cellValue Is Integer Then
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue))
            Else
                worksheet.SetCellValue(rowIndex + 1, colIndex, If(cellValue?.ToString(), String.Empty))
            End If
        Next
    End If
Next

' Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx")
Console.WriteLine("Export completed successfully!")

Jak dodać profesjonalne formatowanie do eksportów do programu Excel?

Profesjonalne eksporty do programu Excel często wymagają formatowania w celu poprawy czytelności. IronXL oferuje funkcje stylizacji, w tym dostosowywanie czcionek, kolorów tła, obramowań i wyrównania. Poniższy przykład dodaje formatowanie nagłówków i naprzemienne kolory wierszy:

using IronXL;
using System.Data;
using System.Windows.Forms;

// Assume dataGridView1 is already populated with data
var dataGridView1 = new DataGridView();

// (populate dataGridView1 with data as shown in the previous example)

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Set column headers with formatting
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    var headerCell = worksheet.GetCellAt(0, colIndex);
    headerCell.Value = dataGridView1.Columns[colIndex].HeaderText;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
    headerCell.Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
}

// Export data with alternating row colors
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            var excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex);

            if (cellValue != null)
                excelCell.Value = cellValue.ToString();

            // Apply alternating row background
            if (rowIndex % 2 == 0)
                excelCell.Style.BackgroundColor = "#F2F2F2";
        }
    }
}

// Auto-fit columns
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.AutoSizeColumn(colIndex);
}

workbook.SaveAs("FormattedExport.xlsx");
Console.WriteLine("Formatted export completed successfully!");

using IronXL;
using System.Data;
using System.Windows.Forms;

// Assume dataGridView1 is already populated with data
var dataGridView1 = new DataGridView();

// (populate dataGridView1 with data as shown in the previous example)

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Set column headers with formatting
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    var headerCell = worksheet.GetCellAt(0, colIndex);
    headerCell.Value = dataGridView1.Columns[colIndex].HeaderText;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
    headerCell.Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center;
}

// Export data with alternating row colors
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            var excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex);

            if (cellValue != null)
                excelCell.Value = cellValue.ToString();

            // Apply alternating row background
            if (rowIndex % 2 == 0)
                excelCell.Style.BackgroundColor = "#F2F2F2";
        }
    }
}

// Auto-fit columns
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.AutoSizeColumn(colIndex);
}

workbook.SaveAs("FormattedExport.xlsx");
Console.WriteLine("Formatted export completed successfully!");

Imports IronXL
Imports System.Data
Imports System.Windows.Forms

' Assume dataGridView1 is already populated with data
Dim dataGridView1 As New DataGridView()

' (populate dataGridView1 with data as shown in the previous example)

Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet = workbook.DefaultWorkSheet

' Set column headers with formatting
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    Dim headerCell = worksheet.GetCellAt(0, colIndex)
    headerCell.Value = dataGridView1.Columns(colIndex).HeaderText
    headerCell.Style.Font.Bold = True
    headerCell.Style.BackgroundColor = "#4472C4"
    headerCell.Style.Font.Color = "#FFFFFF"
    headerCell.Style.HorizontalAlignment = IronXl.Styles.HorizontalAlignment.Center
Next

' Export data with alternating row colors
For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
    If Not dataGridView1.Rows(rowIndex).IsNewRow Then
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
            Dim excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex)

            If cellValue IsNot Nothing Then
                excelCell.Value = cellValue.ToString()
            End If

            ' Apply alternating row background
            If rowIndex Mod 2 = 0 Then
                excelCell.Style.BackgroundColor = "#F2F2F2"
            End If
        Next
    End If
Next

' Auto-fit columns
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    worksheet.AutoSizeColumn(colIndex)
Next

workbook.SaveAs("FormattedExport.xlsx")
Console.WriteLine("Formatted export completed successfully!")

Ta ulepszona wersja stosuje profesjonalne formatowanie w wyeksportowanym pliku Excel. Nagłówki są pogrubione, mają niebieskie tło i białą czcionkę, co zapewnia wyraźne wizualne odróżnienie od wierszy danych. Kod implementuje naprzemienne kolory wierszy za pomocą operacji modulo, poprawiając czytelność dużych zbiorów danych. Możesz dodatkowo dostosować wygląd, korzystając z przewodnika formatowania komórek IronXL lub zastosować funkcję scałania komórek, aby połączyć kolumny nagłówkowe.

Metoda AutoSizeColumn dostosowuje szerokość kolumn do zawartości, eliminując konieczność ręcznej regulacji po eksporcie. Te opcje formatowania przekształcają podstawowy eksport danych w dokument gotowy do prezentacji, który użytkownicy mogą natychmiast udostępnić. Zapoznaj się z instrukcją zapisywania plików Excel za pomocą IronXL, aby poznać więcej wzorców formatowania i zapisywania danych.

Jak eksportować do wielu formatów i dodawać formuły?

IronXL wykracza poza podstawowy eksport do Excela, oferując takie funkcje, jak obsługa formuł, wiele arkuszy oraz alternatywne formaty wyjściowe. Poniższy przykład ilustruje te możliwości:

using IronXL;

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// (populate worksheet with DataGridView data as shown above)
int dataRowCount = 5; // Replace with actual dataGridView1.Rows.Count

// Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})");

// Create a summary worksheet
var summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet.SetCellValue(0, 0, "Total Products");
summarySheet.SetCellValue(0, 1, dataRowCount);

// Save in multiple formats
workbook.SaveAs("export.xlsx");
workbook.SaveAsCsv("export.csv");
workbook.SaveAsJson("export.json");
workbook.SaveAsXml("export.xml");

Console.WriteLine("Multi-format export completed!");

using IronXL;

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// (populate worksheet with DataGridView data as shown above)
int dataRowCount = 5; // Replace with actual dataGridView1.Rows.Count

// Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})");

// Create a summary worksheet
var summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet.SetCellValue(0, 0, "Total Products");
summarySheet.SetCellValue(0, 1, dataRowCount);

// Save in multiple formats
workbook.SaveAs("export.xlsx");
workbook.SaveAsCsv("export.csv");
workbook.SaveAsJson("export.json");
workbook.SaveAsXml("export.xml");

Console.WriteLine("Multi-format export completed!");

Imports IronXL

Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet = workbook.DefaultWorkSheet

' (populate worksheet with DataGridView data as shown above)
Dim dataRowCount As Integer = 5 ' Replace with actual dataGridView1.Rows.Count

' Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})")

' Create a summary worksheet
Dim summarySheet = workbook.CreateWorkSheet("Summary")
summarySheet.SetCellValue(0, 0, "Total Products")
summarySheet.SetCellValue(0, 1, dataRowCount)

' Save in multiple formats
workbook.SaveAs("export.xlsx")
workbook.SaveAsCsv("export.csv")
workbook.SaveAsJson("export.json")
workbook.SaveAsXml("export.xml")

Console.WriteLine("Multi-format export completed!")

IronXL obsługuje formuły programu Excel, umożliwiając dodawanie obliczeń bezpośrednio do eksportowanych plików. W powyższym przykładzie dodano formułę SUM, aby automatycznie obliczać sumy w kolumnach. Tworzenie wielu arkuszy pomaga uporządkować złożone eksporty, np. oddzielając dane szczegółowe od informacji podsumowujących. Odwiedź przewodnik IronXL dotyczący tworzenia plików Excel, aby zapoznać się z innymi wzorcami zarządzania arkuszami.

Elastyczność formatowania jest szczególnie cenna w scenariuszach integracji. Chociaż format XLSX jest standardem dla plików Excel, eksport do formatu CSV zapewnia uniwersalną kompatybilność z systemami baz danych i starszymi aplikacjami. Formaty JSON i XML ułatwiają wymianę danych z usługami internetowymi i interfejsami API. Można również otworzyć istniejące skoroszyty, aby dołączyć wyeksportowane dane do istniejących arkuszy kalkulacyjnych, zamiast za każdym razem tworzyć nowe pliki.

W jaki sposób IronXL upraszcza proces tworzenia oprogramowania w języku C#?

Główną zaletą IronXL jest wyeliminowanie zależności od pakietu Microsoft Office. Aplikacja działa spójnie niezależnie od tego, czy jest wdrożona na stacji roboczej programisty, komputerze klienta czy w kontenerze Docker. Ta niezależność upraszcza wdrażanie i ogranicza problemy związane z obsługą techniczną dotyczące wersji i instalacji pakietu Office. Open XML SDK firmy Microsoft to kolejna alternatywa bez pakietu Office, choć wymaga znacznie więcej kodu szablonowego w porównaniu z API wyższego poziomu IronXL. W przypadku wytycznych dotyczących tworzenia oprogramowania wielopłatformowego w .NET 10 dokumentacja Microsoft .NET obejmuje platformy docelowe, modele wdrażania oraz specyfikę Windows Forms.

Projekt API biblioteki stawia na prostotę. W przeciwieństwie do podejścia Interop opartego na COM, które wymaga starannego usuwania obiektów, IronXL wykorzystuje standardowe wzorce .NET, które są naturalne dla programistów C#. Obsługa wielu platform oznacza, że funkcje eksportu stworzone dla Windows Forms mogą być ponownie wykorzystane w aplikacjach .NET Core działających na serwerach z systemem Linux. Aby uzyskać pełny przegląd dostępnych funkcji, odwiedź stronę funkcji IronXL.

Można również zaimportować dane z Excela, aby wstępnie wypełnić DataGridView przed eksportem, tworząc obiegi pracy typu "round-trip", w których użytkownicy ładują dane z Excela, edytują je w siatce i eksportują wynik z powrotem do Excela. Przewodnik dotyczący plików Excel szczegółowo omawia proces importu.

Podczas pracy z danymi wrażliwymi IronXL obsługuje ochronę hasłem na poziomie skoroszytu i arkusza. Dokumentacja IronXL obejmuje opcje zabezpieczeń dla scenariuszy, w których eksportowane pliki muszą być chronione przed dystrybucją.

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXl

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Dłączego warto wybrać IronXL do eksportu danych z Excela w języku C#?

Eksportowanie danych DataGridView do programu Excel staje się proste dzięki IronXL. Biblioteka eliminuje tradycyjne złożoności związane z interoperacyjnością, zapewniając jednocześnie Professional możliwości formatowania i wiele formatów eksportu. Jego architektura przyjazna dla kontenerów, minimalne zależności i obsługa wielu platform sprawiają, że idealnie nadaje się do nowoczesnych procesów DevOps.

Strona główna IronXL stanowi punkt wyjścia do zapoznania się z pełną biblioteką IronXL. Niezależnie od tego, czy tworzysz mikrousługi, wdrażasz je w klastrach Kubernetes, czy uruchamiasz funkcje bezserwerowe, IronXL płynnie integruje się z procesami CI/CD. Poradnik dotyczący eksportu do programu Excel zawiera dodatkowe wzorce dla różnych scenariuszy eksportu, a poradnik dotyczący otwierania skoroszytów obejmuje odczytywanie i modyfikowanie istniejących plików.

Zacznij od bezpłatnej licencji próbnej, aby poznać pełen zestaw funkcji. Samouczki i przykłady kodu IronXL pomogą Ci szybko wdrożyć gotowe do użycia rozwiązania. Wybierz spośród elastycznych opcji licencyjnych, które odpowiadają Twoim potrzebom wdrożeniowym, od indywidualnych licencji dla programistów po nieograniczone wdrożenia korporacyjne. W przypadku jakichkolwiek pytań dotyczących rozpoczęcia pracy, centrum dokumentacji IronXL udostępnia dokumentację API, przykłady kodu oraz wskazówki dotyczące rozwiązywania problemów.