Code d'implémentation C# pour l'analyse des fichiers JSON

C# analysing json

JSON (nom complet : JavaScript Object Notation) est un format d'échange de données léger. Il est basé sur un sous-ensemble de la norme de syntaxe JavaScript. JSON est un format de texte totalement indépendant de la langue qui peut être facilement transféré sur divers réseaux, plates-formes et programmes. La syntaxe de JSON est très simple, facile à lire et à écrire pour les humains, et facile à analyser et à générer pour les machines.

Comparaison de JSON et XML

◆Lisibilité
En comparant la lisibilité de JSON et XML, XML fournit des balises auxiliaires et est plus adapté à la lecture et à la compréhension humaines.
◆Taille et transmission du fichier
XML permet l'utilisation de balises pratiques, de sorte que la taille du fichier est plus grande que JSON. De plus, JSON provient de Javascript, son principal champ de bataille naturel est donc Javascript et Internet. Ici, JSON présente des avantages que XML ne peut pas rattraper.

Syntaxe JSON

1. La syntaxe JSON est un sous-ensemble de la syntaxe de notation d'objet JavaScript.

• Les données sont sous forme de paires nom/valeur : les noms sont des chaînes, exprimées à l'aide de guillemets doubles. Les valeurs peuvent être : des nombres (entiers ou à virgule flottante), des chaînes (entre guillemets), des tableaux (entre crochets), des objets (entre accolades), vrai/faux/null.
• Les données sont séparées par des virgules :
• Les accolades contiennent des objets : les objets peuvent contenir diverses données, y compris des tableaux.
• Les crochets contiennent des tableaux : les nombres peuvent contenir des objets.

Par exemple :

{
    "employees": [
        {
            "firstName": "Bill",
            "lastName": "Gates"
        },
        {
            "firstName": "George",
            "lastName": "Bush"
        }
    ]
}

2. Si JSON contient des caractères d'échappement, ils doivent être échappés. Par exemple, vous devez utiliser "\" au lieu de "" dans le chemin du fichier. Par exemple : { "file": "C:\a.txt"}.

.NET exploite JSON

Lorsque les fichiers JSON sont lus en mémoire, ce sont des chaînes. NET exploite JSON en générant et en analysant des chaînes JSON. Il existe généralement les manières suivantes d'utiliser JSON :

1. Méthode originale : suivez le format de syntaxe JSON et écrivez du code pour exploiter directement la chaîne JSON. À moins que cela ne soit nécessaire, très peu de gens emprunteraient cette voie et tout recommencer.

2. Méthode générale [★★★★★] :

Cette méthode utilise la bibliothèque de classes open source Newtonsoft.Json (adresse de téléchargement http://json.codeplex.com/) . Après le téléchargement, vous pouvez l'utiliser en l'ajoutant au projet. Habituellement, il peut être traité à l'aide de JObject, JsonReader, JsonWriter. Cette méthode est la plus polyvalente et la plus flexible, et vous pouvez modifier les zones inconfortables à tout moment.
(1) Utilisez JsonReader pour lire la chaîne Json :

string jsonText = @"{""input"" : ""value"", ""output"" : ""result""}";
JsonReader reader = new JsonTextReader(new StringReader(jsonText));
while (reader.Read())
{
    Console.WriteLine(reader.TokenType + "\t\t" + reader.ValueType + "\t\t" + reader.Value);
}

(2) Utilisez JsonWriter pour écrire une chaîne :

StringWriter sw = new StringWriter();
JsonWriter writer = new JsonTextWriter(sw);
writer.WriteStartObject();
writer.WritePropertyName("input");
writer.WriteValue("value");
writer.WritePropertyName("output");
writer.WriteValue("result");
writer.WriteEndObject();
writer.Flush();
string jsonText = sw.GetStringBuilder().ToString();
Console.WriteLine(jsonText);

(3) Utilisez JObject pour lire et écrire une chaîne :

JObject jo = JObject.Parse(jsonText);
string[] values = jo.Properties().Select(item => item.Value.ToString()).ToArray();

(4) Utilisez JsonSerializer pour lire et écrire des objets (basés sur JsonWriter et JsonReader) :

Données de tableau

string jsonArrayText1 = "[{'a':'a1','b':'b1'},{'a':'a2','b':'b2'}]";
JArray ja = (JArray)JsonConvert.DeserializeObject(jsonArrayText1);
string ja1a = ja[1]["a"].ToString();
//或者
JObject o = (JObject)ja[1];
string oa = o["a"].ToString();

Format imbriqué

string jsonText = "{\"beijing\":{\"zone\":\"海淀\",\"zone_en\":\"haidian\"}}";
JObject jo = (JObject)JsonConvert.DeserializeObject(jsonText);
string zone = jo["beijing"]["zone"].ToString();
string zone_en = jo["beijing"]["zone_en"].ToString();

Classe personnalisée Project

Project p = new Project() { Input = "stone", Output = "gold" };
JsonSerializer serializer = new JsonSerializer();
StringWriter sw = new StringWriter();
serializer.Serialize(new JsonTextWriter(sw), p);
Console.WriteLine(sw.GetStringBuilder().ToString());
StringReader sr = new StringReader(@"{""Input"":""stone"", ""Output"":""gold""}");
Project p1 = (Project)serializer.Deserialize(new JsonTextReader(sr), typeof(Project));
Console.WriteLine(p1.Input + "=>" + p1.Output);

Le code ci-dessus est basé sur la définition de classe Project suivante :

class Project
{
    public string Input { get; set; }
    public string Output { get; set; }
}

De plus, si le JsonTextReader ci-dessus et d'autres classes ne peuvent pas être compilé, la description est une classe que nous avons modifiée. Remplacez-la simplement par votre propre classe associée et cela n'affectera pas l'utilisation.

3. Méthode intégrée : utilisez la classe JavaScriptSerializer sous l'espace de noms System.Web.Script.Serialization fourni dans .NET Framework 3.5/4.0 pour sérialiser et désérialiser les objets, ce qui est très simple.

Project p = new Project() { Input = "stone", Output = "gold" };
 JavaScriptSerializer serializer = new JavaScriptSerializer();
 var json = serializer.Serialize(p);
 Console.WriteLine(json);
 var p1 = serializer.Deserialize<Project>(json);
 Console.WriteLine(p1.Input + "=>" + p1.Output);
 Console.WriteLine(ReferenceEquals(p,p1));

Remarque : si vous utilisez VS2010, le framework cible du projet actuel doit être modifié en .Net Framework 4 et le profil client ne peut pas être utilisé. Bien entendu, ce System.Web.Extensions.dll est principalement utilisé par le Web. Cela ressemble à un gaspillage de ressources de l'utiliser directement dans le projet Console.

De plus, comme vous pouvez le voir dans la dernière phrase, la sérialisation et la désérialisation sont une méthode d'implémentation typique de la copie profonde.

4. Méthode de contrat : utilisez DataContractJsonSerializer ou JsonReaderWriterFactory fourni par System.Runtime.Serialization.dll.

Project p = new Project() { Input = "stone", Output = "gold" };
DataContractJsonSerializer serializer = new DataContractJsonSerializer(p.GetType());
string jsonText;
using (MemoryStream stream = new MemoryStream())
{
    serializer.WriteObject(stream, p);
    jsonText = Encoding.UTF8.GetString(stream.ToArray());
    Console.WriteLine(jsonText);
}
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonText)))
{
    DataContractJsonSerializer serializer1 = new DataContractJsonSerializer(typeof(Project));
    Project p1 = (Project)serializer1.ReadObject(ms);
    Console.WriteLine(p1.Input + "=>" + p1.Output);
}

Il convient de noter ici que la classe Project et les membres ici doivent ajouter des attributs pertinents :

[DataContract]
class Project
{
    [DataMember]
    public string Input { get; set; }
    [DataMember]
    public string Output { get; set; }
}

Pour plus d'articles liés au code d'implémentation de C# analysant les fichiers json, veuillez faire attention au site Web PHP chinois !