Using JsonConvert.DeserializeObject to deserialize Json to a C# POCO class

Question

Here is my simple User POCO class:

/// <summary>
/// The User class represents a Coderwall User.
/// </summary>
public class User
{
    /// <summary>
    /// A User's username. eg: "sergiotapia, mrkibbles, matumbo"
    /// </summary>
    public string Username { get; set; }

    /// <summary>
    /// A User's name. eg: "Sergio Tapia, John Cosack, Lucy McMillan"
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// A User's location. eh: "Bolivia, USA, France, Italy"
    /// </summary>
    public string Location { get; set; }

    public int Endorsements { get; set; } //Todo.
    public string Team { get; set; } //Todo.

    /// <summary>
    /// A collection of the User's linked accounts.
    /// </summary>
    public List<Account> Accounts { get; set; }

    /// <summary>
    /// A collection of the User's awarded badges.
    /// </summary>
    public List<Badge> Badges { get; set; }

}

And the method I'm using to deserialize a JSON response into a User object (this actual JSON call is here):

private User LoadUserFromJson(string response)
{
    var outObject = JsonConvert.DeserializeObject<User>(response);
    return outObject;
}

This fires an exception:

Cannot deserialize the current JSON object (e.g. {"name":"value"}) into type 'System.Collections.Generic.List`1[CoderwallDotNet.Api.Models.Account]' 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. Path 'accounts.github', line 1, position 129.

Having never worked with this DeserializeObject method before, I'm kind of stuck here.

I've made sure that the property names in the POCO class are the same as the names in the JSON response.

What can I try to deserialize JSON into this POCO class?

Seems that I am late, but see my answer. using `JsonProperty` is much easier(and readable) than to write `JsonConverter` — L.B, Jun 20 '12 at 20:17
You are probably looking at something like this then. http://stackoverflow.com/questions/25672338/dynamically-deserialize-json-into-any-object-passed-in-c-sharp — Jim, Mar 27 '17 at 19:19

score 129 · Accepted Answer · answered Jun 20 '12 at 20:12

Here is a working example.

Keypoints are:

Declaration of Accounts
Use of JsonProperty attribute

.

using (WebClient wc = new WebClient())
{
    var json = wc.DownloadString("http://coderwall.com/mdeiters.json");
    var user = JsonConvert.DeserializeObject<User>(json);
}

-

public class User
{
    /// <summary>
    /// A User's username. eg: "sergiotapia, mrkibbles, matumbo"
    /// </summary>
    [JsonProperty("username")]
    public string Username { get; set; }

    /// <summary>
    /// A User's name. eg: "Sergio Tapia, John Cosack, Lucy McMillan"
    /// </summary>
    [JsonProperty("name")]
    public string Name { get; set; }

    /// <summary>
    /// A User's location. eh: "Bolivia, USA, France, Italy"
    /// </summary>
    [JsonProperty("location")]
    public string Location { get; set; }

    [JsonProperty("endorsements")]
    public int Endorsements { get; set; } //Todo.

    [JsonProperty("team")]
    public string Team { get; set; } //Todo.

    /// <summary>
    /// A collection of the User's linked accounts.
    /// </summary>
    [JsonProperty("accounts")]
    public Account Accounts { get; set; }

    /// <summary>
    /// A collection of the User's awarded badges.
    /// </summary>
    [JsonProperty("badges")]
    public List<Badge> Badges { get; set; }
}

public class Account
{
    public string github;
}

public class Badge
{
    [JsonProperty("name")]
    public string Name;
    [JsonProperty("description")]
    public string Description;
    [JsonProperty("created")]
    public string Created;
    [JsonProperty("badge")]
    public string BadgeUrl;
}

That resulted in much, much cleaner code. I had already implemented a custom Serializer, but I like this approach better as it's leaner. Thanks again! — Only Bolivian Here, Jun 20 '12 at 20:29
Did you forget the List<> on Account, or am I missing something? It seems to me that the original question had Accounts as a list, but this solution has Accounts as a single Account object... not an array, not a list. — huntharo, Jul 21 '13 at 01:22
@huntharo Looks like the changed `Accounts` declaration -- from `List` to `Account` -- is because the example JSON (linked in the question) has an individual JSON object -- not an array -- for `accounts`: `"accounts": {"github": "sergiotapia"}` — Rick Haffey, Feb 06 '15 at 22:38
how is that a valid answer without any explanation? why should we use JsonProperty if name is the same. JsonProperty is used if returned object has name like badges instead of Badges. Making account not list is not a solution either. because accounts are supposed to be list but it throws exception some cases. — Emil, Jan 15 '18 at 22:30

score 9 · Answer 2 · answered Dec 19 '14 at 22:05

Another, and more streamlined, approach to deserializing a camel-cased JSON string to a pascal-cased POCO object is to use the CamelCasePropertyNamesContractResolver.

It's part of the Newtonsoft.Json.Serialization namespace. This approach assumes that the only difference between the JSON object and the POCO lies in the casing of the property names. If the property names are spelled differently, then you'll need to resort to using JsonProperty attributes to map property names.

using Newtonsoft.Json; 
using Newtonsoft.Json.Serialization;

. . .

private User LoadUserFromJson(string response) 
{
    JsonSerializerSettings serSettings = new JsonSerializerSettings();
    serSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
    User outObject = JsonConvert.DeserializeObject<User>(jsonValue, serSettings);

    return outObject; 
}

score 6 · Answer 3 · answered Jun 20 '12 at 18:59

The accounts property is defined like this:

"accounts":{"github":"sergiotapia"}

Your POCO states this:

public List<Account> Accounts { get; set; }

Try using this Json:

"accounts":[{"github":"sergiotapia"}]

An array of items (which is going to be mapped to the list) is always enclosed in square brackets.

Edit: The Account Poco will be something like this:

class Account {
    public string github { get; set; }
}

and maybe other properties.

Edit 2: To not have an array use the property as follows:

public Account Accounts { get; set; }

with something like the sample class I've posted in the first edit.

Just define the property not as a list. I'm editing my answer (Edit2) — Sascha, Jun 20 '12 at 19:01

score 6 · Answer 4 · edited May 23 '17 at 12:34

6

You could create a JsonConverter. See here for an example thats similar to your question.

edited May 23 '17 at 12:34

Community

1
1

answered Jun 20 '12 at 19:07

SwDevMan81

48,814
22
151
184

**Exactly** what I was hoping existed. I'll definitely take a look at this. Thank you! – Only Bolivian Here Jun 20 '12 at 19:11

score 5 · Answer 5 · edited May 23 '17 at 11:47

5

Along the lines of the accepted answer, if you have a JSON text sample you can plug it in to this converter, select your options and generate the C# code.

If you don't know the type at runtime, this topic looks like it would fit.

dynamically deserialize json into any object passed in. c#

edited May 23 '17 at 11:47

Community

1
1

answered Feb 27 '17 at 23:24

Jim

692
7
15

2

Update July 2021 - the converter is still present on the web and works well. – Vanquished Wombat Jul 13 '21 at 06:45

dmi_ · Answer 6 · 2012-06-20T19:09:03.783

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.`

The whole message indicates that it is possible to serialize to a List object, but the input must be a JSON list. This means that your JSON must contain

"accounts" : [{<AccountObjectData}, {<AccountObjectData>}...],

Where AccountObject data is JSON representing your Account object or your Badge object

What it seems to be getting currently is

"accounts":{"github":"sergiotapia"}

Where accounts is a JSON object (denoted by curly braces), not an array of JSON objects (arrays are denoted by brackets), which is what you want. Try

"accounts" : [{"github":"sergiotapia"}]

Oops, editing now edit: Done. Sorry for not noticing that; skimming is not always optimal ;P — dmi_, Jun 20 '12 at 19:05

Latency · Answer 7 · 2015-02-26T18:41:48.913

That's not exactly what I had in mind. What do you do if you have a generic type to only be known at runtime?

public MyDTO toObject() {
  try {
    var methodInfo = MethodBase.GetCurrentMethod();
    if (methodInfo.DeclaringType != null) {
      var fullName = methodInfo.DeclaringType.FullName + "." + this.dtoName;
      Type type = Type.GetType(fullName);
      if (type != null) {
        var obj = JsonConvert.DeserializeObject(payload);
      //var obj = JsonConvert.DeserializeObject<type.MemberType.GetType()>(payload);  // <--- type ?????
          ...
      }
    }

    // Example for java..   Convert this to C#
    return JSONUtil.fromJSON(payload, Class.forName(dtoName, false, getClass().getClassLoader()));
  } catch (Exception ex) {
    throw new ReflectInsightException(MethodBase.GetCurrentMethod().Name, ex);
  }
}

score 0 · Answer 8 · answered Nov 11 '21 at 22:58

0

May be late but using QuickType is the easiest way to do that:

https://app.quicktype.io/

answered Nov 11 '21 at 22:58

waleedhasan

1

1

Your answer could be improved with additional supporting information. Please [edit] to add further details, such as citations or documentation, so that others can confirm that your answer is correct. You can find more information on how to write good answers [in the help center](/help/how-to-answer). – Community Nov 12 '21 at 06:55

score 0 · Answer 9 · answered Nov 23 '21 at 22:31

For anyone having this problem i was not seeing the json value properly. https://jsonutils.com/ there you can check the classes that should be generated and return ONLY ONE of those classes once you read the json in your code.

For example i needed a booklist object so my code should only read one

res = await response.Content.ReadAsAsync<BookList>();

Where booklist looks something like

    public class BookList
    {

        [JsonProperty("data")]
        public IList<Datum> Data { get; set; }
     }

And in that list have smaller book clasess that the converter named Datum (just books)

    public class Datum
    {

        [JsonProperty("id")]
        public string Id { get; set; }

        [JsonProperty("isbn")]
        public string Isbn { get; set; }
    }

Again, if you have doubts https://jsonutils.com/

Using JsonConvert.DeserializeObject to deserialize Json to a C# POCO class

9 Answers9

Linked

Related