Develop Reference

Deserialize an array inside a json object using JsonConvert.DeserializeObject()

I have a requirement where I have incoming json object of the following format:
{
"CustomerList": {
"Customer": [{
"CustomerCode" : "C123",
"CustomerName" : "Peter"
},
{
"CustomerCode" : "C456",
"CustomerName" : "John"
}]
}
}
And I have the my C# object of the following Format:
[System.Xml.Serialization.XmlArrayItemAttribute(IsNullable = "false")]
public Customer[] CustomerList
{
get; set;
}
[System.Xml.Serialization.XmlTypeAttribute()]
public class Customer
{
public string CustomerCode {get; set;}
public string CustomerName {get; set;}
}
During Deserialization using JsonConvert.DeserializeObject(), I get the following error:
Cannot deserialize the current JSON object into type Customer[], because the type requires a JSON array (e.g. [1,2,3]) to deserialize correctly.
On my side the limitation is that I cannot change the incoming JSON object and neither can I modify the C# object structure. So the ask is that, is there a way to map the Customer node in the incoming Json, to the CustomerList C# array directly, without needing to rename or change the structure of either?

Based on the JSON you have shared, you need to have following class structure.
public class Customer {
public string CustomerCode { get; set; }
public string CustomerName { get; set; }
}
public class CustomerList {
public List<Customer> Customer { get; set; }
}
public class RootObject {
public CustomerList CustomerList { get; set; }
}
and then you need to deserizalize the JSON as following.
RootObject obj = JsonConvert.DeserializeObject<RootObject>(jsonString);
Here jsonString is the string variable which has the JSON string.
I hope you this will help you resolve your issue.

To deserialize the JSON object you need to create a similar C# class.
public class JsonObjectTest {
[JsonPropertyName("CustomerList")]
public Customer CustomerPreList {get;set;}
}
public class Customer {
public List<CustomerObject> Customer {get;set;}
}
public class CustomerObject {
public string CustomerCode { get; set; }
public string CustomerName { get; set; }
}
Afterwards you deserialize the JSON object:
CustomerList xmlData = JsonConvert.DeserializeObject<JsonObjectTest>(jsonObjectString).Select(data =>
new CustomerList = data.CustomerPreList.toArray());
Unfortunately I could not ask you if you have a permission to create new classes (I need more points). If this is the case try AutoMapper to create a mapping policy for this specific case.
Happy coding :)

If you cannot (or do not want to) add new classes, the last two lines of GetCustomers() below should do what you want. Just assign it to the CustomerList property.
public class Customer
{
public string? CustomerCode { get; set; }
public string? CustomerName { get; set; }
}
public Customer[] GetCustomers()
{
string json = #"{
'CustomerList':
{
'Customer': [{
'CustomerCode' : 'C123',
'CustomerName' : 'Peter'
},
{
'CustomerCode' : 'C456',
'CustomerName' : 'John'
}]
}
}";
dynamic? contentObj = JsonConvert.DeserializeObject(json);
return (contentObj?.CustomerList.Customer.ToObject<IList<Customer>>())?.ToArray() ?? new List<Customer>().ToArray();
}
I am working with .NET 6.0 so working with string? but for earlier versions of c# string should do the same. Play with the null handling as required.

Trouble deserialize JSON with RestSharp

I'm trying to deserialize a JSON response from WooCommerce with RestSharp.
I've been crawling this site for similar posts, but haven't found any solution.
My JSON (simplified)
[
{
"id":1,
"name":"product 1",
},
{
"id":2,
"name":"product 2",
}
]
Which translates into C# like this:
public class ProductResponse
{
public List<Product> products { get; set; }
}
public class Product
{
public int id { get; set; }
public string name { get; set; }
}
And is called like this
var response = client.Execute<ProductResponse>(request);
But it doesn't work, as the array of products doesn't have a name.
If the JSON is changed to
{
"products":
[
{
"id":1,
"name":"product 1",
},
{
"id":2,
"name":"product 2",
}
]
}
It works like a charm. Unfortunately I'm not able to change the JSON-format.
So how do I solve this?
Thanks in advance

You can annotate your product class to tell RestSharp which property is which:
public class Product
{
[DeserializeAs(Name = "id")]
public int id { get; set; }
[DeserializeAs(Name = "name")]
public string name { get; set; }
}
Then:
var response = client.Execute<List<Product>>(request);
You should now have a List<Product> with two correctly populated entries.
Original answer for posterity:
I don't have an answer for RestSharp (yet) but you could achieve this easily with Newtonsoft JSON if you can use that.
You can use the JsonProperty annotation like so:
public class Product
{
[JsonProperty("id")]
int id { get; set; }
[JsonProperty("name")]
string name { get; set; }
}
Then:
var products = JsonConvert.DeserializeObject<List<Product>>(json);

I think your deserialization actually should be List<Product> rather than ProductResponse.
E.g.
var response = client.Execute<List<Product>>(request);
Console.WriteLine("id = " + response[0].id) // id = 1
Console.WriteLine("name = " + response[0].name) // name = product 1
Console.WriteLine("id = " + response[1].id) // id = 2
Console.WriteLine("name = " + response[1].name) // name = product 2
So there is nothing wrong with the JSON string, I think the problem is you are expecting an object of type ProductResponse, where as your JSON string is an array/List of type Product.

C# web API property object as string not object

I have an web API function that has a property that can take different shapes. Actually i need to save a json in database.
I will give you some examples
post body
{
"title":"example 1",
"type": "0",
"extraData": { "name": "bob",
// here is the catch this is first type of object let's say children
[{
"age": 10
"toys": "bear, goat"
},
{
"age": 18
"toys": "guitar"
}]
}
}
{
"title":"example 1",
"type": "1",
"extraData": { "name": "john",
// here is the catch this is first type of object let's say grandparents
[{
"age": 90
"cars": "honda civic"
},
{
"age": 18
"car": "renault megan, pegeout 206"
}]
}
}
Now let's assume that we can't merge grandparents and children together in a class so my classes will look something like:
public class Family{
public string Title {get; set;}
public string ExtraData {get; set;}
public int Type {get;set;}
}
public class ExtraData<T> where T: Person{
public string Name{get;set;}
public List<T> Persons {get;set;}
}
public class Person{
public int Age {get;set;}
}
public class Child : Person{
public string Toys{get;set;}
}
public class Grandparent : Person{
public string Cars{get;set;}
}
In the api method I was thinking to do something like:
public void Save(Family model)
{
// to parse extraData my idea was to
switch(mode.Type)
{
case 0: var childrens = JsonConvert.DeserializeObject<ExtraData<Child>>(model.ExtraData);
// do stuff
break;
case 1: var grandparents = JsonConvert.DeserializeObject<ExtraData<Child>>(model.ExtraData);
// do stuff
break;
}
// save the object
}
The issue is that on the api call I get nothing in the extraData string. And I can't put in Family something like
public ExtraData<Person> Persons {get;set;}
because it will deserialize to the base type and I will lose the subclass information.
I know is to do something like json stringify but I would like this to be my last resort. Also i have tried to use dynamic instead of Family but I still need to deserialze it and having same issue.
What is the best approach here?

Order of properties get messed up when serialized by JSON.NET

In my POCO objects, I often inherit from other POCO objects. When I serialize a POCO object using JSON.NET, the order of properties gets all messed up.
Say, I have a Person class that looks like this:
public class Person
{
public int Id {get; set;}
public string FirstName {get; set;}
public string LastName {get; set;}
}
Then I have an Employee class that inherits from Person class:
public class Employee : Person
{
public int DepartmentId {get; set;}
public string Title {get; set;}
}
When I serialize the Employee class, my JSON object looks like this:
{
"departmentId": 123,
"title": "Manager",
"id": 1234567,
"firstName": "John",
"lastName": "Smith"
}
Two questions:
Does the order of my JSON object properties matter?
Even if the order of properties doesn't matter, how can I get the properties to be in correct order i.e. I'd like to see the Person class properties first, then the Employee class properties.
Thank you for your help.

1.) No, order doesn't matter.
2.) You can use the [JsonProperty(Order=x)] attribute to control the order:
public class Employee : Person
{
[JsonProperty(Order = 1)]
public int DepartmentId { get; set; }
[JsonProperty(Order = 1)]
public string Title { get; set; }
}
From a quick test, order defaults to 0, is sorted from low to high, and properties with the same value of Order are sorted in an arbitrary order.

Actually, since my Object was already a JObject, I Had to use the following solution:
public class SortedJObject : JObject
{
public SortedJObject(JObject other)
{
var pairs = new List<KeyValuePair<string, JToken>>();
foreach (var pair in other)
{
pairs.Add(pair);
}
pairs.OrderBy(p => p.Key).ForEach(pair => this[pair.Key] = pair.Value);
}
}
and then use it like this:
string serializedObj = JsonConvert.SerializeObject(new SortedJObject(dataObject));

deserializing child data collections into ienumerables using JSON.NET

Current I have a project where I'm getting the following sample data ( I want to retrieve only the ids within this json string and stuff them into IEnumerables (explained below):
{
"states": [
{
"id": "AL",
"text": "Alabama (AL)"
},
{
"id": "CO",
"text": "Colorado (CO)"
}
],
"cities": [
{
"id": 71761,
"text": "New Brockton, AL"
},
{
"id": 74988,
"text": "Nathrop, CO"
}
],
"zipCodes": []
}
Notice in the zipCodes, I am getting an empty set, so there is no "id" or "text".
I want to be able to create several IEnumerables from the properties found in this JSON string.
I created an object called Locations that looks like this:
public class Location
{
public IEnumerable<string> States { get; set; }
public IEnumerable<string> ZipCodes { get; set; }
public IEnumerable<decimal> Cities { get; set; }
}
The best way I found to going about this approach is to do each data property one by one and convert, formValues is the json string:
JArray arrStates = (JArray)formValues["states"];
JArray arrCities = (JArray)formValues["cities"];
JArray arrZip = (JArray)formValues["zipCodes"];
and then set the properties in the location object as so:
Location loc = new Location();
loc.States = arrStates.Children().Select(m=>m["id"].Value<string>());
loc.ZipCodes = arrCities.Children().Select(m=>m["id"].Value<string>());
loc.Cities = arrZip.Children().Select(m=>m["id"].Value<string>());
I was wondering if there's a better way of doing this instead of doing all this code maintenance for whenever my json response adds a new property. In fact, I think there's going to be about ten more properties added to the json string.
I want it to be reduced down to where I could just update the Location object, and have the json automatically map to the properties that way. Or atleast a solution that has less maintenance than what I'm doing now.
Also I was wondering if JsonConvert.DeserializeObject would work in my case; but read that JSON.NET treats an IEnumerable as an array, so I'm stumped on this one.

JsonConvert.DeserializeObject would work in your case and it will have less maintenance than what you're doing now.
If you enter your json data to http://json2csharp.com, below is the generated class definition that you can use, I renamed RootObject to Location
public class State
{
public string id { get; set; }
public string text { get; set; }
}
public class City
{
public int id { get; set; }
public string text { get; set; }
}
public class Location
{
public List<State> states { get; set; }
public List<City> cities { get; set; }
public List<object> zipCodes { get; set; }
}
This is how you deserialize the json data into Location
string jsonData = ...; // set the json data here
var location = JsonConvert.DeserializeObject<Location>(jsonData);
You can enumerate through the nested properties to get the ids, for example location.states[0].id will return "AL" and location.cities[1].id will return 74988.
If there's a new property in the json data, let's say it's named countries with id and text like in states, you can create a new Country class
public class Country
{
public string id { get; set; }
public string text { get; set; }
}
and add countries property to Location class
public class Location
{
public List<State> states { get; set; }
public List<City> cities { get; set; }
public List<object> zipCodes { get; set; }
public List<Country> countries { get; set; }
}