Skip to footer content
USING IRONXL

How to Export a DataGridView to an Excel in VB.NET

Exporting data from a Windows Forms DataGridView to Excel is a common requirement in business applications. Whether generating reports, creating data backups, or sharing information with stakeholders, developers need a reliable way to export GridView data contents to Excel format. While traditional approaches using Microsoft Office Interop have served this purpose, they come with deployment complexities and dependency requirements that can complicate application distribution.

This tutorial demonstrates a practical VB.NET example for exporting DataGridView data to Excel using IronXL, a powerful .NET library that eliminates the need for Microsoft Office installation. We'll explore how to implement a clean, efficient export solution that works across different environments, including cloud platforms and containers, making it ideal for modern .NET Excel manipulation scenarios.

How to Export a DataGridView to an Excel in VB.NET: Figure 1 - IronXL

Why is the DataGridView to Excel Export Essential?

DataGridView controls are fundamental to Windows Forms applications, displaying tabular data that users interact with daily. Exporting this data to Excel enables users to leverage Excel's powerful analysis tools, create presentations, and share data with colleagues who may not have access to the application. This VB.NET Excel export functionality is crucial for business reporting.

Traditional export methods using Microsoft.Office.Interop.Excel requires Excel to be installed on every machine running the application. This creates deployment challenges, especially in server environments or when distributing applications to users without Office licenses. Additionally, Interop approaches can suffer from memory leaks and COM object cleanup issues if not handled carefully.

Modern .NET applications demand more flexible solutions. IronXL addresses these challenges by providing a standalone library that generates Excel files without any Microsoft Office dependencies. This approach ensures consistent functionality across development, testing, and production environments while supporting deployment to containers and cloud platforms where Office installation isn't feasible.A valid license key is required for production use to unlock all features.

How to Export a DataGridView to an Excel in VB.NET: Figure 2 - Cross Platform

How to Export GridView to Excel VB .NET Example Using IronXL?

Let's start by setting up IronXL in your VB.NET project. Open the Package Manager Console in Visual Studio and install IronXL with this command:

Install-Package IronXL.Excel

How to Export a DataGridView to an Excel in VB.NET: Figure 3 - Installation

For detailed installation options, refer to the IronXL installation guide. Once installed, add Imports IronXL to your VB .NET project files to access the library's Excel export capabilities.

First, we'll create a sample Windows Forms application with a DataGridView populated with import data. Here's the complete code for setting up the form and implementing the export functionality:

Imports IronXL
Imports System.Windows.Forms
Imports System.Data
Public Class Form1
    ' Type GridView
    Private dataGridView1 As DataGridView
    Private btnExport As Button
    Public Sub New()
        InitializeComponent()
        SetupControls()
        LoadSampleData()
    End Sub
    Private Sub SetupControls()
        ' Initialize DataGridView
        dataGridView1 = New DataGridView()
        dataGridView1.Location = New Point(10, 10)
        dataGridView1.Size = New Size(450, 200)
        ' Initialize Export Button
        btnExport = New Button()
        btnExport.Text = "Export to Excel"
        btnExport.Location = New Point(10, 220)
        btnExport.Size = New Size(120, 30)
        AddHandler btnExport.Click, AddressOf ExportToExcel
        ' Add controls to form
        Me.Controls.Add(dataGridView1)
        Me.Controls.Add(btnExport)
        Me.Text = "DataGridView to Excel Export"
        Me.Size = New Size(500, 300)
    End Sub
    Private Sub LoadSampleData()
        ' Create sample DataTable
        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))
        ' Add sample rows
        dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99, 15)
        dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99, 50)
        dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99, 100)
        dt.Rows.Add(1004, "Monitor 27""", "Electronics", 399.99, 8)
        dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99, 25)
        ' Bind to DataGridView
        dataGridView1.DataSource = dt
    End Sub
    Private Sub ExportToExcel(ByVal sender As Object, ByVal e As EventArgs)
        Try
            ' 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, cellValue)
Else
    worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue.ToString())
End If
                    Next
                End If
            Next
            ' Save the Excel file
            Dim saveDialog As New SaveFileDialog()
            saveDialog.Filter = "Excel Files|*.xlsx"
            saveDialog.Title = "Save Excel File"
            saveDialog.FileName = "DataGridViewExport.xlsx"
            If saveDialog.ShowDialog() = DialogResult.OK Then
                workbook.SaveAs(saveDialog.FileName)
                MessageBox.Show("Export completed successfully!", "Success", 
                              MessageBoxButtons.OK, MessageBoxIcon.Information)
            End If
        Catch ex As Exception
            MessageBox.Show("Export failed: " & ex.Message, "Error", 
                          MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
End Class
Imports IronXL
Imports System.Windows.Forms
Imports System.Data
Public Class Form1
    ' Type GridView
    Private dataGridView1 As DataGridView
    Private btnExport As Button
    Public Sub New()
        InitializeComponent()
        SetupControls()
        LoadSampleData()
    End Sub
    Private Sub SetupControls()
        ' Initialize DataGridView
        dataGridView1 = New DataGridView()
        dataGridView1.Location = New Point(10, 10)
        dataGridView1.Size = New Size(450, 200)
        ' Initialize Export Button
        btnExport = New Button()
        btnExport.Text = "Export to Excel"
        btnExport.Location = New Point(10, 220)
        btnExport.Size = New Size(120, 30)
        AddHandler btnExport.Click, AddressOf ExportToExcel
        ' Add controls to form
        Me.Controls.Add(dataGridView1)
        Me.Controls.Add(btnExport)
        Me.Text = "DataGridView to Excel Export"
        Me.Size = New Size(500, 300)
    End Sub
    Private Sub LoadSampleData()
        ' Create sample DataTable
        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))
        ' Add sample rows
        dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99, 15)
        dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99, 50)
        dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99, 100)
        dt.Rows.Add(1004, "Monitor 27""", "Electronics", 399.99, 8)
        dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99, 25)
        ' Bind to DataGridView
        dataGridView1.DataSource = dt
    End Sub
    Private Sub ExportToExcel(ByVal sender As Object, ByVal e As EventArgs)
        Try
            ' 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, cellValue)
Else
    worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue.ToString())
End If
                    Next
                End If
            Next
            ' Save the Excel file
            Dim saveDialog As New SaveFileDialog()
            saveDialog.Filter = "Excel Files|*.xlsx"
            saveDialog.Title = "Save Excel File"
            saveDialog.FileName = "DataGridViewExport.xlsx"
            If saveDialog.ShowDialog() = DialogResult.OK Then
                workbook.SaveAs(saveDialog.FileName)
                MessageBox.Show("Export completed successfully!", "Success", 
                              MessageBoxButtons.OK, MessageBoxIcon.Information)
            End If
        Catch ex As Exception
            MessageBox.Show("Export failed: " & ex.Message, "Error", 
                          MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub
End Class
VB .NET

This code demonstrates the core export functionality. The SetupControls method creates the DataGridView and export button, positioning them on the form. The LoadSampleData method populates the grid with sample product data using a DataTable, which serves as a common data source for DataGridView controls in VB.NET applications.

The ExportToExcel method handles the actual export process. It creates a new IronXL WorkBook using the XLSX format, then iterates through the DataGridView to export both headers and data into the Excel sheet. The SetCellValue method efficiently places values into Excel cells using row and column indices. The code uses the IsNewRow property to skip the empty row that appears at the bottom of editable DataGridViews. This approach ensures clean Excel output without unexpected blank rows.

If you were implementing this feature in a web-based ASP.NET application, you would extend it further by returning the file as a downloadable response. In that case, you would use the Content-Disposition HTTP header to specify whether the Excel file should be displayed inline in the browser or forced as a download attachment. After the rendered end of the page lifecycle, the file is sent to the client. Similarly, ASP.NET WebForms developers may need to override the public override void VerifyRenderingInServerForm method when exporting controls to ensure the control renders properly.

Output

How to Export a DataGridView to an Excel in VB.NET: Figure 4 - DataGridView Output

How to Export a DataGridView to an Excel in VB.NET: Figure 5 - Excel Output

If you were implementing this feature in a web-based ASP.NET application, you could extend it further by returning the file as a downloadable response. In that case, you would use the Content-Disposition HTTP header to specify whether the Excel file should be displayed inline in the browser or forced as a download attachment. Similarly, ASP.NET WebForms developers may need to override the public override void VerifyRenderingInServerForm method when exporting controls like GridView to Excel, ensuring the control renders properly outside of the normal page lifecycle.

How to Enhance Your Excel Export with Formatting?

Professional Excel exports often require formatting to improve readability. IronXL provides extensive styling capabilities that can be applied during the export process. Here's an enhanced version that includes formatting:

' Object sender
Private Sub ExportToExcelWithFormatting(sender As Object, e As EventArgs)
    Try
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Default Excel Worksheet
        Dim worksheet As 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
            ' Apply header formatting
            headerCell.Style.Font.Bold = True
            headerCell.Style.BackgroundColor = "#4472C4"
            headerCell.Style.Font.Color = "#FFFFFF"
            headerCell.Style.HorizontalAlignment = 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 colors
                    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
        ' Save formatted Excel file
        Dim saveDialog As New SaveFileDialog()
        saveDialog.Filter = "Excel Files|*.xlsx"
        If saveDialog.ShowDialog() = DialogResult.OK Then
            workbook.SaveAs(saveDialog.FileName)
            MessageBox.Show("Formatted export completed!", "Success")
        End If
    Catch ex As Exception
        MessageBox.Show("Export failed: " & ex.Message, "Error")
    End Try
End Sub
' Object sender
Private Sub ExportToExcelWithFormatting(sender As Object, e As EventArgs)
    Try
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        ' Default Excel Worksheet
        Dim worksheet As 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
            ' Apply header formatting
            headerCell.Style.Font.Bold = True
            headerCell.Style.BackgroundColor = "#4472C4"
            headerCell.Style.Font.Color = "#FFFFFF"
            headerCell.Style.HorizontalAlignment = 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 colors
                    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
        ' Save formatted Excel file
        Dim saveDialog As New SaveFileDialog()
        saveDialog.Filter = "Excel Files|*.xlsx"
        If saveDialog.ShowDialog() = DialogResult.OK Then
            workbook.SaveAs(saveDialog.FileName)
            MessageBox.Show("Formatted export completed!", "Success")
        End If
    Catch ex As Exception
        MessageBox.Show("Export failed: " & ex.Message, "Error")
    End Try
End Sub
VB .NET

This enhanced version applies professional formatting to the exported Excel file. Headers receive bold text with a blue background and white font color, creating a clear visual distinction. The code implements alternating row colors using a simple modulo operation, improving readability for large datasets.

The AutoSizeColumn method adjusts column widths to fit content, eliminating the need for manual adjustment after export. These formatting options transform a basic data export into a presentation-ready document that users can share immediately.

What Additional Export Options does IronXL Provide?

IronXL extends beyond basic Excel export, offering features that enhance functionality and flexibility. Here are some powerful capabilities you can incorporate:

' Add formulas to calculate totals
worksheet.SetCellValue(dataGridView1.Rows.Count + 2, 3, "=SUM(D2:D" & (dataGridView1.Rows.Count + 1) & ")")
' Create multiple worksheets for categorized data
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("Summary")
summarySheet.SetCellValue(0, 0, "Total Products")
summarySheet.SetCellValue(0, 1, dataGridView1.Rows.Count - 1)
' Export to different formats
workbook.SaveAsCsv("export.csv")     ' CSV format
workbook.SaveAsJson("export.json")   ' JSON format
workbook.SaveAsXml("export.xml")     ' XML format
' Add formulas to calculate totals
worksheet.SetCellValue(dataGridView1.Rows.Count + 2, 3, "=SUM(D2:D" & (dataGridView1.Rows.Count + 1) & ")")
' Create multiple worksheets for categorized data
Dim summarySheet As WorkSheet = workbook.CreateWorkSheet("Summary")
summarySheet.SetCellValue(0, 0, "Total Products")
summarySheet.SetCellValue(0, 1, dataGridView1.Rows.Count - 1)
' Export to different formats
workbook.SaveAsCsv("export.csv")     ' CSV format
workbook.SaveAsJson("export.json")   ' JSON format
workbook.SaveAsXml("export.xml")     ' XML format
VB .NET

IronXL supports Excel formulas, allowing you to add calculations directly to the exported file. The example shows adding a SUM formula to calculate column totals. Creating multiple worksheets helps organize complex exports, such as separating detailed data from summary information.

The library's format flexibility is particularly valuable. While XLSX is standard for Excel files, CSV export provides universal compatibility with database systems and older applications. JSON and XML formats facilitate data exchange with web services and APIs, making IronXL suitable for diverse integration scenarios. Learn more about converting between formats in the documentation.

Output

How to Export a DataGridView to an Excel in VB.NET: Figure 6 - Formula Output

How to Export a DataGridView to an Excel in VB.NET: Figure 7 - Multiple Worksheets Output

How to Export a DataGridView to an Excel in VB.NET: Figure 8 - CSV Output

How to Export a DataGridView to an Excel in VB.NET: Figure 9 - JSON Output

How to Export a DataGridView to an Excel in VB.NET: Figure 10 - XML Output

How Does IronXL Simplify Your Development Process?

IronXL's greatest advantage is eliminating Microsoft Office dependencies. Your application runs consistently whether deployed on a developer workstation, customer machine, or Docker container. This independence simplifies deployment and reduces support issues related to Office versions and installations.

The library's API design prioritizes simplicity. Unlike Interop's COM-based approach requiring careful object disposal, IronXL uses standard .NET patterns that feel natural to VB.NET developers. Cross-platform support means your Windows Forms application's export functionality can be reused in ASP.NET Core applications running on Linux servers. For comprehensive documentation and examples, visit the IronXL API reference.

How to Export a DataGridView to an Excel in VB.NET: Figure 11 - Features

Conclusion

Exporting DataGridView data to Excel becomes straightforward with IronXL. The library eliminates traditional Interop complexities while providing professional formatting capabilities and multiple export formats. Ready to transform your VB.NET Excel export capabilities? Start with a free trial that suit your deployment needs.

How to Export a DataGridView to an Excel in VB.NET: Figure 12 - Licensing

Regan Pun
Software Engineer
Regan graduated from the University of Reading, with a BA in Electronic Engineering. Before joining Iron Software, his previous job roles had him laser-focused on single tasks; and what he most enjoys at Iron Software is the spectrum of work he gets to undertake, whether it’s adding value to ...Read More
Ready to Get Started?
Nuget Downloads 1,626,369 | Version: 2025.10 just released