We have a method that returns a single JSON object as a string.
Now, let’s proceed to look at different ways how to get value by key from JObject in C# and process this JSON string.
The Json.NET library provides us flexibility when reading values from a JSON object. We are going to look at four ways to do this:
Passing the key as an index
Using the JObject.Value<T>() method
Using the JObject.SelectToken() method
Using the JObject.TryGetValue() method
First, let’s add a new JObjectManipulation class, which we’ll use to illustrate these four approaches:
public class JObjectManipulation
public string SingleJsonObject { get; set; }
public JObjectManipulation()
InitializeData();
public void InitializeData()
var testData = new TestData();
SingleJsonObject = testData.GenerateSingleJsonObject();
In this class, we are initializing the SingleJsonObject class property in the InitializeData() method, which we then call in the constructor.
Passing the Key as an Index
In the JObjectManipulation class, let’s add a new method:
public int GetValuesUsingIndex()
var jsonObject = JObject.Parse(SingleJsonObject);
var name = (string)jsonObject["name"];
var make = (string)jsonObject["make"];
var model = (string)jsonObject["model"];
var year = (int)jsonObject["year"];
var price = (JObject)jsonObject["price"];
var amount = (int)price["amount"];
var currency = (string)price["currency"];
Console.WriteLine($"A {make} {name} {model} {year} costs {amount} {currency} \n");
return jsonObject.Count;
We first convert the SingleJsonObject string to a JObject using JObject.Parse. To get values from the JSON object, we pass the keys as indexes to the JObject, using the square bracket notation. After getting the values, we cast them to the desired type.
The price key has nested JSON with amount and currency key-value pairs. To get these values, we follow the same steps, by first converting the value of price to a JObject using a cast:
Wanna join Code Maze Team, help us produce more awesome .NET/C# content and
get paid? >> JOIN US! <<
var price = (JObject)jsonObject["price"]
Then, we access the values of amount and currency using the index of the resulting JObject:
var amount = (int)price["amount"];
var currency = (string)price["currency"];
If the JSON data is not deeply nested, we can use this method to get the values. However, if our JSON object has a deep hierarchy, accessing a value that is deep can be very tedious. That’s where the Value<T>() method comes into play.
Let’s tackle it next.
Using the Value<T>() Method
Using this method, we directly pass the key as the parameter to the method. In addition to that, we also pass the appropriate type as a type argument to the Value<T> method. The method then returns the value already cast.
That said, let’s create a new GetValuesUsingValueMethod method:
public int GetValuesUsingValueMethod()
var jsonObject = JObject.Parse(SingleJsonObject);
var name = jsonObject.Value<string>("name");
var make = jsonObject.Value<string>("make");
var model = jsonObject.Value<string>("model");
var year = jsonObject.Value<string>("year");
var amount = jsonObject.Value<int>("price.amount");
var currency = jsonObject.Value<string>("price.currency");
Console.WriteLine($"A {make} {name} {model} {year} costs {amount} {currency} \n");
return jsonObject.Count;
We first convert the SingleJsonObject string to a JObject. Then, we use the Value<T>() method to get values from the JObject and assign them to local variables. In cases where we have nested JSON, we pass the keys separated by the . operator.
Compared to the first approach, using the Value<T>() method is less tedious when working with a nested JSON object. However, to get the correct value, we have to pass the right key.
Wanna join Code Maze Team, help us produce more awesome .NET/C# content and
get paid? >> JOIN US! <<
Using the SelectToken() Method
To continue, let’s add a new method to the JObjectManipulation class:
public int GetValuesUsingSelectToken()
var jsonObject = JObject.Parse(SingleJsonObject);
var name = (string)jsonObject.SelectToken("name");
var make = (string)jsonObject.SelectToken("make");
var model = (string)jsonObject.SelectToken("model");
var year = (int)jsonObject.SelectToken("year");
var amount = (int)jsonObject.SelectToken("price.amount");
var currency = (string)jsonObject.SelectToken("price.currency");
Console.WriteLine($"A {make} {name} {model} {year} costs {amount} {currency} \n");
return jsonObject.Count;
The first step is creating a JObject from the JSON string. After that, we call the SelectToken method passing the keys as parameters. Then, we cast the values to appropriate data types.
When working with more complex JSON data, the SelectToken() method would be the best choice of the three. Beyond basic usage, it offers some advanced capabilities like:
Querying JSON arrays using indexes
Support for JSONPath queries
Support for LINQ queries
When we call each of these methods discussed, we get this output in the console:
A Dodge Charger RT 2019 costs 36100 USD
In each of the approaches we have covered so far, we will get an exception whenever the JSON key is missing. Let’s look at an alternative approach.
Using the JObject.TryGetValue() Method
The TryGetValue takes both the key and output variable as parameters. Then, it tries to get the JSON token that matches the specified key. If the token is found, this method returns true otherwise, it returns false.
Let’s demonstrate this:
Wanna join Code Maze Team, help us produce more awesome .NET/C# content and
get paid? >> JOIN US! <<
public int GetValuesUsingTryGetValue()
JObject jsonObject = JObject.Parse(SingleJsonObject);
if (jsonObject.TryGetValue("name", out JToken nameToken))
string name = (string)nameToken;
Console.WriteLine($"Name: {name}");
if (jsonObject.TryGetValue("make", out JToken makeToken))
string make = (string)makeToken;
Console.WriteLine($"Make: {make}");
if (jsonObject.TryGetValue("price", out JToken priceToken) && priceToken is JObject priceObject)
if (priceObject.TryGetValue("amount", out JToken amountToken))
int amount = (int)amountToken;
Console.WriteLine($"Price amount: {amount}");
if (priceObject.TryGetValue("currency", out JToken currencyToken))
string currency = (string)currencyToken;
Console.WriteLine($"Price currency: {currency}");
return jsonObject.Count;
We are passing the keys for which we want to get values together with JToken objects. If the method returns true, we cast the JToken objects into specified types.
Similarly, we have a nested JSON price object. In this case, we first call the TryGetValue method passing the price key. If this returns true, we use the is operator to check if priceToken is a JObject. If this check returns true as well, we proceed to access the values of the price nested JSON object.
Calling this method, we get:
Name: Charger
Make: Dodge
Price amount: 36100
Price currency: USD
Using TryGetValue method, if any of the keys we are trying to access is missing, the method returns false. This way, we are not trying to access the values of a non-existent key.
The appropriate use case for this method is when working with JSON data from an API where the data does not have a fixed structure. In this case, if a key is missing, our application won’t break.
Conclusion
In this article, we have learned how to get value by key from JObject in C# to process JSON data. We hope this guide will be of assistance when developing future applications.
