wake-up-neo.net

Analysieren Sie den JSON-String in Liste <string>

string json = "{\"People\":[{\"FirstName\":\"Hans\",\"LastName\":\"Olo\"}
                            {\"FirstName\":\"Jimmy\",\"LastName\":\"Crackedcorn\"}]}";

var obj = JObject.Parse(json);

List<string> first;
List<string> last;

foreach (var child in obj["People"].Children())
{
    var name = child.First()["countryName"].ToString();
    var two = child.First()["countryCode"].ToString();
    var three = child.First()["isoAlpha3"].ToString();

    countries.Add(name);
    twoCharCodes.Add(two);
    threeCharCodes.Add(three);

    Console.Write("Name:\t\t{0}\n2CharCode:\t{1}\n3CharCode:\t{2}\n\n", name, two, three);
}

Ich bin auf der Suche nach einer Möglichkeit, jeden FirstName-Wert in die erste Liste und den LastName-Wert und die letzte Liste einzufügen. Was ist der beste Weg, dies zu tun?

Der obige Code bricht ab bei:

var name = child.First()["countryName"].ToString();

mit diesem Fehler:

 Cannot access child value on Newtonsoft.Json.Linq.JProperty

Irgendein Rat?

c#jsonlist
6
ChangeJar

Es scheint ein schlechter Weg zu sein (zwei korrelierte Listen zu erstellen), aber ich gehe davon aus, dass Sie Ihre Gründe dafür haben.

Ich würde den JSON-String (der in Ihrem Beispiel einen Tippfehler hat, ein Komma zwischen den beiden Objekten fehlt) in ein stark typisiertes Objekt parsen und dann ein paar LINQ-Abfragen verwenden, um die beiden Listen zu erhalten.

void Main()
{
    string json = "{\"People\":[{\"FirstName\":\"Hans\",\"LastName\":\"Olo\"},{\"FirstName\":\"Jimmy\",\"LastName\":\"Crackedcorn\"}]}";

    var result = JsonConvert.DeserializeObject<RootObject>(json);

    var firstNames = result.People.Select (p => p.FirstName).ToList();
    var lastNames = result.People.Select (p => p.LastName).ToList();
}

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class RootObject
{
    public List<Person> People { get; set; }
}
12
Craig W.

Da Sie JSON.NET verwenden, würde ich mich persönlich für die Serialisierung entscheiden, damit Sie Intellisense-Unterstützung für Ihr Objekt haben können. Sie benötigen eine Klasse, die Ihre JSON-Struktur darstellt. Sie können dies von Hand erstellen oder Sie können etwas wie json2csharp verwenden, um es für Sie zu generieren:

z.B.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class RootObject
{
    public List<Person> People { get; set; }
}

Dann können Sie einfach die Methoden von JsonConvert aufrufen, um die JSON in ein Objekt zu deserialisieren:

RootObject instance = JsonConvert.Deserialize<RootObject>(json);

Dann haben Sie Intellisense:

var firstName = instance.People[0].FirstName;
var lastName = instance.People[0].LastName;
7
Kenneth K.

Wollte dies als Kommentar als Randnotiz zur akzeptierten Antwort posten, aber das wurde ein wenig unklar ..__ So rein als Randnotiz:

Wenn Sie die Objekte selbst nicht benötigen und Ihr Projekt von weiteren ungenutzten Klassen befreit werden soll, können Sie Folgendes analysieren:

var list = JObject.Parse(json)["People"].Select(el => new { FirstName = (string)el["FirstName"], LastName = (string)el["LastName"] }).ToList();

var firstNames = list.Select(p => p.FirstName).ToList();
var lastNames = list.Select(p => p.LastName).ToList();

Selbst wenn Sie eine stark typisierte Personenklasse verwenden, können Sie das Stammobjekt immer noch überspringen, indem Sie eine Liste mit JObject.Parse(json)["People"].ToObject<List<Person>>() .__ erstellen. Wenn Sie die Objekte jedoch wiederverwenden möchten, sollten Sie sie natürlich von Anfang an erstellen. Wollte nur auf die Alternative hinweisen;)

0
Me.Name

Ich verwende diese JSON-Helper-Klasse in meinen Projekten. Ich habe es vor einem Jahr im Netz gefunden, aber die Quell-URL verloren. Also füge ich es direkt aus meinem Projekt ein:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Runtime.Serialization.Json;
using System.IO;
using System.Text;
/// <summary>
/// JSON Serialization and Deserialization Assistant Class
/// </summary>
public class JsonHelper
{
    /// <summary>
    /// JSON Serialization
    /// </summary>
    public static string JsonSerializer<T> (T t)
    {
        DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
        MemoryStream ms = new MemoryStream();
        ser.WriteObject(ms, t);
        string jsonString = Encoding.UTF8.GetString(ms.ToArray());
        ms.Close();
        return jsonString;
    }
    /// <summary>
    /// JSON Deserialization
    /// </summary>
    public static T JsonDeserialize<T> (string jsonString)
    {
        DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
        MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
        T obj = (T)ser.ReadObject(ms);
        return obj;
    }
}

Sie können es folgendermaßen verwenden: Erstellen Sie die Klassen, wie Craig W. vorgeschlagen hat.

Und dann deserialisieren

RootObject root = JSONHelper.JsonDeserialize<RootObject>(json);
0
Aishwarya Shiva