Nie można deserializować tablicy JSON (np. [1,2,3]) do typu „”, ponieważ typ wymaga obiektu JSON (np. {„Name”: „value”}) do prawidłowego deserializacji

Mam ten 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"
    }
]

Mam te zajęcia:

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; }
}

Próbuję deserializować powyższy kod JSON za pomocą poniższego kodu:

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

ale otrzymuję ten błąd:

Nie można deserializować bieżącej tablicy JSON (np. [1,2,3]) do typu „test.Model.RetrieveMultipleResponse”, ponieważ typ ten wymaga obiektu JSON (np. {"Name": "value"}) do poprawnej deserializacji. Aby naprawić ten błąd, zmień JSON na obiekt JSON (np. {"Name": "value"}) lub zmień typ deserializowany na tablicę lub typ implementujący interfejs kolekcji (np. ICollection, IList), taki jak List, który może być deserializowane z tablicy JSON. JsonArrayAttribute można również dodać do typu, aby wymusić deserializację z tablicy JSON. Path '', wiersz 1, pozycja 1.

Twój ciąg json jest zawijany w nawiasy kwadratowe ( []), dlatego jest interpretowany jako tablica zamiast pojedynczego RetrieveMultipleResponseobiektu. Dlatego musisz deserializować go, aby wpisać kolekcję RetrieveMultipleResponse, na przykład:

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

Jeśli ktoś chce obsługiwać Generics (w metodzie rozszerzenia), to jest wzorzec ...

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

Jest używany w następujący sposób:

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

MyClassType wygląda następująco (musi pasować do par nazwa-wartość w tablicy JSON)

[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; }
 }

Użyj NUGET, aby pobrać Newtonsoft.Json, dodaj odniesienie w razie potrzeby ...

using Newtonsoft.Json;

Nie mogę dodać komentarza do rozwiązania, ale to nie zadziałało. Rozwiązaniem, które działało u mnie, było użycie:

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

Deserializacja tablicy JSON do obiektu .NET o jednoznacznie określonym typie

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

zadziałało!

Użyj tego, FrontDatato ciąg JSON:

var objResponse1 = JsonConvert.DeserializeObject<List<DataTransfer>>(FrontData);  

i wypakuj listę:

var a = objResponse1[0];
var b = a.CustomerData;