Exporting data from a DataGridView to an Excel file requires just a few lines of C# code when you use IronXL. Create a WorkBook, iterate through the grid's columns and rows, write each cell value to the worksheet, then call SaveAs to produce a fully formatted .xlsx file -- no Microsoft Office installation needed.
Windows Forms is a foundational GUI library in the .NET ecosystem, widely used for building desktop applications. The DataGridView control is one of its most-used components: it displays, edits, and manages tabular data from any bindable source such as a DataTable, a database query result, or an in-memory list.
Exporting that grid data to Excel serves several everyday needs -- sending reports to stakeholders, archiving snapshots for auditing, or feeding data into downstream analytical tools. The two traditional approaches are Microsoft Office Interop and third-party libraries. Interop requires a copy of Excel installed on every machine that runs the application, creates COM object lifecycle issues, and performs poorly in server or cloud deployments. Libraries such as IronXL, ClosedXML, and Syncfusion avoid those problems by writing directly to the Open XML file format without any Office dependency.
This guide demonstrates the IronXL approach in C# targeting .NET 10, though IronXL supports .NET Framework 4.6.2 and all modern .NET versions.
Before writing any export code, confirm the following are in place:
DataGridView controlOpen the Package Manager Console in Visual Studio and run either command:
Alternatively, right-click the project in Solution Explorer, choose Manage NuGet Packages, search for IronXL.Excel, and click Install.
Once installed, add the IronXL using directive at the top of any file that uses Excel functionality:
using IronXL;
using System.Data;Imports IronXL
Imports System.DataIronXL supports every common spreadsheet format: XLSX, XLS, CSV, and TSV. This guide uses XLSX throughout because it is the default format for modern Excel versions.
For this walkthrough, the form contains a DataGridView named DataGridView1 and a button named btnExport. The grid is populated in the form's Load event with employee records stored in a 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;
}Option Strict On
Option Infer 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 SubEach column is defined with a specific .NET type so that numeric comparisons and formatting work correctly later. The DataSource property binds the DataTable directly to the DataGridView, and the grid automatically renders all rows when the form opens. In production, this data would typically come from a database query, an ORM result set, or a REST API response rather than hard-coded values.
A DataGridView exposes its content through two collections: Columns (for metadata such as HeaderText and column index) and Rows (for the actual data cells). Each DataGridViewRow contains a Cells collection indexed by column position. The Value property of each cell returns a boxed object that you must cast or convert before writing it to an Excel cell. Understanding this hierarchy is essential for writing a reliable export loop.
The DataTable behind the scenes stores typed values, so a decimal salary does not need string conversion before being written to an IronXL worksheet. IronXL's SetCellValue method accepts string, double, decimal, int, bool, and DateTime overloads, allowing you to preserve the original data type in the output file.
The export logic sits inside the button's click handler. The code creates a new WorkBook, retrieves the default worksheet, writes column headers to the first row, then writes each data row beneath them:
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 SubThe WorkBook object represents the entire Excel file in memory. DefaultWorkSheet returns the first sheet without requiring you to create one explicitly. The outer loop writes header text from HeaderText into row zero. The nested loop then iterates each data row, checking for null before converting the cell value to a string. The row + 1 offset shifts data below the header row. SaveAs writes the finished workbook as an Open XML XLSX file to the specified path.
The resulting file opens in Excel, Google Sheets, or any application that reads the XLSX format. Column headers appear in the first row, and all data rows follow in the same order they appeared in the DataGridView.
A plain data dump is functional but not presentation-ready. IronXL's styling API lets you apply bold fonts, background colors, text colors, and number formats to any cell range before saving:
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
Option Infer 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 SubThe GetRange method accepts standard Excel notation (A1:D1) to select a contiguous block of cells. Setting Style.Font.Bold, Style.SetBackgroundColor, and Style.Font.SetColor applies those formats to every cell in the selected range. For numeric columns, writing the value as a decimal rather than a string keeps the data type intact, which means Excel can apply number formatting such as $#,##0 correctly. Cells stored as strings do not respond to numeric format codes.
You can extend this pattern to apply alternating row shading, column width auto-fit, or freeze panes by consulting the IronXL styling documentation.
Some workflows require CSV output for compatibility with legacy systems or lightweight data pipelines. IronXL handles CSV export without any additional configuration change to the main code:
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 SubThe only change from the XLSX export is the file extension passed to SaveAs. IronXL detects the extension and serializes the workbook in the correct format automatically. This consistency means your data-writing logic stays identical regardless of output format -- a significant advantage over libraries that require separate code paths for each format.
CSV export is especially useful when the downstream consumer is a Python pandas script, a database bulk-import tool, or an analytics platform that cannot read binary XLSX files.
For grids containing tens of thousands of rows, performance becomes a consideration. The following pattern reduces memory pressure by constructing the full dataset in a single pass:
| Approach | Rows handled | Office required | Type preservation |
|---|---|---|---|
| Microsoft.Office.Interop.Excel | Up to ~65k (slow) | Yes | Partial |
| IronXL (string cells) | 1M+ rows | No | No (all text) |
| IronXL (typed cells) | 1M+ rows | No | Yes |
| IronXL from DataTable | 1M+ rows | No | Yes (auto) |
When the DataGridView is bound to a DataTable, you can load the table directly into IronXL using the WorkSheet.LoadDataTable method, bypassing the cell-by-cell iteration entirely. This approach is faster and preserves all column types automatically.
For grids not backed by a DataTable, the cell-by-cell pattern shown earlier remains the standard approach. If you need to export asynchronously to keep the UI responsive during large exports, wrap the export logic in a Task.Run call and await the result on a background thread. See the async file operations documentation for patterns on marshaling results back to the UI thread.
Traditional .NET solutions used Microsoft.Office.Interop.Excel to drive a running Excel process. That approach creates several deployment and reliability problems:
IronXL writes directly to the OOXML file format without launching any external process. Applications deploy as self-contained units. The library's API is fully managed .NET, so garbage collection handles memory automatically without Marshal.ReleaseComObject calls. Speed is substantially higher because no inter-process communication occurs.
For teams evaluating alternatives, ClosedXML is a popular open-source option. IronXL offers a broader feature set including PDF conversion, chart generation, and commercial support, which may be factors in enterprise procurement decisions. Review the IronXL licensing options to match the right tier to your team size and deployment scenario.
| Feature | IronXL | Office Interop |
|---|---|---|
| Office installation required | No | Yes |
| Server / cloud deployment | Yes | No (unsupported) |
| Managed memory model | Yes | No (COM cleanup required) |
| XLSX / CSV / XLS formats | All three | Depends on installed Excel |
| PDF export from spreadsheet | Yes | Requires additional library |
The IronXL tutorials section covers reading existing Excel files, modifying templates, generating charts, and applying conditional formatting -- all capabilities that extend naturally from the DataGridView export pattern shown here.
You now have working C# code to export a DataGridView to a formatted Excel file using IronXL. From here, consider the following directions:
try/catch block and display a user-friendly message if the file is locked or the path is invalidSaveFileDialog to let users choose the output location and filename at runtimeDataTable with a database query using ADO.NET or Entity FrameworkWorkSheet objects in the same WorkBook to organize related datasets
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
IronXL is a part of IRONSUITE
10 .NET API products for your office documents
The Excel API you need, without the Office Interop hassle.
