Newtonsoft Json Sérialiseur/Deserializer - comment faire pour utiliser des objets génériques au lieu de JObject?

J'ai JSON spécifié par un service restful je suis de consommation qui ressemble à ceci (exemple):

{
  "id": "97",
  "name": "Tom Production",
  "description": null,
  "parameters": [
    {
      "first_parameter_name": "First Parameter Value"
    },
    {
      "second_parameter_name": "Second Parameter Value"
    }
  ]
}

Noter que les noms de propriété id, nom, description et les paramètres sont tous établis dans le cadre de la spécification. La collection de paramètres génériques, montré dans mon exemple "first_parameter_name" et "second_parameter_name" ne sont pas spécifiés.... pourrait être n'importe quoi et je tiens à les cartographier de façon générique les objets de type.

Je l'ai déclaré à un objet pour ce qu':

[DataContract (Name = "MyClass")]
public class MyClass
{
    [DataMember (Name = "id")]
    public string Id { get; set; }

    [DataMember(Name = "name")]
    public string Name { get; set; }

    [DataMember(Name = "description")]
    public string Description { get; set; }

    [DataMember(Name = "parameters")]
    public List<object> Parameters { get; set; }
}

Sérialisation fonctionne très bien, exactement comme je m'attends à:

        var myObject = new MyClass();
        myObject.Id = "97";
        myObject.Name = "Tom Production";
        myObject.Parameters = new List<object>();
        myObject.Parameters.Add(new { first_parameter_name = "First Parameter Value" });
        myObject.Parameters.Add(new { second_parameter_name = "Second Parameter Value" });
        string json = JsonConvert.SerializeObject(myObject);
        Console.WriteLine(json);

les rendements du JSON, je suis à la recherche d', exactement comme en haut de cette page.

CEPENDANT.

Désérialisation ne fonctionne PAS bien. Si ça a marché, j'espère qu'il, serait de créer des types génériques comme j'avais créé, et le code suivant devrait fonctionner.... mais au lieu de cela, il lance une réflexion exception:

        var myNewObject = JsonConvert.DeserializeObject<MyClass>(json);

        foreach (object o in myNewObject.Parameters)
        {
            Type t = o.GetType();
            Console.WriteLine("\tType is {0}", t);
            foreach (PropertyInfo pi in t.GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                Console.WriteLine("\t\tName is {0}", pi.Name);
                Console.WriteLine("\t\tValue is {0}", pi.GetValue(o, null));
            }
        }

Au lieu de cela, je dois écrire le code qui est Newtonsoft spécifiques (ick) à utiliser une sorte de faux Newtonsoft réflexion:

        var myNewObject = JsonConvert.DeserializeObject<MyClass>(json);

        foreach (object o in myNewObject.Parameters)
        {
            var jo = o as JObject;
            if (jo != null)
            {
                foreach (JProperty prop in jo.Properties())
                {
                    Console.WriteLine("\t\tName is {0}", prop.Name);
                    Console.WriteLine("\t\tValue is {0}", prop.Value);
                }
            }
        }

Est-il un moyen que je peux contrôler le Deserializer de sorte qu'il va générer le bon types génériques plutôt que la JObject type avec le JProperties?

Merci beaucoup à l'avance.

Anonyme types à la compilation des classes. Vous pouvez les créer dans votre code, car le compilateur met en place les classes concrètes pour vous dans les coulisses. Lorsque vous désérialisez, il n'est pas possible de re-créer les classes anonymes parce que les types sont dépendants du JSON, qui n'est connue qu'à l'exécution. C'est pourquoi Json.Net ne peut pas recréer les types anonymes. La solution est d'utiliser un List<Dictionary<string, string>> comme @Tim S. suggéré.
Si vous avez trouvé une solution à votre problème, puis après, comme une réponse à la question, non pas comme une modification à la question elle-même. Si la réponse est suffisante, alors il n'y a même pas besoin de le faire; il suffit de le laisser comme il est.

OriginalL'auteur Stephan G | 2015-01-09

c#json json.net serialization

10

JObjects carte plus directement à Dictionnaire<string, object>s, car ils sont tout simplement un ensemble de clés à des valeurs. Si vous savez que la valeur est toujours une string, vous pouvez en faire un Dictionary<string, string>.
```
[DataMember(Name = "parameters")]
public List<Dictionary<string, object>> Parameters { get; set; }

//or

[DataMember(Name = "parameters")]
public List<Dictionary<string, string>> Parameters { get; set; }

//e.g.
var myNewObject = JsonConvert.DeserializeObject<MyClass>(json);

foreach (var dict in myNewObject.Parameters)
{
    foreach (var pair in dict)
    {
        Console.WriteLine("\t\tKey is {0}", pair.Key);
        Console.WriteLine("\t\tValue is {0}", pair.Value);
    }
}
```
C'est peut-être une solution viable.... curieux de voir si quelqu'un a des idées sur la façon de l'obtenir à la façon de "je le veux vraiment", mais cela pourrait fonctionner. Seul problème, c'est que les Dictionnaires de cours ne permettent pas de double de clés, ce qui la spécification pourrait permettre, en théorie. Bien que maintenant que je suis en train de regarder votre code de plus près, je vois que c'est une liste de dictionnaires, de sorte que pourrait être bien. Ce serait bien si NameValueCollection serait de travailler.... mais je le soupçonne de ne pas.... Je peux essayer.
JSON n'autorise pas les doubles des clés, soit, donc, si ils ne comprennent doublons dans un délai d'un objet, ils sont en vous donnant une entrée non valide. Je suis sûr que ça ne marcherait pas out-of-the-box, mais je me attends à ce que, avec un convertisseur personnalisé vous pouvez remplacer le List<Dictionary<..>> avec un seul NameValueCollection, si cela sonne comme une meilleure option pour votre spécification de données.
Merci pour l'aide.

OriginalL'auteur Tim S.

Vous devez vous connecter pour publier un commentaire.