Test in production without watermarks.
Works wherever you need it to.
Get 30 days of fully functional product.
Have it up and running in minutes.
Full access to our support engineering team during your product trial
The applications we develop are constantly communicating with Excel spreadsheets to obtain data for evaluation and results. It's really helpful to be able to generate Excel files in C# programmatically, saving us time and effort with our development. In this tutorial, we'll learn about generating Excel files in different formats, setting cell styles, and inserting data using efficient function C# programming.
Generate Excel Files using the IronXL Excel for C# Library, providing a range of functions for generating and manipulating data in your project. The library is free for development, with licenses available when you're ready to push live. To follow this tutorial, you can download IronXL for generating or access it through Visual Studio and NuGet gallery.
dotnet add package IronXL.Excel
In business application development, we often need to generate different types of Excel files programmatically. For this purpose, we need the easiest and quickest way to generate different types of files and save them in the required location automatically.
After installing IronXL, we can use the functions to generate different Excel file types:
.xlsx
extension..xls
extension..csv
) files..tsv
) files..json
) files..xml
) files.To generate any type of file, firstly we need to create an Excel WorkBook
.
// Generate a new WorkBook
WorkBook wb = WorkBook.Create();
// Generate a new WorkBook
WorkBook wb = WorkBook.Create();
' Generate a new WorkBook
Dim wb As WorkBook = WorkBook.Create()
The above line of code will create a new WorkBook
named wb
. Now we will create a WorkSheet
object.
// Generate a new WorkSheet
WorkSheet ws = wb.CreateWorkSheet("SheetName");
// Generate a new WorkSheet
WorkSheet ws = wb.CreateWorkSheet("SheetName");
' Generate a new WorkSheet
Dim ws As WorkSheet = wb.CreateWorkSheet("SheetName")
This will create a WorkSheet
named ws
that we can use to insert data in Excel files.
First, we follow the steps above to generate the WorkBook
and WorkSheet
.
Then, we insert data into it to create our .xlsx
extension file. For this purpose, IronXL provides a Cell Addressing System that allows us to insert data into a specific cell address programmatically.
// Insert data by cell addressing
ws["CellAddress"].Value = "MyValue";
// Insert data by cell addressing
ws["CellAddress"].Value = "MyValue";
' Insert data by cell addressing
ws("CellAddress").Value = "MyValue"
It will insert a new value "MyValue" in a specific cell address. In the same way, we can insert data into as many cells as we require. After this, we will save the Excel file in the specified path as follows:
// Specify file path and name
wb.SaveAs("Path + FileName.xlsx");
// Specify file path and name
wb.SaveAs("Path + FileName.xlsx");
' Specify file path and name
wb.SaveAs("Path + FileName.xlsx")
This will create a new Excel file with the extension .xlsx
in the specified path. Don't forget to write the extension .xlsx
with the file name while saving.
To take a step further into how to create an Excel WorkBook in a C# project, check out the code examples here.
/**
* Generate XLSX File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook of .xlsx Extension
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX);
// Create workSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
ws["C4"].Value = "IronXL";
// Save the file as .xlsx
wb.SaveAs("sample.xlsx");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
/**
* Generate XLSX File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook of .xlsx Extension
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLSX);
// Create workSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
ws["C4"].Value = "IronXL";
// Save the file as .xlsx
wb.SaveAs("sample.xlsx");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
'''
''' * Generate XLSX File
'''
Imports System
Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Create new WorkBook of .xlsx Extension
Dim wb As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Create workSheet
Dim ws As WorkSheet = wb.CreateWorkSheet("Sheet1")
' Insert data in the cells of WorkSheet
ws("A1").Value = "Hello"
ws("A2").Value = "World"
ws("C4").Value = "IronXL"
' Save the file as .xlsx
wb.SaveAs("sample.xlsx")
Console.WriteLine("Successfully created.")
Console.ReadKey()
End Sub
End Class
You can see a screenshot of the newly created Excel file sample.xlsx
here:
The result of the modified value in cell C4
It is also possible to generate .xls
files using IronXL. For this purpose, we will use the WorkBook.Create()
function as follows:
// Create a workbook with XLS format
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLS);
// Create a workbook with XLS format
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLS);
' Create a workbook with XLS format
Dim wb As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)
This will create a new Excel file with a .xls
extension. Keep in mind that while assigning a name to an Excel file, you must write the extension .xls
with the file name, like this:
// Save the file as .xls
wb.SaveAs("Path + FileName.xls");
// Save the file as .xls
wb.SaveAs("Path + FileName.xls");
' Save the file as .xls
wb.SaveAs("Path + FileName.xls")
Now, let's see the example of how to generate an Excel file with a .xls
extension:
/**
* Generate XLS File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook of .xls Extension
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLS);
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .xls
wb.SaveAs("sample.xls");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
/**
* Generate XLS File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook of .xls Extension
WorkBook wb = WorkBook.Create(ExcelFileFormat.XLS);
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .xls
wb.SaveAs("sample.xls");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
'''
''' * Generate XLS File
'''
Imports System
Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Create new WorkBook of .xls Extension
Dim wb As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)
' Create WorkSheet
Dim ws As WorkSheet = wb.CreateWorkSheet("Sheet1")
' Insert data in the cells of WorkSheet
ws("A1").Value = "Hello"
ws("A2").Value = "World"
' Save the file as .xls
wb.SaveAs("sample.xls")
Console.WriteLine("Successfully created.")
Console.ReadKey()
End Sub
End Class
Comma Separated Value (.csv
) files also play a very important role in keeping data in different types of organizations. So, we also need to learn how to generate .csv
files and insert data into them programmatically.
We can use the same process as above, but we need to specify the .csv
extension with the file name while saving. Let's see an example of how to create .csv
files in our C# project:
/**
* Generate CSV File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .csv
wb.SaveAsCsv("sample.csv");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
/**
* Generate CSV File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .csv
wb.SaveAsCsv("sample.csv");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
'''
''' * Generate CSV File
'''
Imports System
Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Create new WorkBook
Dim wb As WorkBook = WorkBook.Create()
' Create WorkSheet
Dim ws As WorkSheet = wb.CreateWorkSheet("Sheet1")
' Insert data in the cells of WorkSheet
ws("A1").Value = "Hello"
ws("A2").Value = "World"
' Save the file as .csv
wb.SaveAsCsv("sample.csv")
Console.WriteLine("Successfully created.")
Console.ReadKey()
End Sub
End Class
To be able to interact more with CSV files, you can follow this tutorial to read .csv
file.
Sometimes we need to generate Tab Separated Value (.tsv
) files and insert data programmatically.
Using IronXL we can also generate .tsv
extension files, insert data into them, and then save it to the required location.
Let's see the example of how to generate .tsv
extension files:
/**
* Generate TSV File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .tsv
wb.SaveAsTsv("sample.tsv");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
/**
* Generate TSV File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .tsv
wb.SaveAsTsv("sample.tsv");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
'''
''' * Generate TSV File
'''
Imports System
Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Create new WorkBook
Dim wb As WorkBook = WorkBook.Create()
' Create WorkSheet
Dim ws As WorkSheet = wb.CreateWorkSheet("Sheet1")
' Insert data in the cells of WorkSheet
ws("A1").Value = "Hello"
ws("A2").Value = "World"
' Save the file as .tsv
wb.SaveAsTsv("sample.tsv")
Console.WriteLine("Successfully created.")
Console.ReadKey()
End Sub
End Class
We can comfortably say that JavaScript Object Notation (.json
) files are the most common data files and are used in almost all software development companies. Therefore, we often need to save the data in JSON format. For this, we need the simplest method to generate JSON format files and insert the data into them.
In such conditions, IronXL is the best option by which we can easily generate these files for C#. Let's see the example.
/**
* Generate JSON File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "1";
ws["A2"].Value = "john";
ws["B1"].Value = "2";
ws["B2"].Value = "alex";
ws["C1"].Value = "3";
ws["C2"].Value = "stokes";
// Save the file as .json
wb.SaveAsJson("sample.json");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
/**
* Generate JSON File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "1";
ws["A2"].Value = "john";
ws["B1"].Value = "2";
ws["B2"].Value = "alex";
ws["C1"].Value = "3";
ws["C2"].Value = "stokes";
// Save the file as .json
wb.SaveAsJson("sample.json");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
'''
''' * Generate JSON File
'''
Imports System
Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Create new WorkBook
Dim wb As WorkBook = WorkBook.Create()
' Create WorkSheet
Dim ws As WorkSheet = wb.CreateWorkSheet("Sheet1")
' Insert data in the cells of WorkSheet
ws("A1").Value = "1"
ws("A2").Value = "john"
ws("B1").Value = "2"
ws("B2").Value = "alex"
ws("C1").Value = "3"
ws("C2").Value = "stokes"
' Save the file as .json
wb.SaveAsJson("sample.json")
Console.WriteLine("Successfully created.")
Console.ReadKey()
End Sub
End Class
And review the screenshot of the newly created JSON file sample.json
:
Navigating to NuGet Package Manager in Visual Studio
In business application development, we often need to save the data in the Extensible Markup Language (.xml
) file format. This is important because .xml
file data is readable by both humans and machines.
Through the following examples, we will learn how to generate .xml
files for C# and insert data programmatically.
/**
* Generate XML File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .xml
wb.SaveAsXml("sample.xml");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
/**
* Generate XML File
*/
using System;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create new WorkBook
WorkBook wb = WorkBook.Create();
// Create WorkSheet
WorkSheet ws = wb.CreateWorkSheet("Sheet1");
// Insert data in the cells of WorkSheet
ws["A1"].Value = "Hello";
ws["A2"].Value = "World";
// Save the file as .xml
wb.SaveAsXml("sample.xml");
Console.WriteLine("Successfully created.");
Console.ReadKey();
}
}
'''
''' * Generate XML File
'''
Imports System
Imports IronXL
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Create new WorkBook
Dim wb As WorkBook = WorkBook.Create()
' Create WorkSheet
Dim ws As WorkSheet = wb.CreateWorkSheet("Sheet1")
' Insert data in the cells of WorkSheet
ws("A1").Value = "Hello"
ws("A2").Value = "World"
' Save the file as .xml
wb.SaveAsXml("sample.xml")
Console.WriteLine("Successfully created.")
Console.ReadKey()
End Sub
End Class
You can read more about converting Excel spreadsheets and files programmatically for use in C# projects.
IronXL library also offers a wide range of features to interact with Excel files such as cell data formatting, merging cells, inserting math functions, and even managing charts.
Read the full documentation on how IronXL generates files in every Excel format necessary for your C# project.
IronXL Generator DocumentationIronXL is a library used in C# projects to generate and manipulate Excel files, including various formats like XLSX, XLS, CSV, TSV, JSON, and XML.
You can install IronXL using the NuGet package manager in Visual Studio with the command `dotnet add package IronXL.Excel`.
To generate an XLSX file, create a WorkBook and WorkSheet, insert data using the Cell Addressing System, and save the file with an '.xlsx' extension using IronXL.
Yes, you can generate CSV files using IronXL by creating a WorkBook and WorkSheet, inserting the necessary data, and using the SaveAsCsv method.
JSON files are commonly used for data interchange between systems and applications due to their lightweight and human-readable format. They are widely used in software development for saving and exchanging data.
To generate a JSON file using IronXL, create a WorkBook and WorkSheet, insert data, and use the SaveAsJson method to save the file in the desired location.
Besides XLSX and XLS, IronXL can export to CSV, TSV, JSON, and XML formats, allowing for versatile data handling in C# projects.
IronXL is free for development purposes. However, a license is required when you are ready to deploy or go live with your project.
IronXL simplifies the process of generating and manipulating Excel files programmatically, which is crucial in business applications for automating data processing tasks.
Yes, IronXL can generate XML files by creating a WorkBook, inserting data, and using the SaveAsXml method to export the data in XML format.