C#-Implementierungscode zum Parsen von JSON-Dateien

C#-Parsing-JSON

JSON (vollständiger Name: JavaScript Object Notation) ist ein leichtes Datenaustauschformat. Es basiert auf einer Teilmenge des JavaScript-Syntaxstandards. JSON ist ein völlig sprachunabhängiges Textformat, das problemlos über verschiedene Netzwerke, Plattformen und Programme übertragen werden kann. Die Syntax von JSON ist sehr einfach, für Menschen leicht zu lesen und zu schreiben und für Maschinen leicht zu analysieren und zu generieren.

Vergleich von JSON und XML

◆Lesbarkeit
Beim Vergleich der Lesbarkeit von JSON und XML stellt XML Hilfs-Tags bereit und eignet sich besser für das menschliche Lesen und Verstehen.
◆Dateigröße und -übertragung
XML ermöglicht die Verwendung praktischer Tags, sodass die Dateigröße größer als JSON ist. Darüber hinaus stammt JSON aus Javascript, sodass sein natürliches Hauptschlachtfeld Javascript und das Internet ist. Hier hat JSON Vorteile, mit denen XML nicht mithalten kann.

JSON-Syntax

1. Die JSON-Syntax ist eine Teilmenge der JavaScript-Objektnotationssyntax.

• Daten liegen in Name/Wert-Paaren vor: Namen sind Zeichenfolgen, ausgedrückt in doppelten Anführungszeichen. Werte können sein: Zahlen (Ganzzahl oder Gleitkomma), Zeichenfolgen (in doppelten Anführungszeichen), Arrays (in eckigen Klammern), Objekte (in geschweiften Klammern), wahr/falsch/null.
• Daten werden durch Kommas getrennt:
• Geschweifte Klammern halten Objekte: Objekte können eine Vielzahl von Daten enthalten, einschließlich Arrays.
• Eckige Klammern enthalten Arrays: Zahlen können Objekte enthalten.

Zum Beispiel:

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

2. Wenn JSON Escape-Zeichen enthält, müssen diese maskiert werden. Beispielsweise müssen Sie im Dateipfad „\“ anstelle von „“ verwenden. Zum Beispiel: { „file“: „C:\a.txt“}.

.NET betreibt JSON

Wenn JSON-Dateien in den Speicher eingelesen werden, sind sie Strings. .NET betreibt JSON, indem es JSON-Strings generiert und analysiert. Normalerweise gibt es mehrere Möglichkeiten, JSON zu bedienen:

1 Ursprüngliche Methode: Befolgen Sie das JSON-Syntaxformat und schreiben Sie Code, um die JSON-Zeichenfolge direkt zu bedienen. Wenn es nicht nötig wäre, würden die wenigsten Menschen diesen Weg einschlagen und noch einmal von vorne anfangen.

2. Allgemeine Methode [★★★★★]:

Diese Methode verwendet die Open-Source-Klassenbibliothek Newtonsoft.Json (Download-Adresse http://json.codeplex.com/). Nach dem Herunterladen können Sie es verwenden, indem Sie es dem Projekt hinzufügen. Normalerweise kann es mit JObject, JsonReader, JsonWriter verarbeitet werden. Diese Methode ist die vielseitigste und flexibelste und Sie können unbequeme Bereiche jederzeit ändern.
(1) Verwenden Sie JsonReader, um die Json-Zeichenfolge zu lesen:

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) Verwenden Sie JsonWriter, um die Zeichenfolge zu schreiben:

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) Verwenden Sie JObject, um die Zeichenfolge zu lesen und zu schreiben :

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

(4) Verwenden Sie JsonSerializer zum Lesen und Schreiben von Objekten (basierend auf JsonWriter und JsonReader):

Array-Daten

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();

Verschachteltes Format

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();

Benutzerdefiniertes Klassenprojekt

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

Der obige Code basiert auf der folgenden Projektklassendefinition:

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

Außerdem, wenn der oben genannte JsonTextReader und andere Klassen dies nicht können kompiliert werden. Die Beschreibung ist eine von uns geänderte Klasse. Ersetzen Sie sie einfach durch Ihre eigene verwandte Klasse, die Verwendung wird dadurch nicht beeinträchtigt.

3. Integrierte Methode: Verwenden Sie die JavaScriptSerializer-Klasse unter dem in .NET Framework 3.5/4.0 bereitgestellten Namespace System.Web.Script.Serialization, um Objekte zu serialisieren und zu deserialisieren, was sehr einfach ist.

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

Hinweis: Wenn Sie VS2010 verwenden, muss das Zielframework des aktuellen Projekts auf .Net Framework 4 geändert werden und Client Profile kann nicht verwendet werden. Natürlich wird diese System.Web.Extensions.dll hauptsächlich im Web verwendet, daher fühlt sich die direkte Verwendung im Konsolenprojekt wie eine Verschwendung von Ressourcen an.

Darüber hinaus sind Serialisierung und Deserialisierung, wie Sie dem letzten Satz entnehmen können, eine typische Implementierungsmethode für Deep Copy.

4. Vertragsmethode: Verwenden Sie DataContractJsonSerializer oder JsonReaderWriterFactory, bereitgestellt von 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);
}

Hier ist zu beachten, dass die Project-Klasse und die Mitglieder hier relevante Attribute hinzufügen müssen:

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

Weitere Artikel zum Implementierungscode von C#-Parsing-JSON-Dateien finden Sie unter Bitte achten Sie auf die chinesische PHP-Website!