We Keep Coding

Converting JSON to an Object

i have a method that sends a POST Request to my PHP API and the API responds with a JSON String return value.
however after using JsonConvert.DeserializeObject() to the JSON result, i am getting this format
{[
{
"usr_name": "12-34567",
"usr_fullname": "LASTNAME, FIRSTNAME MIDDLENAME",
"usr_emailaddress": "myemail#mail.com",
"photo_url": "http://mywebsite.com/fetch_photo.php?id=MTItNDA1MDY=",
"token": "64c420939814c62889ea143d17736841"
}
]}
however i am not able to Deserialize it to my Class that is structured like below
public class MyObject
{
public string usr_name { get; set; }
public string usr_fullname { get; set; }
public string usr_emailaddress { get; set; }
public string photo_url { get; set; }
public string token { get; set; }
}
i am using Newtonsoft JSON.Net for this purpose, this is my first time dealing with JSON inside C# so i am quite clueless no how or what to do. i've done several research only to find outdated tutorials or questions unlike my returned JSON value
so the php's response looks like this
and after trying to deserialize it, it looks like this

Your json string is not valid json - the wrapping {} are invalid. You should check how the json string is generated / encoded inside your php API.

If I had to guess, I'd say you serialized this object in PHP from a database query, which typically returns an array of rows. Which is why your JSON is an object with an array that contains an object.
There's an extra level of indirection in there so you need to remove that to deserialize. Try using array_pop in your PHP to to make sure you're only serializing a single object, or just use the fetch rather than fetchAll equivalent for your database interface in PHP if you only expect a single value. Otherwise, iterate over the array of objects after deserializing in C#.

That can be a soultion for that in PHP (if your json example is right):
$obj = new MyClass();//get empty instance
$arr = json_decode(trim($json,'}{'),true);//get array from json, but fix it first
//because {[{'key':'value'}]} is not valid!
$arr = $arr[0];//get sub array with real data
//bind all data to your object
array_walk($arr,function($v,$k) use ($obj){ $obj->{$k}=$v; });
print $obj->usr_name;// output: 12-34567
Why is {[{'key':'value'}]} not valid?
An Object Member MUST have a name!
So that would be valid json: {'content':[{'key':'value'}]}.
UPDATE: Forget this answer!! You want to do this in C# not in PHP :)

C# Parse/Deserialize JSON partially with Newtonsoft

I have to extract a part of json-string using .net or newtonsoft json.
JSON:
var json = "{\"method\":\"subtract\",\"parameters\":{\"minuend\":\"SOME_CUSTOM_JSON_OBJECT_DIFFERENT_FOR_EACH_METHOD\",\"subtrahend\":23}}";
C# Class:
class MyJson{
public string method { get; set; }
//public string parameters {get; set;}
public object parameters {get; set;}
}
I do not need to parse all the children of "parameters" json-object. "parameters" could be a very big object ([{obj1}...{obj1000}], objX of 1000 fields), parse which would be not performant.
I would like i.e. to pass it exactly as it is on some point, so conversion "string-C#object-string" would be redundant.
I do not want use Regexp or string transformations (string.Substring, Split and co), because of error margin, I know that all .net and newtonsoft string transformations based.
Question 1: if I define a property of type "object", how newtonsoft will handle this? (Documentation is worse than msdn, so I'm looking for the input from you, who already tried this).
static void Main(string[] args)
{
var json = "{\"method\":\"subtract\",\"parameters\":{\"minuend\":42,\"subtrahend\":23}}";
var data = JsonConvert.DeserializeObject<MyJson>(j);
// what internal representaion of data.parameters?
// How is it actually converted from json-string to an C# object (JObject/JsonObject).
}
In perfect case:
"parameters" is a string and calling
ExtractMyJson(jsonString)
gives me the json string of parameters.
Basically I need the newtonsoft version of
string ExtractMyJson(jsonString){
var p1 = jsonString.Split(",");
// .. varios string transformations
return pParams;
}
Note: please don't reference "dynamic" keyword or ask why no string transformations, it's the very specific question.

If you know that your parameters are unique you can do something like this:
class MyJson
{
public string method { get; set; }
public Dictionary<string,object> parameters { get; set; }
}
................
string json = "{\"method\":\"subtract\",\"parameters\":{\"minuend\":{\"img\": 3, \"real\": 4},\"subtrahend\":23}}";
var data = JsonConvert.DeserializeObject<MyJson>(json);
If you let it as object is going to receive the type Newtonsoft.Json.Linq.JObject.

Have you tried JTOKEN?
It is a rather simple solution to partially read basic or nested JSONs as described in this post.
For a nested JSON
{
"key1": {
"key11": "value11",
"key12": "value12"
}
"key2": "value2"
}
it would look like this
JToken token = JToken.Parse(json);
var value12 = token.SelectToken("key1.key12");
to get the element of the key "key12.
I think this could go nicely with your problem.

Well Objects are treated the same way your parent object is treated. It will start from the base of the graph. So if you have something like:
Person
{
Address Address {get;set;}
}
The Json will start Deserializing Address and then add in the Person object.
If you want to limit thesize of the graph depth you can use a setting like :
JsonConvert.DeserializeObject<List<IList<IList<string>>>>(json, new JsonSerializerSettings
{
MaxDepth = 2
});
For more configurations of the JsonSerializer check JsonSerializerSettings
If your field is an object then that object will have the KeyValuePair of every property that it holds, based on that when you cast that field you can access that type.(the behaviour is the same as assigning a type to an object in C#).
Update: So if you question using JsonObject or type, well JObject is and intermediary way to construct the json format in a generic format. But using the Type deserializatin means you can ignore properties you are not interested in. Mapping to a json with a type makes more sense because it creates a new object and dismisses the old JObject.

NewtonSoft Json retrieve data with brackets method

Currently I am using the YouTube API to get some data. The data is in json and I am trying to get a single part of it.
The problem that I am facing right now is that I want to use the following method:
WebClient client = new WebClient();
string jsonData = client.DownloadString("https://www.googleapis.com/youtube/v3/videos?id=" + videoId + "&part=contentDetails&key=");
var results = JsonConvert.DeserializeObject(jsonData);
string duration = results["items"]["contentDetails"]["duration"];
Currently this results in an error:
Cannot apply indexing with [] to an expression of type 'object'
The problem I am facing right now is that I don't know how to deserialize the object properly so I can use text indexes to get to the data. I used to do it like this before but I can't recall it and can't find anything about my method.

What you should do is define a class with all your properties that matches your JSON, and then pass that class as a type argument to the deserialization:
Results results = JsonConvert.DeserializeObject<Results>(jsonData);
I don't have more info about your JSON, but a quick definition would look like this:
public class Results
{
public Items items { get; set; }
}
public class Items
{
public ContentDetails contentDetails { get; set; }
}
public class ContentDetails
{
public string duration { get; set; }
}
If you need help converting a JSON response to C# classes, you can use converters such as http://json2csharp.com/
You can also deserialize to a dynamic type, like so:
var results = JsonConvert.DeserializeObject<dynamic>(jsonData);
Then, you just access your properties:
string duration = results.items.contentDetails.duration;
However, using dynamic is not recommended most of the time, because it effectively removes static typing, so you must be sure that duration will be a string, or it will throw a runtime exception when you try to access it.

Normally if I'm dealing with a JSON payload that I don't feel like mapping to a strong type I use JObjects which allow for LINQ to JSON.
var jObject = JObject.Parse(jsonString);
This will allow the properties of the object to be indexed using [] syntax.
More information on using LINQ to JSON in the API docs.

Get your Deserialized data into dynamic type:
dynamic results = JsonConvert.DeserializeObject(jsonData);
and then access it using .:
string duration = results.items.contentDetails.duration;
The syntax you're using is used in javascript.

Try this way:
dynamic results = JsonConvert.DeserializeObject(jsonData);
then you can do
string duration = results["items"]["contentDetails"]["duration"];
or
string duration = results.items.contentDetails.duration;
Reference to dynamic keyword on MSDN: https://msdn.microsoft.com/en-us/library/dd264736.aspx

How to parse non-array JSON?

I am trying to read json from a local .json file and parse the contents using StreamReader and Json.NET. Json & my code:
contents of .json file: {"rate":50,"information":{"height":70,"ssn":43,"name":"andrew"}}
using (var sr = new StreamReader(pathToJsonFile))
{
dynamic jsonArray = JsonConvert.DeserializeObject(sr.ReadToEnd());
foreach(var item in jsonArray)
{
Console.WriteLine(item.rate);
Console.WriteLine(item.ssn);
}
}
This gives me an error on the line foreach(var item in array): Object reference not set to an instance of an object. I am guessing this is because my json is not actually an array but that is how I am trying to parse it. How can I parse this json in order to pull out fields such as rate or ssn?
NB - please do not flag this question as a duplicate of Read and parse a Json File in C#, as that is where I got my original code from.
EDIT: As has been pointed out in other answers, jsonArray is null. That explains my error but still does not answer my question. How else can I parse this json in order to extract the desired fields?

A couple things:
If you want to manually parse out the values, you should try using JObject rather than JsonConvert.DeserializeObject. The following code should work:
dynamic jsonObject = JObject.Parse("{'rate':50,'information':{'height':70,'ssn':43,'name':'andrew'}}");
Console.WriteLine(jsonObject["rate"]);
Console.WriteLine(jsonObject["information"]["ssn"]);
However, if you know how the json is structured, you should create a .net class like:
public class Person
{
public int rate {get;set;}
public Information information {get;set;}
}
public class Information
{
public int height {get;set;}
public int ssn {get;set;}
public string name {get;set;}
}
and then use:
var person = JsonConvert.DeserializeObject<Person>(thestringtodeserialize);
That way you can have a strongly typed object.

In any case, I would check for null (DeserializeObject can obviously return null):
using (var sr = new StreamReader(pathToJsonFile))
{
dynamic jsonArray = JsonConvert.DeserializeObject(sr.ReadToEnd());
if(jsonArray != null) //new check here
{
foreach(var item in jsonArray)
{
Console.WriteLine(item.rate);
Console.WriteLine(item.ssn);
}
}

I am guessing this is because my json is not actually an array
True, the returned object is dynamic, so make use of dynamic:
var json = "{\"rate\":50,\"information\":{\"height\":70,\"ssn\":43,\"name\":\"andrew\"}}";
dynamic obj = JsonConvert.DeserializeObject(json);
Console.WriteLine("rate: {0}. ssn: {1}", obj.rate, obj.information.ssn);
See live sample here: https://dotnetfiddle.net/nQYuyX

Are you sure it's an array?
If that's the format the you expect from Json, maybe you should consider defining a class.
For example:
class SomeJsonObject
{
public int rate {get;set;}
[JsonProperty("information")] //if you want to name your property something else
public InformationObject Information {get;set;}
}
class InformationObject
{
[JsonProperty("height", NullValueHandling = NullValueHandling.Ignore)] //some other things you can do with Json
public int Height {get;set;}
public int ssn {get;set;}
public string name {get;set;}
}
This way you can just deserialize it to an object:
SomeJsonObject jsonArray = JsonConvert.DeserializeObject<SomeJsonObject>(sr.ReadToEnd());

I think your question is similar to this Deserialize JSON with C# . you can use JavaScriptSerializer

I don't get a null reference (with Json.net 6.0.3) but your code has one obvious bug:
static void Main(string[] args)
{
string s = "{'rate':50,'information':{'height':70,'ssn':43,'name':'andrew'}}".Replace('\'', '\"');
var obj = JsonConvert.DeserializeObject(s);
dynamic jsonArray = obj;
foreach (var item in jsonArray)
{
Console.WriteLine(item.rate);
Console.WriteLine(item.ssn);
}
}
The bug is Console.WriteLine(item.rate) will throw.
Your 'array' jsonArray is not actually an array, it is a dictionary!
Therefore, item=the first Key-Value-pair in the dictionary, = {"rate":50}.
You can prevent the code from throwing by getting rid of your foreach loop.

i would fire up nuget and get the JSON.net package
https://www.nuget.org/packages/Newtonsoft.Json/
http://james.newtonking.com/json
it is well documented and can save you a tonne of work.
see also http://json2csharp.com/
EDIT: you are already using this

How to map a data contract to refer to correct fields in a JSON object?

I'm recieving a JSON object that looks like the example below.
{
"name1":{"name1a":"value1a","name1b":"value1b"},
"name2":{"name2a":"value2a","name2b":"value2b"}
}
I've set up a data contract for it (since I only need to access a single data field at the moment) like this.
[DataContract]
public class MyThingy
{
[DataMember(Name="name1b")]
public string Name1b { get; set; }
public MyThingy() { }
public MyThingy(String name1b)
{
Name1b = name1b;
}
}
When I've serialized the object, I try to print it out (which works, since I'm getting a string description of the class) and them the field Name1b. The last part doesn't work and I'm getting null there. My guess is that I must have mapped the data contract wrongly but I can't see how to correct it.
How should the MyThingy class be declared?
My JSON object is fetched as described in this post.

I would use JavaScriptSerializer here,
string json = #"{
""name1"":{""name1a"":""value1a"",""name1b"":""value1b""},
""name2"":{""name2a"":""value2a"",""name2b"":""value2b""}
}";
var obj = new JavaScriptSerializer()
.Deserialize<Dictionary<string, Dictionary<string, string>>>(json);
Console.WriteLine(obj["name1"]["name1b"]);
You can also use Json.Net and dynamic together
dynamic obj = JsonConvert.DeserializeObject(json);
Console.WriteLine(obj.name1.name1b);