La désérialisation tableau JSON dans fortement typé .NET objet

Quand je peux appeler la 3ème partie de l'api et de revenir à une seule catégorie de données tout deserialises fine à l'aide de ce code

TheUser me = jsonSerializer.Deserialize(response, typeof(TheUser)) as TheUser

Le problème vient quand je l'ai essayer et deserialise JSON contenu de la réponse qui est un tableau, comme

{
   "data": [
      {
         "name": "A Jones",
         "id": "500015763"
      },
      {
         "name": "B Smith",
         "id": "504986213"
      },
      {
         "name": "C Brown",
         "id": "509034361"
      }
   ]
}

Je ne peux obtenir la sérialisation de travail si j'utilise un emballage sur mesure de classe autour de la "data" du membre et membre doit être de type List<object>. Si il ont comme type de List<TheUser> - je obtenir ArgumentException de la JsonParser DesializeType méthode.

J'ai d'abord essayé de serialise sans un type d'emballage comme ce

List<TheUser> freinds = jsonSerializer.Deserialize(response, typeof(List<TheUser>)) as List<TheUser>;

mais qui ne renvoie-moi un vide de la collection. Certes, je doit être en mesure d'avoir le tableau de désérialiser à une fortement typé liste.

J'ai le même problème; si vous désérialisez response dans un dynamic var au lieu de TheUser, puis deserialized.data est disponible en JArray -- aucune idée si vous pouvez les convertir en List<something>?
Semble que vous devriez être en mesure de (lien).

InformationsquelleAutor Pat Long - Munkii Yebee | 2011-05-12

c#hammock json.net windows-phone-7

30

Afer regardant la source, pour WP7 Hamac ne fait pas les utiliser Json.Net pour JSON de l'analyse. Au lieu de cela, il utilise son propre analyseur qui ne supporte pas le type personnalisé est très bien.

Si vous utilisez Json.Net directement, il est possible de désérialiser à un typage fort de la collection à l'intérieur d'un objet wrapper.
```
var response = @"
    {
        ""data"": [
            {
                ""name"": ""A Jones"",
                ""id"": ""500015763""
            },
            {
                ""name"": ""B Smith"",
                ""id"": ""504986213""
            },
            {
                ""name"": ""C Brown"",
                ""id"": ""509034361""
            }
        ]
    }
";

var des = (MyClass)Newtonsoft.Json.JsonConvert.DeserializeObject(response, typeof(MyClass));

return des.data.Count.ToString();
```
et avec:
```
public class MyClass
{
    public List<User> data { get; set; }
}

public class User
{
    public string name { get; set; }
    public string id { get; set; }
}
```
Avoir à créer l'objet supplémentaire avec les données de la propriété est ennuyeux, mais c'est une conséquence de la manière dont le format JSON objet est construit.

Documentation: La sérialisation et la Désérialisation JSON
- Il est très facile de changer DeSerializer dans un Hamac. Créer une classe qui implémente l'Hamac.La sérialisation.IDeserializer interface. Et puis définissez la classe que votre Deserializer sur le RestClient.
- Je suis d'accord que c'est un peu ennuyeux, d'ajouter un petit objet, d'où ma solution ci-dessous. Mon approche obtient également autour de vous avoir à le cas, comme vous êtes dans le var, des = (Maclasse)... ligne. Vous ne savez pas si ceci ou ma solution est meilleure que l'autre, tout simplement préfèrent ne pas avoir à ajouter des Données supplémentaires de l'objet et de manière générale, j'essaie d'éviter de conversion de type.
- Combien faut-il d'abord faire un Json.Parse(jsonString) et puis faire un JsonConvert.DeserializeObject(parsedJson["data"]).ToString()) pour enfin obtenir une liste de User, la performance et la santé mentale sage? 😉
InformationsquelleAutor Matt Lacey
11

essayer
```
List<TheUser> friends = jsonSerializer.Deserialize<List<TheUser>>(response);
```
- Qui ne compile pas, cependant, n'est-ce pas juste un différent d'appeler le style qui est le résultat de la même sous-jacent mthods être appelé de la même manière? Je ne vois pas comment cela va obtenir autour de mon problème
- Cela a fonctionné pour moi: List<TheUser> friends = JsonConvert.DeserializeObject<List<TheUser>>(response);
- Merci! Cela m'a permis de désérialiser un tableau d'objets, sans les emballer dans un objet conteneur.
- J'aime Homère solution, je suis d'accord c'est un peu plus propre que ma solution car il élimine la nécessité d'avoir une classe parent ou d'avoir à mettre en œuvre une interface si vous ne voulez pas hériter de quoi que ce soit. -Eric
InformationsquelleAutor Frank

Cette solution semble fonctionner pour moi et se déplace avoir à coder un tas de classes avec des "Data" dans les.

public interface IDataResponse<T> where T : class
{
    List<T> Data { get; set; }
}

public class DataResponse<T> : IDataResponse<T> where T : class
{
   [JsonProperty("data")]
   public List<T> Data { get; set; }
}

Je devrais avoir inclus ce, pour commencer, voici un exemple à l'aide de la méthode ci-dessus:

public List<TheUser> GetUser()
{
    var results = GetUserJson();
    var userList = JsonConvert.DeserializeObject<DataResponse<TheUser>>(results.ToString());

    return userList.Data.ToList();
}

InformationsquelleAutor Erick Brown

7

Cela a fonctionné pour moi pour la désérialisation JSON en un tableau d'objets:
```
List<TheUser> friends = JsonConvert.DeserializeObject<List<TheUser>>(response);
```
InformationsquelleAutor Homer
7

Json.NET - Documentation

http://james.newtonking.com/json/help/index.html?topic=html/SelectToken.htm

Interprétation de l'auteur
```
var o = JObject.Parse(response);
var a = o.SelectToken("data").Select(jt => jt.ToObject<TheUser>()).ToList();
```
InformationsquelleAutor bobah75
2

Pat, la structure json semble très familier à un problème que j'ai décrit ici - La réponse pour moi était de traiter la représentation json comme un Dictionnaire<TKey, TValue>, même si il y avait seulement 1 entrée.

Si je suis correct de votre clé est de type chaîne de caractères et la valeur d'une Liste<T> où T représente la classe 'Utilisateur'

HTH

PS - si vous souhaitez mieux la sérialisation perf découvrez à l'aide de Silverlight Sérialiseur, vous aurez besoin de construire une version WP7, Shameless plug - j'ai écrit un billet de blog sur cette

InformationsquelleAutor AwkwardCoder
0

Je soupçonne que le problème est que le json représente un objet avec la liste des utilisateurs en tant que bien. Essayez de la désérialisation à quelque chose comme:
```
public class UsersResponse
{
    public List<User> Data { get; set; }
}
```
InformationsquelleAutor Nigel Sampson

Vous devez vous connecter pour publier un commentaire.