However, whether you are a building a massively complex application or a simple console application, you might come across instances where you need to transmit the data. One of the most powerful data interchange formats is JSON. It offers a lightweight and human-readable format while supporting the complex data layout.
In this tutorial, we will learn how to use the provided C# tools and features to read and parse the data from a JSON file in a C# application.
Sample JSON File
Let us start by setting up our JSON file that we are going to use for demonstration purposes. In our case, the JSON file is as follows:
"database": {
"name": "admin",
"type": "SQL",
"server": "localhost:5904",
"creds": {
"username": "root",
"password": "mysql"
}
}
}
In this case, we have a basic JSON file with nested values which allows us to demonstrate how to read an arrayed JSON file.
Installing the Newtonsoft.JSON Package
In order to quickly and efficiently parse and work with JSON data in C#, we will make use of a “.NET” external library. In this case, we use the Newtonsoft.JSON package to read and work with JSON data.
Before using it, we need to ensure that we have it installed. We can run the following command in the NuGet Package Console as follows:
This should download and allow you to access the features from the Newtonsoft JSON package.
Read and Deserialize the JSON File
Once we have everything ready, we can proceed and read the JSON file. We can add the source code as follows:
using System.IO;
class Program
{
static void Main()
{
string jsonFilePath = "config.json";
string jsonString;
if (File.Exists(jsonFilePath))
{
jsonString = File.ReadAllText(jsonFilePath);
Console.WriteLine(jsonString);
}
else
{
Console.WriteLine("File not found!");
}
}
}
In the given example code, we start by defining the path to the JSON file. Next, we define a new variable to store the raw JSON string that we read.
Finally, we use the File.ReadAllText to read the JSON file.
The next step is to deserialize the JSON string. Deserializing allows us to format JSON into a valid C# object. We can do this by creating a class that represents the structure of the JSON data from the file.
An example code is as follows:
using System.IO;
using Newtonsoft.Json;
public class Creds
{
public string Username { get; set; }
public string Password { get; set; }
}
public class Database
{
public string Name { get; set; }
public string Type { get; set; }
public string Server { get; set; }
public Creds Creds { get; set; }
}
public class RootObject
{
public Database Database { get; set; }
}
class Program
{
static void Main()
{
string jsonFilePath = "config.json";
string jsonString;
if (File.Exists(jsonFilePath))
{
jsonString = File.ReadAllText(jsonFilePath);
RootObject dbInfo = JsonConvert.DeserializeObject(jsonString);
Console.WriteLine($"Database Name: {dbInfo.Database.Name}");
Console.WriteLine($"Type: {dbInfo.Database.Type}");
Console.WriteLine($"Server: {dbInfo.Database.Server}");
Console.WriteLine($"Username: {dbInfo.Database.Creds.Username}");
Console.WriteLine($"Password: {dbInfo.Database.Creds.Password}");
}
else
{
Console.WriteLine("File not found!");
}
}
}
In the given example, we define three main classes. The first is the “Credentials” class, the second is the “Database” class, and lastly, we have the “RootObject” classes. Each class maps the structure of the JSON data and the corresponding types.
Finally, we use the JsonConvert.DeserializedObject method to convert the resulting JSON string from the file into a C# object.
Read the JSON Arrays
As you can guess, a JSON data in the real world is not as simplistic as shown in the previous example. One of the most complex features that you will encounter in JSON is the arrays or nested JSON objects.
Let us see how we can handle such a layout in C#.
In our case, we are dealing with a JSON file as follows:
{
"name": "admin",
"type": "SQL",
"server": "localhost:5094",
"creds": {
"username": "root",
"password": "mysql"
}
},
{
"name": "users",
"type": "MongoDB",
"server": "localhost:5095",
"creds": {
"username": "root",
"password": "postgres"
}
}
]
Once we define the previous code, we can proceed and deserialize the JSON file and read the file.
An example code is as follows:
using System;
using System.Collections.Generic;
using System.IO;
public class Creds
{
public string Username { get; set; }
public string Password { get; set; }
}
public class Database
{
public string Name { get; set; }
public string Type { get; set; }
public string Server { get; set; }
public Creds Creds { get; set; }
}
class Program
{
static void Main()
{
string jsonFilePath = "config.json";
string jsonString;
if (File.Exists(jsonFilePath))
{
jsonString = File.ReadAllText(jsonFilePath);
List databases = JsonConvert.DeserializeObject<List>(jsonString);
foreach (var db in databases)
{
Console.WriteLine($"Database Name: {db.Name}");
Console.WriteLine($"Type: {db.Type}");
Console.WriteLine($"Server: {db.Server}");
Console.WriteLine($"Username: {db.Creds.Username}");
Console.WriteLine($"Password: {db.Creds.Password}");
Console.WriteLine();
}
}
else
{
Console.WriteLine("File not found!");
}
}
}
You might notice that the previous program does not provide much difference than a regular JSON parsing. The main different thing is that in the JsonConvert.DeserializeObject method, we convert the JSON string into a List of Database object where each object contains information about each array from the JSON list.
The resulting output is as follows:
Type: SQL
Server: localhost:5094
Username: root
Password: mysql
Database Name: users
Type: MongoDB
Server: localhost:5095
Username: root
Password: postgres
Conclusion
In this tutorial, we covered all the features of reading and working with JSON files in a C# application using the Newtonsoft.JSON application.
