C # .net, wie komplexe Objekte von JSON deserialisiert werden

Sollte einfach so sein:

var jobject = JsonConvert.DeserializeObject<RootObject>(jsonstring);

Sie können den Json-String hier einfügen: http://json2csharp.com/ , um zu überprüfen, ob Ihre Klassen korrekt sind.

Wenn Sie C # 2010 oder neuer verwenden, können Sie dynamic type verwenden:

dynamic json = Newtonsoft.Json.JsonConvert.DeserializeObject(jsonstring);

Dann können Sie auf Attribute und Arrays in dynamischen Objekten mithilfe der Punktnotation zugreifen:

string nemo = json.response[0].images[0].report.nemo;

Installieren Sie zuerst newtonsoft.json-Paket mit Visual Studio in NuGet Package Manager und fügen Sie dann den folgenden Code hinzu:

ClassName ObjectName = JsonConvert.DeserializeObject < ClassName > (jsonObject);

Ich hatte ein Szenario und dieses half mir

JObject objParserd = JObject. Parse (jsonString);

JObject arrayObject1 = (JObject) objParserd ["d"];

D myOutput = JsonConvert. DeserializeObject<D> (arrayObject1.ToString ());

 public static void Main(string[] args)
{
    string json = @" {
    ""children"": [
            {
        ""url"": ""foo.pdf"", 
                ""expanded"": false, 
                ""label"": ""E14288-Passive-40085-2014_09_26.pdf"", 
                ""last_modified"": ""2014-09-28T11:19:49.000Z"", 
                ""type"": 1, 
                ""size"": 60929
            }
        ]
     }";




    var result = JsonConvert.DeserializeObject<ChildrenRootObject>(json);
    DataTable tbl = DataTableFromObject(result.children);
}

public static DataTable DataTableFromObject<T>(IList<T> list)
{
    DataTable tbl = new DataTable();
    tbl.TableName = typeof(T).Name;

    var propertyInfos = typeof(T).GetProperties();
    List<string> columnNames = new List<string>();

    foreach (PropertyInfo propertyInfo in propertyInfos)
    {
        tbl.Columns.Add(propertyInfo.Name, propertyInfo.PropertyType);
        columnNames.Add(propertyInfo.Name);
    }

    foreach(var item in list)
    {
        DataRow row = tbl.NewRow();
        foreach (var name in columnNames)
        {
            row[name] = item.GetType().GetProperty(name).GetValue(item, null);
        }

        tbl.Rows.Add(row);
    }

    return tbl;
}

public class Child
{
    public string url { get; set; }
    public bool expanded { get; set; }
    public string label { get; set; }
    public DateTime last_modified { get; set; }
    public int type { get; set; }
    public int size { get; set; }
}

public class ChildrenRootObject
{
    public List<Child> children { get; set; }
}

shareInfo ist Klasse:

public class ShareInfo
        {
            [JsonIgnore]
            public readonly DateTime Timestamp = DateTime.Now;
            [JsonProperty("sharename")]
            public string ShareName = null;
            [JsonProperty("readystate")]
            public string ReadyState = null;
            [JsonProperty("created")]
            [JsonConverter(typeof(Newtonsoft.Json.Converters.UnixDateTimeConverter))]
            public DateTime? CreatedUtc = null;
            [JsonProperty("title")]
            public string Title = null;
            [JsonProperty("getturl")]
            public string GettUrl = null;
            [JsonProperty("userid")]
            public string UserId = null;
            [JsonProperty("fullname")]
            public string Fullname = null;
            [JsonProperty("files")]
            public GettFile.FileInfo[] Files = new GettFile.FileInfo[0];
        }

// POST request.
            var gett = new WebClient { Encoding = Encoding.UTF8 };
            gett.Headers.Add("Content-Type", "application/json");
            byte[] request = Encoding.UTF8.GetBytes(jsonArgument.ToString());
            byte[] response = gett.UploadData(baseUri.Uri, request);

            // Response.
            var shareInfo = JsonConvert.DeserializeObject<ShareInfo>(Encoding.UTF8.GetString(response));

Ich hatte auch das Problem, JSON-Objekte in C # zu analysieren und zu verwenden. Ich habe den dynamischen Typ mit einigen Bibliotheken überprüft, aber es wurde immer geprüft, ob eine Eigenschaft vorhanden ist.

Am Ende bin ich auf diese Webseite gestoßen, was mir viel Zeit gespart hat. Es erstellt automatisch eine stark typisierte Klasse basierend auf Ihren JSON-Daten, die Sie mit der Newtonsoft-Bibliothek verwenden werden, und es funktioniert einwandfrei. Es funktioniert auch mit anderen Sprachen als C #.

Ich verwende folgendes:

    using System.Web.Script.Serialization;       

    ...

    public static T ParseResponse<T>(string data)
    {
        return new JavaScriptSerializer().Deserialize<T>(data);
    }

Sie können Ihr Problem wie folgt lösen

public class Response
{
    public string loopa { get; set; }
    public string drupa{ get; set; }
    public Image[] images { get; set; }
}

public class RootObject<T>
    {
        public List<T> response{ get; set; }

    }

var des = (RootObject<Response>)Newtonsoft.Json.JsonConvert.DeserializeObject(Your JSon String, typeof(RootObject<Response>));

Ich habe dieses Problem gelöst, um einen öffentlichen Setter für alle Eigenschaften hinzuzufügen, der deserialisiert werden sollte.