Categories
arrays c# json json.net serialization

Cannot deserialize the JSON array (e.g. [1,2,3]) into type ‘ ‘ because type requires JSON object (e.g. {“name”:”value”}) to deserialize correctly

148

I have this JSON:

[
    {
        "Attributes": [
            {
                "Key": "Name",
                "Value": {
                    "Value": "Acc 1",
                    "Values": [
                        "Acc 1"
                    ]
                }
            },
            {
                "Key": "Id",
                "Value": {
                    "Value": "1",
                    "Values": [
                        "1"
                    ]
                }
            }
        ],
        "Name": "account",
        "Id": "1"
    },
    {
        "Attributes": [
            {
                "Key": "Name",
                "Value": {
                    "Value": "Acc 2",
                    "Values": [
                        "Acc 2"
                    ]
                }
            },
            {
                "Key": "Id",
                "Value": {
                    "Value": "2",
                    "Values": [
                        "2"
                    ]
                }
            }
        ],
        "Name": "account",
        "Id": "2"
    },
    {
        "Attributes": [
            {
                "Key": "Name",
                "Value": {
                    "Value": "Acc 3",
                    "Values": [
                        "Acc 3"
                    ]
                }
            },
            {
                "Key": "Id",
                "Value": {
                    "Value": "3",
                    "Values": [
                        "3"
                    ]
                }
            }
        ],
        "Name": "account",
        "Id": "2"
    }
]

And I have these classes:

public class RetrieveMultipleResponse
{
    public List<Attribute> Attributes { get; set; }
    public string Name { get; set; }
    public string Id { get; set; }
}

public class Value
{
    [JsonProperty("Value")]
    public string value { get; set; }
    public List<string> Values { get; set; }
}

public class Attribute
{
    public string Key { get; set; }
    public Value Value { get; set; }
}

I am trying to deserialize the above JSON using the code below:

var objResponse1 = JsonConvert.DeserializeObject<RetrieveMultipleResponse>(JsonStr);

but I am getting this error:

Cannot deserialize the current JSON array (e.g. [1,2,3]) into type
‘test.Model.RetrieveMultipleResponse’ because the type requires a JSON
object (e.g. {“name”:”value”}) to deserialize correctly. To fix this
error either change the JSON to a JSON object (e.g. {“name”:”value”})
or change the deserialized type to an array or a type that implements
a collection interface (e.g. ICollection, IList) like List that can
be deserialized from a JSON array. JsonArrayAttribute can also be
added to the type to force it to deserialize from a JSON array. Path
”, line 1, position 1.

    235

    Your json string is wrapped within square brackets ([]), hence it is interpreted as array instead of single RetrieveMultipleResponse object. Therefore, you need to deserialize it to type collection of RetrieveMultipleResponse, for example :

    var objResponse1 = 
        JsonConvert.DeserializeObject<List<RetrieveMultipleResponse>>(JsonStr);
    

    8

    • I had to remove “//” befor “[“, then it worked for me. thanks

      – garish

      Aug 10, 2017 at 13:49

    • 2

      If you wanted to keep it as a single object instead of a collection, could you just do JsonStr.Replace(“[“,””).Replace(“]”,””) or would this not be good practice?

      – Rich

      Apr 13, 2018 at 18:34

    • 3

      FYI this didn’t work for me because I was getting my JSON from an API and I had the freaking URL wrong for an entire day. ><

      – w00ngy

      Oct 5, 2018 at 13:14

    • 2

      What is RetrieveMultipleResponse here?

      Dec 26, 2018 at 21:50

    • Thanks this worked for me var objResponse1 = JsonConvert.DeserializeObject<List<QuestionData>>(srt); // myWord = myQuestionData.Word; Debug.Log(“myWord” + objResponse1[0].Word);

      Jul 6, 2019 at 11:55

    17

    If one wants to support Generics (in an extension method) this is the pattern…

    public  static List<T> Deserialize<T>(this string SerializedJSONString)
    {
        var stuff = JsonConvert.DeserializeObject<List<T>>(SerializedJSONString);
        return stuff;
    }
    

    It is used like this:

    var rc = new MyHttpClient(URL);
    //This response is the JSON Array (see posts above)
    var response = rc.SendRequest();
    var data = response.Deserialize<MyClassType>();
    

    MyClassType looks like this (must match name value pairs of JSON array)

    [JsonObject(MemberSerialization = MemberSerialization.OptIn)]
     public class MyClassType
     {
        [JsonProperty(PropertyName = "Id")]
        public string Id { get; set; }
    
        [JsonProperty(PropertyName = "Name")]
        public string Name { get; set; }
    
        [JsonProperty(PropertyName = "Description")]
        public string Description { get; set; }
    
        [JsonProperty(PropertyName = "Manager")]
        public string Manager { get; set; }
    
        [JsonProperty(PropertyName = "LastUpdate")]
        public DateTime LastUpdate { get; set; }
     }
    

    Use NUGET to download Newtonsoft.Json add a reference where needed…

    using Newtonsoft.Json;
    

      6

      Can’t add a comment to the solution but that didn’t work for me. The solution that worked for me was to use:

      var des = (MyClass)Newtonsoft.Json.JsonConvert.DeserializeObject(response, typeof(MyClass)); 
      return des.data.Count.ToString();
      

      Deserializing JSON array into strongly typed .NET object

      0