Develop Reference

Nested JObjects getting serialized as empty arrays

I'm getting a really strange situation where I'm trying to serialize an object returned by a third party API into JSON. I don't have any control over the third party API or the object it returns. The C# POCO I'm trying to serialize looks something like this:
public class JobSummary {
public Job Job { get; set; }
}
public class Job {
public Status Status { get; set; }
}
public class Status {
public object JobOutput { get; set; }
public int Progress { get; set; }
}
Based on what the third party library returns, I would expect it to serialize to the following. At runtime, I can tell that the type of JobOutput is a JObject that contains a single key (Count) and value (0).
{
job: {
status: {
jobOutput: {
Count: 0
},
progress: 100
}
}
}
In this, job and status are obviously objects. progress is an int and jobOutput is a JObject.
If I run any of the following variations:
JToken.FromObject(jobSummary)
JObject.FromObject(jobSummary)
JObject.Parse(jobSummary)
And ToString() or JsonConvert.SerializeObject() the result, I get the following output:
{
job: {
status: {
jobOutput: {
Count: []
},
progress: 100
}
}
}
Notice that Count has become an [].
But if I do jobSummary.Status.JobOutput.ToString(), I correctly get back 0, so I know that the POCO returned by the third party library isn't malformed and has the info I need.
Does anybody know what could be going on? Or how I can correctly serialize the nested JObject?
Edit: I should clarify that I'm on v6.0.8 of Newtonsoft for reasons outside my control, and that the thirdparty assembly that contains the POCO has an unknown version of Newtonsoft ILMerged in it. I don't know if that is relevant.

You wrote that
I should clarify that I'm on v6.0.8 of Newtonsoft for reasons outside my control, and that the thirdparty assembly that contains the POCO has an unknown version of Newtonsoft ILMerged in it.
This explains your problem. The JobOutput contains an object with full name Newtonsoft.Json.Linq.JObject from a completely different Json.NET DLL than the one you are using. When your version of Json.NET tests to see whether the object being serialized is a JToken, it checks objectType.IsSubclassOf(typeof(JToken)) -- which will fail since the ILMerged type is not, in fact, a subclass of your version's type, despite having the same name.
As a workaround, you will need to create custom JsonConverter logic that uses the ToString() methods of the foreign JToken objects to generate output JSON, then writes that JSON to the JSON stream you are generating. The following should do the job:
public class ForeignJsonNetContainerConverter : ForeignJsonNetBaseConverter
{
static readonly string [] Names = new []
{
"Newtonsoft.Json.Linq.JObject",
"Newtonsoft.Json.Linq.JArray",
"Newtonsoft.Json.Linq.JConstructor",
"Newtonsoft.Json.Linq.JRaw",
};
protected override IReadOnlyCollection<string> TypeNames { get { return Names; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var json = value.ToString();
// Fix indentation
using (var stringReader = new StringReader(json))
using (var jsonReader = new JsonTextReader(stringReader))
{
writer.WriteToken(jsonReader);
}
}
}
public class ForeignJsonNetValueConverter : ForeignJsonNetBaseConverter
{
static readonly string [] Names = new []
{
"Newtonsoft.Json.Linq.JValue",
};
protected override IReadOnlyCollection<string> TypeNames { get { return Names; } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var underlyingValue = ((dynamic)value).Value;
if (underlyingValue == null)
{
writer.WriteNull();
}
else
{
// JValue.ToString() will be wrong for DateTime objects, we need to serialize them instead.
serializer.Serialize(writer, underlyingValue);
}
}
}
public abstract class ForeignJsonNetBaseConverter : JsonConverter
{
protected abstract IReadOnlyCollection<string> TypeNames { get; }
public override bool CanConvert(Type objectType)
{
if (objectType.IsPrimitive)
return false;
// Do not use the converter for Native JToken types, only non-native types with the same name(s).
if (objectType == typeof(JToken) || objectType.IsSubclassOf(typeof(JToken)))
return false;
var fullname = objectType.FullName;
if (TypeNames.Contains(fullname))
return true;
return false;
}
public override bool CanRead { get { return false; } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
And then use them in settings as follows:
var settings = new JsonSerializerSettings
{
Converters =
{
new ForeignJsonNetContainerConverter(), new ForeignJsonNetValueConverter()
},
};
var json = JsonConvert.SerializeObject(summary, Formatting.Indented, settings);
Notes:
The converters work by assuming that types whose FullName matches a Json.NET type's name are, in fact, Json.NET types from a different version.
JValue.ToString() returns localized values for DateTime objects (see here for details), so I created a separate converter for JValue.
I also fixed the indentation to match.
Mockup fiddle here.

How to exclude a property from being serialized in System.Text.Json.JsonSerializer.Serialize() using a JsonConverter

I want to be able to exclude a property when serializing using System.Text.Json.JsonSerializer. I don't want to use a JsonIgnore attribute everywhere I want to do this. I would like to be able to define the properties I want to exclude during serialization only, via some kind of Fluent API, which currently does not exist.
The only option I was able to find is to define a JsonConverter and add it to the list of Converters on the JsonSerializerOptions that I pass to the Serialize() method like so:
var options = new JsonSerializerOptions();
options.Converters.Add(new BookConverter());
json = JsonSerializer.Serialize(book, options);
In the JsonConverter I would have to write the entire JSON representation myself using a Utf8JsonWriter, excluding the property I don't want to serialize. This is a lot of work to just be able to exclude a property. While the JsonConverter is a great extensibility feature from the .NET team, its just too low-level for my use case. Does anyone know of any other way to acheive the exclusion of the property without having to write out the JSON representation myself?
I don't want to have to do the following:
Use an attribute, or dynamically add an attribute at runtime
Change the access modifier of the property to something like private or protected
Use a 3rd party library, as my issue is solvable if I use Json.NET.
Example:
class Program
{
void Main()
{
// We want to serialize Book but to ignore the Author property
var book = new Book() { Id = 1, Name = "Calculus", Author = new Author() };
var json = JsonSerializer.Serialize(book);
// Default serialization, we get this:
// json = { "Id": 1, "Name": "Calculus", "Author": {} }
// Add our custom converter to options and pass it to the Serialize() method
var options = new JsonSerializerOptions();
options.Converters.Add(new BookConverter());
json = JsonSerializer.Serialize(book, options);
// I want to get this:
// json = { Id: 1, Name: "Calculus" }
}
}
public class Author { }
public class Book
{
public int Id { get; set; }
public string Name { get; set; }
public Author Author { get; set; }
}
public class BookConverter : JsonConverter<Book>
{
public override Book Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
// Use default implementation when deserializing (reading)
return JsonSerializer.Deserialize<Book>(ref reader, options);
}
public override void Write(Utf8JsonWriter writer, Book value, JsonSerializerOptions options)
{
// Serializing. Here we have to write the JSON representation ourselves
writer.WriteStartObject();
writer.WriteNumber("Id", value.Id);
writer.WriteString("Name", value.Name);
// Don't write Author so we can exclude it
writer.WriteEndObject();
}
}

Option 1 - Cast to Interface
Extract interface which describes structure of desired object.
public interface IBook
{
public int Id { get; set; }
public string Name { get; set; }
}
Implement it on the original class class Book : IBook
Use the follow overload of string Serialize(object value, Type inputType, JsonSerializerOptions options = null);
json = JsonSerializer.Serialize(book, typeof(IBook), options);
If you're serializing array of Books (plural), you'll need to pass typeof(IEnumerable<IBook>) as an argument.
Option 2 - Use AutoMapper
This is useful if you don't have access to the original Book class.
Create LiteBook class:
public class LiteBook
{
public int Id { get; set; }
public string Name { get; set; }
}
Create mapping configuration:
var config = new MapperConfiguration(cfg => {
cfg.CreateMap<Book, LiteBook>();
});
Map it and serialize
json = JsonSerializer.Serialize(new Mapper(config).Map<LiteBook>(book), options)

So I happened to stumble upon an article that demonstrates how to use the JsonDocument object in the new System.Text.Json namespace and it is the next best thing to a Fluent API. Here is how this question can be solved.
The BookConverter.Write() method:
public override void Write(Utf8JsonWriter writer, Book value, JsonSerializerOptions options)
{
writer.WriteStartObject();
using (JsonDocument document = JsonDocument.Parse(JsonSerializer.Serialize(value)))
{
foreach (var property in document.RootElement.EnumerateObject())
{
if (property.Name != "Author")
property.WriteTo(writer);
}
}
writer.WriteEndObject();
}

You can simply ignore a property like this:
public class Book
{
public int Id { get; set; }
public string Name { get; set; }
[JsonIgnore]
public Author Author { get; set; }
}
reference: https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-ignore-properties?pivots=dotnet-6-0

You can try to use the following method:
public static object ConvertToObjectWithoutListedProperties<T>(
this T objectToTransform,
string[] propertiesToIgnore)
{
var type = objectToTransform.GetType();
var returnClass = new ExpandoObject() as IDictionary<string, object>;
foreach (var propertyInfo in type.GetProperties())
if (!propertiesToIgnore.Contains(propertyInfo.Name))
returnClass.Add(propertyInfo.Name,
propertyInfo.GetValue(objectToTransform));
return returnClass;
}
Credits: "Remove the null property from object"

.Net 7 made it possible to more flexibly and dynamically control which properties get serialized. See here for the official blog post:
https://devblogs.microsoft.com/dotnet/system-text-json-in-dotnet-7/#example-conditional-serialization

Is it possible to deserialize into property rather than an object

Appologies if its already been asked, I could not find anything helpful to my situation.
I need to deserialize a JSON in a property of my object instead of a whole object. The reason I am trying to do it, is that is simply generics.
I have the following situation
For instance I have
Class User
{
int UserId {get;set;}
string Name {get;set;
}
Class Wanted : CustomClass
{
User[] Users {get;set;}
public override void Map(){ }
public override void Scan(){ }
}
My Json is:
[
{
"userId": 1,
"name": "Josh"
},
{
"userId": 5,
"name" : "Martin"
}
]
Is it possible to deserialize(+ generics) my JSON directly into my Wanted class instead of serializing into A and then assign it into Wanted ?
The goal is after the serialization I will have object with type Wanted and an array with 2 users in it.

Since the JSON does not match the class you want to deserialize into, and you cannot change the JSON, you will need to use a custom JsonConverter to bridge the gap.
To make it work you'll need to introduce an interface IHasUsers which your Wanted class (or its base class) will need to implement:
interface IHasUsers
{
User[] Users { get; set; }
}
class Wanted : CustomClass, IHasUsers
{
public User[] Users { get; set; }
...
}
Then you can make a generic converter which will instantiate the Wanted class (or any other class which implements IHasUsers) and populate the Users property:
class UserListConverter<T> : JsonConverter where T: IHasUsers, new()
{
public override bool CanConvert(Type objectType)
{
return typeof(IHasUsers).IsAssignableFrom(objectType);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JArray array = JArray.Load(reader);
T obj = new T() { Users = array.ToObject<User[]>() };
return obj;
}
public override bool CanWrite
{
get { return false; }
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
Then you can deserialize your JSON like this:
Wanted wanted = JsonConvert.DeserializeObject<Wanted>(json, new UserListConverter<Wanted>());
Here is a demo: https://dotnetfiddle.net/KL6Ok6
Hope this is what you were looking for.

Since Wanted is "your desired class", there needs to be an instance of Wanted created somewhere. You might just as well create it yourself rather than having a derserializer do it for you. Once you have done this you can simply set the Users property to the deserialized data:
var wanted = new Wanted() { Users = JsonConvert.DeSerialize<User[]>(myString) };
You don't deserialize some data "into a property" without deserializing it to some object of some type first. Once you have done this you can then set the property to the object that contains the deserialized data.
There is nothing generic about Wanted here though and the deserializer cannot be supposed to figure out that it should create a Wanted or any other type unless you specify the type to derserialize the data to somewhere.
And there is no point of deserializing the data to a type defined at compile time if you don't know that the data matches this type. Then you might as well create an anonymous object or a dictionary of key/value pairs.

You can use Newtonsoft.json . Try below
var files = JArray.Parse(YourJSON);
var recList = files.SelectTokens("$").ToList();
foreach (JObject item in recList.Children())
{
foreach (JProperty prop in item.Children())
{
string key = prop.Name.ToString();
string value = prop.Value.ToString();
// and add these to an array
}
}

How to force the serialization/deserialization of my custom type?

Here is my code:
void Main()
{
var test = new Order()
{
Id = Guid.NewGuid(),
Title = "Test",
Code = new Code("O-123456789") // TODO create a Code.NewCode() later
};
var line = Newtonsoft.Json.JsonConvert.SerializeObject(test).ToString();
Console.WriteLine(line);
}
// Define other methods and classes here
public class Order
{
public Guid Id { get; set; }
public Code Code { get; set; }
public string Title { get; set; }
}
public class Code
{
public string code;
public Code(string code)
{
this.code = code;
}
}
On the console I get this result:
{"Id":"227599fe-c834-4330-84e5-2018abe59e35","Code":{"code":"O-123456789"},"Title":"Test"}
But I want this:
{"Id":"227599fe-c834-4330-84e5-2018abe59e35","Code":"O-123456789","Title":"Test"}
So how can I force my Code type to serialize like I want. Actually, I want the same behavior of Guid(). Or find a way to implement String(). Could you help me on this.
I know I can probably use some attribute to force JSON serialization but I would like something that work for all serialization exactly like the Guid()

You can create a new JsonConverter that deals with your type and then serializes it how you like:
public class CodeSerializer : JsonConverter
{
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var code = value as Code;
writer.WriteValue(code.code);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
throw new NotImplementedException();
}
public override bool CanConvert(Type objectType)
{
return typeof(Code).IsAssignableFrom(objectType);
}
}
Once we have this you can plug it in to your SerializeObject method by setting some properties on JsonSerializerSettings:
var jsonSerializerSettings = new JsonSerializerSettings();
jsonSerializerSettings.Converters.Insert(0, new CodeSerializer());
var line = Newtonsoft.Json.JsonConvert.SerializeObject(test, jsonSerializerSettings).ToString();
Console.WriteLine(line);
// {"Id":"2010e737-a9e8-4b77-bde6-1c50e92c6a30","Code":"O-123456789","Title":"Test"}

Maybe you can do it like this;
public class Order
{
public Guid Id { get; set; }
[JsonIgnore]
public Code Code { get; set; }
public string SerializedCode
{
get
{
if (Code != null)
{
return Code.code;
}
return string.Empty;
}
}
public string Title { get; set; }
}
Output : {"Id":"227599fe-c834-4330-84e5-2018abe59e35","SerializedCode":"O-123456789","Title":"Test"}
Actually, you can't do it for all serialization actions. There is no generic way to perform it. Maybe you can provide own serializer class. But I think, it wouldn't be a good solution. You don't want serialized output and class object
to be different from each other. It can be cause another problems. I suggest you to change your class and properties to perform it.

The answer is the one given in comment by David Watts:
Json.Net converts the .Net Primitive of a Guid to a string (JSON Primitive) under the hood. All details on newtonsoft.com/json/help/html/SerializationGuide.htm
At a high level, the Json.NET serializer will convert primitive .NET values into primitive JSON values, will convert .NET arrays and collections to JSON arrays, and will convert everything else to JSON objects.
For other custom serialization I must use a JsonConverter as explained by Kevin Smith.

How to convert JSON to list string, when some of the JSON objects are string and some are array?

My JSON looks like
{
"d": {
"__type": "CubeJsonData",
"SessionID": null,
"Code": 0,
"Message": "",
"Rows": {},
"Columns": {
"Place 1": [
0,
1
],
"Place 2": [
0,
2,
4,
6
],
},
"Set": [
[
"Number 1"
],
[
"Number 2"
],
[
"Number 3"
]
]
}
}
I need to get the following values
List<string> Columns must contain: "Place 1", "Place 2"
List<string> Set must contain: "Number 1", "Number 2", "Number 3"
My caller is
var settings = new JsonSerializerSettings();
settings.Converters.Add(new AssosiativeArrayConverter());
var staffAlerts = JsonConvert.DeserializeObject<List<AlertDetails>>(jo.ToString(), settings);
My JsonConverter is
class AssosiativeArrayConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
return (objectType == typeof(string)) || (objectType == typeof(List<string>));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.StartArray)
{
var l = new List<string>();
reader.Read();
while (reader.TokenType != JsonToken.EndArray)
{
l.Add(reader.Value as string);
reader.Read();
}
return l;
}
else
{
return new List<string> { reader.Value as string };
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{//to do
}
}
My class is
class StaffDetail
{
public string __type { get; set; }
public string SessionID { get; set; }
public string Code { get; set; }
public string Message { get; set; }
[JsonConverter(typeof(AssosiativeArrayConverter))]
public List<string> Rows { get; set; }
[JsonConverter(typeof(AssosiativeArrayConverter))]
public List<string> Columns { get; set; }
[JsonConverter(typeof(AssosiativeArrayConverter))]
public List<string> Set { get; set; }
}
I am getting an error
Cannot deserialize the current JSON object (e.g. {"name":"value"}) into type 'System.Collections.Generic.List`1[ReportingServicesAlerts.AlertDetails]' because the type requires a JSON array (e.g. [1,2,3]) to deserialize correctly.
To fix this error either change the JSON to a JSON array (e.g. [1,2,3]) or change the deserialized type so that it is a normal .NET type (e.g. not a primitive type like integer, not a collection type like an array or List) that can be deserialized from a JSON object. JsonObjectAttribute can also be added to the type to force it to deserialize from a JSON object.
Can you help me figure out what I'm doing wrong?

You have a lot of problems going on here. Let me start with the reason you are getting this error: your JSON contains a single outer object, but you are trying to deserialize it into a list. This won't work. If there's just a single object in the JSON, you need to deserialize into a single object.
Second issue, the data for your StaffDetail class is not at the top level of your JSON; it is one level down-- in the value of the d property of the outer JSON object. To fix this, you need to introduce a wrapper class and deserialize into that. Then you can retrieve the StaffDetail from the wrapper.
Third issue, it looks like you are trying to flatten the Columns and Set data from the JSON into List<string> properties in your class. It looks like you have correctly realized that you need a converter to do this; however, your converter doesn't handle the JSON data correctly-- it is assuming it is going to get just a simple array of strings or a simple string. Neither Columns nor Set is structured in this way in the JSON, and furthermore, the data is structured differently for both of them. The former is an object containing properties whose values are arrays of integers. The latter is an array of arrays of strings. Since they are different structures, they need to be handled differently. I would suggest using two different converters in this case.
Fourthly, while you correctly decorate your StaffDetail class with [JsonConverter] attributes to indicate which properties should use your converter, you incorrectly also add the converter to the serializer settings. The problem with this is that your converter says in CanConvert that it can handle any string or any list of strings. If you apply the converter in the settings that means that Json.Net will try to use your converter for any property anywhere that is either a string or a list of strings. Clearly, you do not want this-- your converter is really intended just to handle one specific case.
Fifth, it looks like you have also decorated your Rows property with a [JsonConverter] attribute, but the JSON shows an empty object. Will this field have any data that you care about? If not, just declare it as object; if you do care, please show an example of what might be in there. Or if you know that it will be structured the same as either Columns or Set, then you can keep it as List<string> and reuse one of those converters.
There are also some other minor issues in your question such as your JSON being invalid due to an extra comma (already pointed out by #frno), and the fact that your call to JsonConvert.DeserializeObject() mentions a class called AlertDetails but the class you show is actually named StaffDetail. But we'll chalk those up to simple copy-paste mistakes.
Whew!
OK, so how do we fix all this?
Let start with your classes. I mentioned that you need a wrapper class since your data is actually one level down in the JSON; here's what that would look like:
class Wrapper
{
public StaffDetail d { get; set; }
}
For your StaffDetail class, I've changed the Columns and Set properties to use different converters, since the JSON is different for each. I'll define those converters next. I also changed the type of Rows to object and removed the [JsonConverter] attribute for now, since it's not clear from the question how that field should be handled. If the data will be structured like Columns or Set then you can change it back and use the appropriate converter, as I mentioned.
class StaffDetail
{
public string __type { get; set; }
public string SessionID { get; set; }
public string Code { get; set; }
public string Message { get; set; }
public object Rows { get; set; }
[JsonConverter(typeof(ColumnsConverter))]
public List<string> Columns { get; set; }
[JsonConverter(typeof(SetConverter))]
public List<string> Set { get; set; }
}
Here is the converter which will handle the Columns data. This converter will take a JSON object and extract the property names into a list of strings.
class ColumnsConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
// this converter can handle converting some JSON to a List<string>
return objectType == typeof(List<string>);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
// Convert an object to a flat list of strings containing
// just the property names from the object.
JObject obj = JObject.Load(reader);
return obj.Properties().Select(p => p.Name).ToList();
}
public override bool CanWrite
{
get { return false; }
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
Here is the converter which will handle the Set data. This converter will take an array of arrays of strings and convert it into a flat list of strings.
class SetConverter : JsonConverter
{
public override bool CanConvert(Type objectType)
{
// this converter can handle converting some JSON to a List<string>
return objectType == typeof(List<string>);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
// Convert an array of arrays of strings to a flat list of strings
JArray array = JArray.Load(reader);
return array.Children<JArray>()
.SelectMany(ja => ja.Children(), (ja, jt) => jt.Value<string>()).ToList();
}
public override bool CanWrite
{
get { return false; }
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotImplementedException();
}
}
To deserialize, you can call JsonConvert.DeserializeObject() like this. Notice how I deserialize into the Wrapper class, then retrieve the StaffDetail from it. Also notice that I don't need to (and shouldn't in this case) pass the converters to the deserializer. They will get picked up automatically and at the appropriate times by virtue of the [JsonConverter] attributes on the StaffDetail class properties.
StaffDetail detail = JsonConvert.DeserializeObject<Wrapper>(json).d;
Here is simple demo program to show how it all works:
class Program
{
static void Main(string[] args)
{
string json = #"
{
""d"": {
""__type"": ""CubeJsonData"",
""SessionID"": null,
""Code"": 0,
""Message"": """",
""Rows"": {},
""Columns"": {
""Place 1"": [
0,
1
],
""Place 2"": [
0,
2,
4,
6
]
},
""Set"": [
[
""Number 1""
],
[
""Number 2""
],
[
""Number 3""
]
]
}
}";
StaffDetail detail = JsonConvert.DeserializeObject<Wrapper>(json).d;
Console.WriteLine("Columns: " + string.Join(", ", detail.Columns));
Console.WriteLine("Set: " + string.Join(", ", detail.Set));
}
}
Output:
Columns: Place 1, Place 2
Set: Number 1, Number 2, Number 3

your Json is a bit weird, if you can change it. Nevertheless, correct classes :
(+ DONT FORGET TO REMOVE A COMMA I WROTE ABOUT )
public class Columns
{
[JsonProperty(PropertyName="Place 1")]
public List<int> Place1;
[JsonProperty(PropertyName="Place 2")]
public List<int> Place2;
}
public class Rows { }
public class D
{
public string __type;
public object SessionID;
public int Code;
public string Message;
public Rows Rows;
public Columns Columns;
public List<List<string>> Set;
}
public class StaffDetail
{
public D d { get; set; }
}
and a single simple way to get it all
var result = JsonConvert.DeserializeObject<StaffDetail>(json);
then just get the properties all you want, like
result.d.Columns.Place1[0] // for example