Librairie NewtonSoft pour manipuler les JSON

En C# vous disposez d’une très puissante librairie pour manipuler les chaines et objets JSON. Pour utiliser cette librairie, aidez vous de Nuget pour la télécharger dans votre projet.

Certes .Net possède des méthode pour manipuler les JSON, mais ce n’est pas très pratique. Il est vivement conseillé d’utiliser NewtonSoft.

Cette librairie sert à convertir une chaine JSON en un objet C# s’il existe une classe équivalente. On l’utilise principalement pour lire les informations d’une chaîne JSON.

Nous allons voir comment transformer une chaîne JSON en un objet C# manipulable facilement, comment extraire un tableau d’objets JSON, la  librairie LINQtoJSON permet de traverser un objet construit à partir d’une chaine JSON.

Nous allons partir d’une chaine JSON assez représentative de ce qu’on peut trouver dans la vraie vie, voici ci-dessous une chaine JSON extrait de Mailchimp.

Il existe un outil en ligne qui permet de visualiser le JSON sérialisé, sous forme hiérarchique, très utile pour vous aider à voir plus clair dans une chaine JSON que vous ne connaissez pas => Online JSON Viewer.

Obtenir la librairie NewtonSoft avec Nuget dans Visual Studio

Clickez avec le bouton droit de la souris sur le projet, « Gérer les packages Nuget », tapez le nom « Newtonsoft », et installez. Normalement dans le projet courant une référence à cette librairie est faite.

Obtenir une chaîne JSON (Mailchimp dans notre cas)

Mailchimp a sans doute l’un des services web REST les plus plus facile à utiliser. Avec lui pas besoin d’authentification Oauth2, il suffit d’obtenir une clé secrète (à ne pas dévoiler ! donc exit les usages avec du Javascript côté client).

Vous pouvez télécharger le fichier JSON échantillon pour faire des tests.

Copiez le contenu et allez sur le site Online JSON Viewer et visualisez le contenu de la chaine.

Une fois l’arbre reconstitué, vous pouvez naviguer dans le contenu. On voit un tableau de JSON « lists ».

On continue à inspecter le contenu, nous pouvons voir la structure qui s’affiche clairement, les éléments de ce tableau sont des JSON, en langage C# ce sont des IEnumerable, dont les objets pourront être appelé List. Mais comme en C# List est déjà existant, ici on va plutôt appeler MailChimpList. Cette MailchimpList contient des propriétés dont certaines sont des objets (Contact, CampaignDefault,Modules,Stats, Links).

Bonus : en C# tout est typé, donc il y a des classes pour tout. Dans le cas de Mailchimp, vous recevez le JSON mais ce serait bien de convertir ça en objet, le problème c’est que bien que vous connaissiez la structure du JSON qui vous permettra de créer vos classes, c’est super fastidieux, il existe un site (et sans doute des librairies) qui transforme votre JSON sérialisé en objet C# !

Voici le site qui permet les conversions en ligne :  http://json2csharp.com/

Créer des définitions de classe à partir des chaînes JSON

Objectif : créer une définition de classes pour pouvoir convertir la chaine JSON en objet C# afin de travailler dans le monde de la programmation orientée objet. En effet notre objet MailchimpList pourrait être comme ci-dessous :

MailchimpList{

    Contact contact {get;set;}
    CampaignDefaults campaignDefault {get;set;}
    List<Modules> listModules {get;set;}
    Stats stats {get;set;}  
    List<Link> listLinks {get;set;} 

}

Donc ce qu’il faut faire c’est copier coller un élément de la liste « lists » et non les 6 éléments, et coller dans l’interface du site de conversion.

 

Et voilà magique non? C’est quand j’étais à deux doigts de coder à la main les classes que je me suis mis à chercher une solution qui le ferai pour moi sans efforts. L’image ci-dessus n’est qu’un extrait pour vous montrer.

Parsons la chaîne JSON avec les méthodes de la librairie NewtonSoft

La librairie est riche en méthodes, et l’on peut se perdre facilement, car il y a plusieurs façons de faire les choses, mais essayons de lister des méthodes courantes méthodiquement pour ne pas perdre de temps à chercher.

Dans la première image on voit dans le JSON qu’il peut y avoir deux type de choses : un tableau de JSON, des propriétés.

Conversion de base en JObject

La méthode la plus générique, convertir n’importe quel JSON en JObject. C’est à dire que quelque soit le contenu du JSON (propriété + tableau), ça marche.

JObject o = JObject.Parse(jsonString);

jsonString est une chaîne de caractère qui contient

Désérialisation partielle (partial deserialization)

Très pratique, imaginons que vous ayez un gros objet JSON, amis qu’il n’y a qu’un partie de cet objet JSON qui vous intéresse, grâce à JSONtoLINQ, vous pourrez accéder à une propriété de cet objet JSON et le parser, vous évitant ainsi d’écrire des classes inutilement.

JObject o = JObject.Parse(jsonString)
List<JToken> list = o["lists"].Children().ToList();

Ici on accède à une propriété particulière du JObject, prenons les élément du tableau et on les transforme en List, via la notation Linq.

Sérialiser un JSON

La sérialisation est le contraire de la désérialisation, elle consiste à transformer un objet en une chaine de caractères afin de pouvoir la transporter ou la stocker. En général, des guillemets sont ajoutés.

Product product = new Product();

product.Name = "Apple";
product.ExpiryDate = new DateTime(2008, 12, 28);
product.Price = 3.99M;
product.Sizes = new string[] { "Small", "Medium", "Large" };

string output = JsonConvert.SerializeObject(product);

//{
//  "Name": "Apple",
//  "ExpiryDate": "2008-12-28T00:00:00",
//  "Price": 3.99,
//  "Sizes": [
//    "Small",
//    "Medium",
//    "Large"
//  ]
//}

 

Convertir un JSON Array en « IEnumerable » avec JArray

Pratique lorsque qu’une propriété du JSON est un tableau et que l’on souhaite extraire tous les éléments du tableau.

Si vous disposez d’un tableau de JSON, vous pouvez le transformer en JArray en une seule commande

string json = @"['Small','Medium','Large']";
JArray a = JArray.Parse(json);
var z = a.First().GetType();
Console.WriteLine(a.ToString());
// [
//   "Small",
//   "Medium",
//   "Large"
// ]

SI vous survolez la variable z, vous aurez le type d’un élément du tableau, qui est un JToken.

Last thing : JProperty

JProperty représente une propriété d’un objet JSON.

En notation JSON on met les clé:valeur de cette façon :

{
   nom:"Dupont",
   prenom:"Yves",
   age:34,
   voiture:[{marque:"alfa Romeo",modele:"Giulietta"},{marque:"BMW",model:"Z4"}],
   hobby:["sport","informatique"]
}

La propriété nom a pour valeur « Dupont ». La méthode Properties() permet d’extraire les propriétés, utile si vous voulez sélectionner une en particulier ou tester la présence d’une propriété.

foreach (JProperty property in o.Properties())
{
    Console.WriteLine(property.Name + ":" + property.Value);
}

// sortie console

nom:Dupont
prenom:Yves
age:34
voiture:[
 {
 "marque": "alfa Romeo",
 "modele": "Giulietta"
 },
 {
 "marque": "BMW",
 "model": "Z4"
 }
]

 

JToken, JObject, JArray ?

JToken est une classe abstraite qui sert de base  aux classes JObject, JArray, JProperty et JValue qui sont des données.

Caster un JObject en un objet C#

La partie la plus intéressante ! Enfin nous allons convertir en objet C# la chaine JSON. Pour ce faire on va utiliser JSONConvert.

#j est un objet de type JToken


JObject o = JObject.Parse(Jsonstring);
List<JToken> list = o["lists"].Children().ToList();

List<MCList> mcList = new List<MCList>();

foreach(JToken j in lists){
        mcList.Add(JsonConvert.DeserializeObject(j.ToString()));
    }

En plaçant un espion, nous pouvons voir le résultat de la conversion et le résultat est étonnant :

Pour un conversion fortement typée, il se peut que le snippet ci-dessus ne marche pas, or ce lien explique qu’il faut la syntaxe suivante :

JObject o = JObject.Parse(Jsonstring); 
List<JToken> list = o["lists"].Children().ToList(); 
List<MCList> mcList = new List<MCList>(); 
foreach(JToken j in lists){     
    mcList.Add(JsonConvert.DeserializeObject<MCList>(j.ToString()));
}

 

La conversion est parfaite ! Nous retrouvons toutes les valeurs de la chaines JSON, la fonction de desérialisation est vraiment puissante ! nous pouvons travailler dans notre univers C# comme si de rien n’était.