Deserializzare JSON in oggetto dinamico C #?


966

C'è un modo per deserializzare il contenuto JSON in un tipo dinamico C # 4? Sarebbe bello saltare la creazione di un gruppo di classi per utilizzare il DataContractJsonSerializer.


5
Se vuoi qualcosa di "dinamico", perché non usare semplicemente gli accessor get-style forniti con la maggior parte dei decoder JSON che non vanno al semplice oggetto vecchio? (ad esempio, c'è davvero bisogno di creare oggetti "dinamici"?) json.org ha un sacco di collegamenti per implementazioni JSON in C #.

Sto lavorando a un progetto che sta cercando di ridurre al minimo le dipendenze esterne. Quindi, se è possibile qualcosa con i serializzatori .net di stock e tipi che sarebbero preferiti. Naturalmente se non è possibile, sto colpendo json.org. Grazie!
jswanson,

42
Sono davvero sorpreso che il team C # abbia aggiunto "dinamico", ma nel CLR non c'è modo di convertire un oggetto JSON in un'istanza di classe CLR dinamica.
Frank Schwieterman,

2
Purtroppo la risposta accettata non funziona in .NET 4 RTM. Ho pubblicato una risposta che mi ha aiutato ad andare avanti con questo che potrebbe essere utile per gli altri.
Drew Noakes,

(Anche se sembra che Newtonsoft JSON.NET si avvicini abbastanza. Non ci sono esempi davvero buoni, comunque.)
Hot Licks

Risposte:


660

Se sei felice di avere una dipendenza System.Web.Helpersdall'assembly, puoi usare la Jsonclasse:

dynamic data = Json.Decode(json);

È incluso con il framework MVC come download aggiuntivo per il framework .NET 4. Assicurati di dare a Vlad un voto se questo è utile! Tuttavia, se non si può presumere che l'ambiente client includa questa DLL, continuare a leggere.


Un approccio alternativo alla deserializzazione è suggerito qui . Ho modificato leggermente il codice per correggere un bug e adattarmi al mio stile di codifica. Tutto ciò di cui hai bisogno è questo codice e un riferimento a System.Web.Extensionsdal tuo progetto:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Web.Script.Serialization;

public sealed class DynamicJsonConverter : JavaScriptConverter
{
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        if (dictionary == null)
            throw new ArgumentNullException("dictionary");

        return type == typeof(object) ? new DynamicJsonObject(dictionary) : null;
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override IEnumerable<Type> SupportedTypes
    {
        get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(object) })); }
    }

    #region Nested type: DynamicJsonObject

    private sealed class DynamicJsonObject : DynamicObject
    {
        private readonly IDictionary<string, object> _dictionary;

        public DynamicJsonObject(IDictionary<string, object> dictionary)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");
            _dictionary = dictionary;
        }

        public override string ToString()
        {
            var sb = new StringBuilder("{");
            ToString(sb);
            return sb.ToString();
        }

        private void ToString(StringBuilder sb)
        {
            var firstInDictionary = true;
            foreach (var pair in _dictionary)
            {
                if (!firstInDictionary)
                    sb.Append(",");
                firstInDictionary = false;
                var value = pair.Value;
                var name = pair.Key;
                if (value is string)
                {
                    sb.AppendFormat("{0}:\"{1}\"", name, value);
                }
                else if (value is IDictionary<string, object>)
                {
                    new DynamicJsonObject((IDictionary<string, object>)value).ToString(sb);
                }
                else if (value is ArrayList)
                {
                    sb.Append(name + ":[");
                    var firstInArray = true;
                    foreach (var arrayValue in (ArrayList)value)
                    {
                        if (!firstInArray)
                            sb.Append(",");
                        firstInArray = false;
                        if (arrayValue is IDictionary<string, object>)
                            new DynamicJsonObject((IDictionary<string, object>)arrayValue).ToString(sb);
                        else if (arrayValue is string)
                            sb.AppendFormat("\"{0}\"", arrayValue);
                        else
                            sb.AppendFormat("{0}", arrayValue);

                    }
                    sb.Append("]");
                }
                else
                {
                    sb.AppendFormat("{0}:{1}", name, value);
                }
            }
            sb.Append("}");
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (!_dictionary.TryGetValue(binder.Name, out result))
            {
                // return null to avoid exception.  caller can check for null this way...
                result = null;
                return true;
            }

            result = WrapResultObject(result);
            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            if (indexes.Length == 1 && indexes[0] != null)
            {
                if (!_dictionary.TryGetValue(indexes[0].ToString(), out result))
                {
                    // return null to avoid exception.  caller can check for null this way...
                    result = null;
                    return true;
                }

                result = WrapResultObject(result);
                return true;
            }

            return base.TryGetIndex(binder, indexes, out result);
        }

        private static object WrapResultObject(object result)
        {
            var dictionary = result as IDictionary<string, object>;
            if (dictionary != null)
                return new DynamicJsonObject(dictionary);

            var arrayList = result as ArrayList;
            if (arrayList != null && arrayList.Count > 0)
            {
                return arrayList[0] is IDictionary<string, object> 
                    ? new List<object>(arrayList.Cast<IDictionary<string, object>>().Select(x => new DynamicJsonObject(x))) 
                    : new List<object>(arrayList.Cast<object>());
            }

            return result;
        }
    }

    #endregion
}

Puoi usarlo in questo modo:

string json = ...;

var serializer = new JavaScriptSerializer();
serializer.RegisterConverters(new[] { new DynamicJsonConverter() });

dynamic obj = serializer.Deserialize(json, typeof(object));

Quindi, data una stringa JSON:

{
  "Items":[
    { "Name":"Apple", "Price":12.3 },
    { "Name":"Grape", "Price":3.21 }
  ],
  "Date":"21/11/2010"
}

Il seguente codice funzionerà in fase di esecuzione:

dynamic data = serializer.Deserialize(json, typeof(object));

data.Date; // "21/11/2010"
data.Items.Count; // 2
data.Items[0].Name; // "Apple"
data.Items[0].Price; // 12.3 (as a decimal)
data.Items[1].Name; // "Grape"
data.Items[1].Price; // 3.21 (as a decimal)

1
Ottengo un errore in obj = serializer.Deserialize dinamico (json, typeof (oggetto)); dicendo che nessun sovraccarico per il metodo con 2 argomenti ... sbagliato dll o cosa?
Stewie Griffin,

32
È possibile utilizzare System.Web.Helpers.Json: offre un metodo di decodifica che restituisce un oggetto dinamico. Ho anche pubblicato queste informazioni come risposta.
Vlad Iliescu,

2
Anche questo mi ha aiutato molto, ma sono curioso di sapere cosa dovrei fare se dovessi usare il metodo .Serialize, che attualmente genera solo NotImplementedException ... Non ho familiarità con le classi sigillate e / o l'abstract esteso classi. Qualcuno può indicarmi la giusta direzione?
Cory W.

2
a volte in js hai campi con caratteri speciali come "background-color". Per accedere a tali campi in js fai obj ["background-color"]. Come posso accedere a tali campi da c # dopo aver deserializzato l'oggetto dinamico? Non posso fare obj.background-color, ovviamente, e obj ["background-color"] non sembra funzionare. Sarebbe bello se fosse possibile accedere all'oggetto dinamico anche come dizionario, allo stesso tempo, esattamente come in js.
Radu Simionescu,

2
@RaduSimionescu Probabilmente sono un po 'in ritardo, ma forse questo aiuta i futuri visitatori. Ho avuto lo stesso problema, solo con il nome campo params(che è una parola chiave in C #). Oltre a TryGetMemberte puoi scavalcare TryGetIndex, il che ti dà esattamente lo stesso comportamento di JS. Quindi puoi fare obj["params"]o obj["background-color"]per nomi di campi scomodi.
Martin Ender,

606

È abbastanza semplice usare Json.NET :

dynamic stuff = JsonConvert.DeserializeObject("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

string name = stuff.Name;
string address = stuff.Address.City;

Inoltre using Newtonsoft.Json.Linq:

dynamic stuff = JObject.Parse("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

string name = stuff.Name;
string address = stuff.Address.City;

Documentazione: query su JSON con dinamica


9
@HotLicks: Per introspettare la dinamica stufffai qualcosa del tipo:foreach (Newtonsoft.Json.Linq.JProperty jproperty in stuff) { Console.WriteLine("jproperty.Name = {0}", jproperty.Name);}
Matthias,

11
Qual è la differenza tra JsonConvert.DeserializeObject e JObject.Parse? La risposta sta usando entrambi allo stesso modo per fare la stessa cosa ma non spiega la differenza.
cja

7
@TomPeplow Ho provato questo. Non ha funzionato per me. Dice che "JObject non implementa 'Nome'".
Lee Louviere,

4

8
Non riesco a farlo funzionare. Ho ridotto il problema ad essere all'interno di un asyncmetodo. Se rendo il metodo sincrono funziona come previsto. Tuttavia, crea il metodo asynce non riesco a ottenere un dynamic, ho solo un object. Il casting esplicito non fa nulla, mi dà ancora solo un object. Qualcun altro sta vivendo questo?
codeConcussion

295

Puoi farlo usando System.Web.Helpers.Json - il suo metodo Decode restituisce un oggetto dinamico che puoi attraversare come preferisci.

È incluso nell'assemblaggio System.Web.Helpers (.NET 4.0).

var dynamicObject = Json.Decode(jsonString);

25
FYI System.Web.Helpers.dll richiede .net 4.0 ma non è incluso in .net 4.0. Può essere installato con ASP.NET MVC 3
jbtule il

7
Troverai questo assembly nel gruppo Extensions in Assembly in Visual Studio 2012
W3Max

1
Problemi con l'utilizzo dinamico? Come possiamo gestire le eccezioni in modo efficiente se l'input JSON non contiene le proprietà ..
Usama Khalil

5
Se si desidera digitare fortemente il modello, assicurarsi di utilizzare il metodo Json.Decode <T> (stringa).
Mike,

2
Per aggiungere questa libreria al progetto: stackoverflow.com/questions/8037895/...

80

.NET 4.0 ha una libreria integrata per fare ciò:

using System.Web.Script.Serialization;
JavaScriptSerializer jss = new JavaScriptSerializer();
var d = jss.Deserialize<dynamic>(str);

Questo è il modo più semplice.


27
hai provato questo? Ritorna Dictionary<string,object>. A meno che non mi manchi qualcosa, il tuo esempio non restituisce un oggetto dinamico.
sergiopereira,

18
Questo non funziona, restituisce solo un dict sotto forma di un dinamico
mattmanser,

55
@Peter Long Credo di non essere riuscito a dichiarare chiaramente il mio caso, caro amico. Vorrei tentare di correggere il mio errore. So cos'è una dinamica. Questo non ti consente di passare un oggetto JSON e utilizzare d.code, dovresti fare d ["code"]. Valore, che non è quello che la maggior parte delle persone trova questa risposta, sappiamo già come ottenere il dizionario e trasmetterlo a una dinamica è una totale perdita di tempo. Rispetto rispettosamente, signore.
Mattmanser,

4
@mattmanser, we already know how to get the dictionary and casting it to a dynamic. Non deve essere una dizione. Json ha anche elenchi oltre al dizionario. E anche liste e dizionari potrebbero essere nidificati. Il mio codice potrebbe gestire tutte queste situazioni. MA il tuo metodo NON può.
Peter Long,

4
@mattmanser ha ragione; è possibile implementare IDynamicMetaObjectProvider(o usare ad esempio ExpandoObject) che è in grado di intercettare le proprietà e cercarle in un dizionario interno. Questo combinato con l'uso di dynamicconsente il codice come d.codeda utilizzare. È quasi inutile trasmettere un dizionario a una dinamica.
Stephen Drew,

78

"String JSON data" semplici da obiettare senza alcun file DLL di terze parti:

WebClient client = new WebClient();
string getString = client.DownloadString("https://graph.facebook.com/zuck");

JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic item = serializer.Deserialize<object>(getString);
string name = item["name"];

//note: JavaScriptSerializer in this namespaces
//System.Web.Script.Serialization.JavaScriptSerializer

Nota: è anche possibile utilizzare l'oggetto personalizzato.

Personel item = serializer.Deserialize<Personel>(getString);

4
Non capisco. Questa è di gran lunga la soluzione più semplice e nessuno lo menziona.
Cikatomo,

2
sì, è semplice :) a volte è necessario serializzare ma non si desidera includere la terza parte dll
İbrahim Özbölük

Puoi approfondire: come dinamica può accedere all'oggetto deserializzato via: myObject["myprop"]? So che è fatto in fase di runtime ma quanto myObject["myprop"]è valido accedervi tramite ?
Royi Namir,

1
Puoi deserializzare il tuo oggetto come Personel item = serializer.Deserialize <Personel> (getString); e se usi anche l'oggetto dinamico puoi usare l'array e tutto è possibile come ogni oggetto
İbrahim Özbölük

3
Per utilizzare lo spazio dei nomi System.Web.Script.Serialization, il progetto deve fare riferimento a System.Web.Extensions.
StilgarISCA

28

JsonFx può deserializzare il contenuto JSON in oggetti dinamici.

Serializza da / verso tipi dinamici (impostazione predefinita per .NET 4.0):

var reader = new JsonReader(); var writer = new JsonWriter();

string input = @"{ ""foo"": true, ""array"": [ 42, false, ""Hello!"", null ] }";
dynamic output = reader.Read(input);
Console.WriteLine(output.array[0]); // 42
string json = writer.Write(output);
Console.WriteLine(json); // {"foo":true,"array":[42,false,"Hello!",null]}

19

Ho realizzato una nuova versione di DynamicJsonConverter che utilizza Expando Objects. Ho usato gli oggetti expando, perché volevo serializzare nuovamente la dinamica in JSON usando Json.NET.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Dynamic;
using System.Web.Script.Serialization;

public static class DynamicJson
{
    public static dynamic Parse(string json)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        jss.RegisterConverters(new JavaScriptConverter[] { new DynamicJsonConverter() });

        dynamic glossaryEntry = jss.Deserialize(json, typeof(object)) as dynamic;
        return glossaryEntry;
    }

    class DynamicJsonConverter : JavaScriptConverter
    {
        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            if (dictionary == null)
                throw new ArgumentNullException("dictionary");

            var result = ToExpando(dictionary);

            return type == typeof(object) ? result : null;
        }

        private static ExpandoObject ToExpando(IDictionary<string, object> dictionary)
        {
            var result = new ExpandoObject();
            var dic = result as IDictionary<String, object>;

            foreach (var item in dictionary)
            {
                var valueAsDic = item.Value as IDictionary<string, object>;
                if (valueAsDic != null)
                {
                    dic.Add(item.Key, ToExpando(valueAsDic));
                    continue;
                }
                var arrayList = item.Value as ArrayList;
                if (arrayList != null && arrayList.Count > 0)
                {
                    dic.Add(item.Key, ToExpando(arrayList));
                    continue;
                }

                dic.Add(item.Key, item.Value);
            }
            return result;
        }

        private static ArrayList ToExpando(ArrayList obj)
        {
            ArrayList result = new ArrayList();

            foreach (var item in obj)
            {
                var valueAsDic = item as IDictionary<string, object>;
                if (valueAsDic != null)
                {
                    result.Add(ToExpando(valueAsDic));
                    continue;
                }

                var arrayList = item as ArrayList;
                if (arrayList != null && arrayList.Count > 0)
                {
                    result.Add(ToExpando(arrayList));
                    continue;
                }

                result.Add(item);
            }
            return result;
        }

        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            throw new NotImplementedException();
        }

        public override IEnumerable<Type> SupportedTypes
        {
            get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { typeof(object) })); }
        }
    }
}

18

Un altro modo di usare Newtonsoft.Json :

dynamic stuff = Newtonsoft.Json.JsonConvert.DeserializeObject("{ color: 'red', value: 5 }");
string color = stuff.color;
int value = stuff.value;

14

Puoi raggiungerlo con l'aiuto di Newtonsoft.Json. Installa Newtonsoft.Json da Nuget e il:

using Newtonsoft.Json;

dynamic results = JsonConvert.DeserializeObject<dynamic>(YOUR_JSON);

8

Il modo più semplice è:

Includi questo file DLL .

Usa il codice in questo modo:

dynamic json = new JDynamic("{a:'abc'}");
// json.a is a string "abc"

dynamic json = new JDynamic("{a:3.1416}");
// json.a is 3.1416m

dynamic json = new JDynamic("{a:1}");
// json.a is

dynamic json = new JDynamic("[1,2,3]");
/json.Length/json.Count is 3
// And you can use json[0]/ json[2] to get the elements

dynamic json = new JDynamic("{a:[1,2,3]}");
//json.a.Length /json.a.Count is 3.
// And you can use  json.a[0]/ json.a[2] to get the elements

dynamic json = new JDynamic("[{b:1},{c:1}]");
// json.Length/json.Count is 2.
// And you can use the  json[0].b/json[1].c to get the num.

6

È possibile estendere JavaScriptSerializer per copiare ricorsivamente il dizionario creato per espanderne gli oggetti e quindi utilizzarli in modo dinamico:

static class JavaScriptSerializerExtensions
{
    public static dynamic DeserializeDynamic(this JavaScriptSerializer serializer, string value)
    {
        var dictionary = serializer.Deserialize<IDictionary<string, object>>(value);
        return GetExpando(dictionary);
    }

    private static ExpandoObject GetExpando(IDictionary<string, object> dictionary)
    {
        var expando = (IDictionary<string, object>)new ExpandoObject();

        foreach (var item in dictionary)
        {
            var innerDictionary = item.Value as IDictionary<string, object>;
            if (innerDictionary != null)
            {
                expando.Add(item.Key, GetExpando(innerDictionary));
            }
            else
            {
                expando.Add(item.Key, item.Value);
            }
        }

        return (ExpandoObject)expando;
    }
}

Quindi devi solo avere un'istruzione using per lo spazio dei nomi in cui hai definito l'estensione (considera solo definirli in System.Web.Script.Serialization ... un altro trucco è non usare uno spazio dei nomi, quindi non è necessario l'utilizzo di dichiarazione) e puoi consumarli in questo modo:

var serializer = new JavaScriptSerializer();
var value = serializer.DeserializeDynamic("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

var name = (string)value.Name; // Jon Smith
var age = (int)value.Age;      // 42

var address = value.Address;
var city = (string)address.City;   // New York
var state = (string)address.State; // NY

6

Puoi usare using Newtonsoft.Json

var jRoot = 
 JsonConvert.DeserializeObject<dynamic>(Encoding.UTF8.GetString(resolvedEvent.Event.Data));

resolvedEvent.Event.Data è la mia risposta che arriva dalla chiamata al Core Event.


6

Uso http://json2csharp.com/ per ottenere una classe che rappresenta l'oggetto JSON.

Ingresso:

{
   "name":"John",
   "age":31,
   "city":"New York",
   "Childs":[
      {
         "name":"Jim",
         "age":11
      },
      {
         "name":"Tim",
         "age":9
      }
   ]
}

Produzione:

public class Child
{
    public string name { get; set; }
    public int age { get; set; }
}

public class Person
{
    public string name { get; set; }
    public int age { get; set; }
    public string city { get; set; }
    public List<Child> Childs { get; set; }
}

Dopodiché utilizzo Newtonsoft.Json per riempire la classe:

using Newtonsoft.Json;

namespace GitRepositoryCreator.Common
{
    class JObjects
    {
        public static string Get(object p_object)
        {
            return JsonConvert.SerializeObject(p_object);
        }
        internal static T Get<T>(string p_object)
        {
            return JsonConvert.DeserializeObject<T>(p_object);
        }
    }
}

Puoi chiamarlo così:

Person jsonClass = JObjects.Get<Person>(stringJson);

string stringJson = JObjects.Get(jsonClass);

PS:

Se il nome della tua variabile JSON non è un nome C # valido (il nome inizia con $) puoi sistemarlo in questo modo:

public class Exception
{
   [JsonProperty(PropertyName = "$id")]
   public string id { get; set; }
   public object innerException { get; set; }
   public string message { get; set; }
   public string typeName { get; set; }
   public string typeKey { get; set; }
   public int errorCode { get; set; }
   public int eventId { get; set; }
}

5

Per questo vorrei usare JSON.NET per eseguire l'analisi di basso livello del flusso JSON e quindi creare la gerarchia degli oggetti dalle istanze della ExpandoObjectclasse.


5

Sto usando così nel mio codice e funziona bene

using System.Web.Script.Serialization;
JavaScriptSerializer oJS = new JavaScriptSerializer();
RootObject oRootObject = new RootObject();
oRootObject = oJS.Deserialize<RootObject>(Your JSon String);

1
ma non è questa la domanda. c'è un altro quando devi specificare il tipo per ogni stringa json e lavorare con il tipo dinamico.
Illuminati,

5

Guarda l'articolo che ho scritto su CodeProject, uno che risponde esattamente alla domanda:

Tipi dinamici con JSON.NET

Esiste un modo eccessivo per ripubblicare tutto qui, e anche meno punti poiché quell'articolo ha un allegato con la chiave / il file sorgente richiesto.


5

Un'altra opzione è "Incolla JSON come classi" in modo che possa essere deserializzato in modo rapido e semplice.

  1. Basta copiare l'intero JSON
  2. In Visual Studio: fai clic su ModificaIncolla specialeIncolla JSON come classi

Ecco una spiegazione migliore n piccas ... 'Incolla JSON come classi' in ASP.NET e Web Tools 2012.2 RC


questo mi ha fatto risparmiare un sacco di tempo! dovrebbe essere scelto come migliore risposta!
Jsiot

4

La deserializzazione in JSON.NET può essere dinamica usando la JObjectclasse, inclusa in quella libreria. La mia stringa JSON rappresenta queste classi:

public class Foo {
   public int Age {get;set;}
   public Bar Bar {get;set;}
}

public class Bar {
   public DateTime BDay {get;set;}
}

Ora deserializziamo la stringa SENZA fare riferimento alle classi precedenti:

var dyn = JsonConvert.DeserializeObject<JObject>(jsonAsFooString);

JProperty propAge = dyn.Properties().FirstOrDefault(i=>i.Name == "Age");
if(propAge != null) {
    int age = int.Parse(propAge.Value.ToString());
    Console.WriteLine("age=" + age);
}

//or as a one-liner:
int myage = int.Parse(dyn.Properties().First(i=>i.Name == "Age").Value.ToString());

O se vuoi approfondire:

var propBar = dyn.Properties().FirstOrDefault(i=>i.Name == "Bar");
if(propBar != null) {
    JObject o = (JObject)propBar.First();
    var propBDay = o.Properties().FirstOrDefault (i => i.Name=="BDay");
    if(propBDay != null) {
        DateTime bday = DateTime.Parse(propBDay.Value.ToString());
        Console.WriteLine("birthday=" + bday.ToString("MM/dd/yyyy"));
    }
}

//or as a one-liner:
DateTime mybday = DateTime.Parse(((JObject)dyn.Properties().First(i=>i.Name == "Bar").First()).Properties().First(i=>i.Name == "BDay").Value.ToString());

Vedi post per un esempio completo.


Questo approccio consente di "attraversare" il documento jSON, in modo da poter gestire situazioni in cui la struttura JSON è sconosciuta o variabile (ad esempio, molte API restituiscono un documento JSON completamente diverso quando si verifica un errore). Esistono altre librerie che consentono di farlo, a parte Newtonsoft.JSON (aka JSON.NET)?
Alex 75

4

L'oggetto desiderato DynamicJSONObject è incluso in System.Web.Helpers.dll dal pacchetto di pagine Web ASP.NET, che fa parte di WebMatrix.


4

Esiste una libreria JSON leggera per C # chiamata SimpleJson .

Supporta .NET 3.5+, Silverlight e Windows Phone 7.

Supporta dinamico per .NET 4.0

Può anche essere installato come pacchetto NuGet

Install-Package SimpleJson

4

Utilizzare DataSet (C #) con JavaScript. Una semplice funzione per la creazione di un flusso JSON con input DataSet. Crea contenuti JSON come (set di dati a più tabelle):

[[{a:1,b:2,c:3},{a:3,b:5,c:6}],[{a:23,b:45,c:35},{a:58,b:59,c:45}]]

Solo lato client, usa eval. Per esempio,

var d = eval('[[{a:1,b:2,c:3},{a:3,b:5,c:6}],[{a:23,b:45,c:35},{a:58,b:59,c:45}]]')

Quindi utilizzare:

d[0][0].a // out 1 from table 0 row 0

d[1][1].b // out 59 from table 1 row 1

// Created by Behnam Mohammadi And Saeed Ahmadian
public string jsonMini(DataSet ds)
{
    int t = 0, r = 0, c = 0;
    string stream = "[";

    for (t = 0; t < ds.Tables.Count; t++)
    {
        stream += "[";
        for (r = 0; r < ds.Tables[t].Rows.Count; r++)
        {
            stream += "{";
            for (c = 0; c < ds.Tables[t].Columns.Count; c++)
            {
                stream += ds.Tables[t].Columns[c].ToString() + ":'" +
                          ds.Tables[t].Rows[r][c].ToString() + "',";
            }
            if (c>0)
                stream = stream.Substring(0, stream.Length - 1);
            stream += "},";
        }
        if (r>0)
            stream = stream.Substring(0, stream.Length - 1);
        stream += "],";
    }
    if (t>0)
        stream = stream.Substring(0, stream.Length - 1);
    stream += "];";
    return stream;
}

3

Per ottenere un ExpandoObject:

using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

Container container = JsonConvert.Deserialize<Container>(jsonAsString, new ExpandoObjectConverter());

3

Prova questo:

  var units = new { Name = "Phone", Color= "White" };
    var jsonResponse = JsonConvert.DeserializeAnonymousType(json, units);

3

Come analizzare facilmente i contenuti JSON con Dynamic & JavaScriptSerializer

Aggiungi il riferimento di System.Web.Extensions e aggiungi questo spazio dei nomi using System.Web.Script.Serialization;in alto:

public static void EasyJson()
{
    var jsonText = @"{
        ""some_number"": 108.541,
        ""date_time"": ""2011-04-13T15:34:09Z"",
        ""serial_number"": ""SN1234""
    }";

    var jss = new JavaScriptSerializer();
    var dict = jss.Deserialize<dynamic>(jsonText);

    Console.WriteLine(dict["some_number"]);
    Console.ReadLine();
}

Come analizzare json nidificati e complessi con Dynamic & JavaScriptSerializer

Aggiungi il riferimento di System.Web.Extensions e aggiungi questo spazio dei nomi using System.Web.Script.Serialization;in alto:

public static void ComplexJson()
{
    var jsonText = @"{
        ""some_number"": 108.541,
        ""date_time"": ""2011-04-13T15:34:09Z"",
        ""serial_number"": ""SN1234"",
        ""more_data"": {
            ""field1"": 1.0,
            ""field2"": ""hello""
        }
    }";

    var jss = new JavaScriptSerializer();
    var dict = jss.Deserialize<dynamic>(jsonText);

    Console.WriteLine(dict["some_number"]);
    Console.WriteLine(dict["more_data"]["field2"]);
    Console.ReadLine();
}

1

Con Cinchoo ETL - una libreria open source disponibile per analizzare JSON in un oggetto dinamico:

string json = @"{
    ""key1"": [
        {
            ""action"": ""open"",
            ""timestamp"": ""2018-09-05 20:46:00"",
            ""url"": null,
            ""ip"": ""66.102.6.98""
        }
    ]
}";
using (var p = ChoJSONReader.LoadText(json)
    .WithJSONPath("$.*")
    )
{
    foreach (var rec in p)
    {
        Console.WriteLine("Action: " + rec.action);
        Console.WriteLine("Timestamp: " + rec.timestamp);
        Console.WriteLine("URL: " + rec.url);
        Console.WriteLine("IP address: " + rec.ip);
    }
}

Produzione:

Action: open
Timestamp: 2018-09-05 20:46:00
URL: http://www.google.com
IP address: 66.102.6.98

Disclaimer: sono l'autore di questa biblioteca.


0

prova così!

Esempio JSON:

  [{
            "id": 140,
            "group": 1,
            "text": "xxx",
            "creation_date": 123456,
            "created_by": "xxx@gmail.co",
            "tags": ["xxxxx"]
        }, {
            "id": 141,
            "group": 1,
            "text": "xxxx",
            "creation_date": 123456,
            "created_by": "xxx@gmail.com",
            "tags": ["xxxxx"]
        }]

Codice C #:

        var jsonString = (File.ReadAllText(Path.Combine(Directory.GetCurrentDirectory(),"delete_result.json")));
        var objects = JsonConvert.DeserializeObject<dynamic>(jsonString);
        foreach(var o in objects)
        {
            Console.WriteLine($"{o.id.ToString()}");
        }
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.