JSON을 C # 동적 객체로 역 직렬화합니까?


965

JSON 콘텐츠를 C # 4 동적 유형으로 역 직렬화하는 방법이 있습니까? 를 사용하기 위해 많은 클래스를 만드는 것을 건너 뛰는 것이 좋습니다 DataContractJsonSerializer.


5
'동적'인 것을 원한다면 평범한 객체로 가지 않는 대부분의 JSON 디코더와 함께 제공되는 get 스타일 접근자를 사용하는 것이 어떻습니까? (예를 들어 실제로 '동적'객체 생성이 필요합니까?) json.org 에는 C # JSON 구현을위한 많은 링크가 있습니다.

외부 종속성을 최소화하려고하는 프로젝트를 진행 중입니다. 따라서 스톡 .net 시리얼 라이저와 유형이있는 것이 가능할 경우 가능합니다. 물론 그것이 가능하지 않으면 json.org를 치고 있습니다. 감사!
jswanson 2016 년

42
C # 팀에 'dynamic'을 추가 한 것에 놀랐지 만 CLR에는 JSON 객체를 동적 CLR 클래스 인스턴스로 변환하는 방법이 없습니다.
Frank Schwieterman

2
불행히도 .NET 4 RTM에서는 허용되는 답변이 작동하지 않습니다. 나는 다른 사람들에게 유용 할 수있는이 문제를 해결하는 데 도움이되는 답변을 게시했습니다.
Drew Noakes

(Newtonsoft JSON.NET은 꽤 근접한 것으로 보이지만 실제로는 좋은 예는 없습니다.)
Hot Licks

답변:


659

System.Web.Helpers어셈블리에 의존하고 싶다면 다음 Json클래스를 사용할 수 있습니다 .

dynamic data = Json.Decode(json);

MVC 프레임 워크 에는 .NET 4 프레임 워크에 대한 추가 다운로드 로 포함되어 있습니다 . 도움이된다면 Vlad에게 공감대를 제공하십시오! 그러나 클라이언트 환경에이 DLL이 있다고 가정 할 수 없으면 계속 읽으십시오.


대체 직렬화 해제 방법이 여기 에 제안 됩니다 . 버그를 수정하고 코딩 스타일에 맞게 코드를 약간 수정했습니다. 이 코드와 System.Web.Extensions프로젝트에 대한 참조 만 있으면 됩니다.

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
}

다음과 같이 사용할 수 있습니다.

string json = ...;

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

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

따라서 JSON 문자열이 주어집니다.

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

다음 코드는 런타임에 작동합니다.

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
동적 obj = serializer.Deserialize (json, typeof (object));에서 오류가 발생했습니다. 2 arguments..wrong dll 또는 무엇을 가진 메소드에 과부하가 없다고 말하는가?
Stewie Griffin

32
System.Web.Helpers.Json을 사용할 수 있습니다. 동적 객체를 반환하는 Decode 메서드를 제공합니다. 또한이 정보를 답변으로 게시했습니다.
블라드 Iliescu

2
이것은 나에게도 많은 도움이되었지만 현재 NotImplementedException 만 발생시키는 .Serialize 메소드를 사용해야하는 경우 어떻게 해야하는지 궁금합니다. 클래스. 누구든지 올바른 방향으로 나를 가리킬 수 있습니까?
Cory W.

2
때로는 js에는 "background-color"와 같은 특수 문자가있는 필드가 있습니다. js에서 이러한 필드에 액세스하려면 obj [ "background-color"]를 수행하십시오. 역동적 객체로 직렬화 해제 한 후 C #에서 이러한 필드에 어떻게 액세스 할 수 있습니까? 물론 obj.background-color를 수행 할 수없고 obj [ "background-color"]가 작동하지 않는 것 같습니다. 동적 객체를 js와 똑같이 사전으로 액세스 할 수 있다면 좋을 것입니다.
Radu Simionescu

2
@RaduSimionescu 아마 늦었을지 모르지만 이것은 아마도 미래 방문자에게 도움이 될 것입니다. field-name params(C #의 키워드) 과 동일한 문제가있었습니다 . 또한을 TryGetMember재정의 TryGetIndex하면 JS에서와 동일한 동작을 제공합니다. 그런 다음 어색한 필드 이름을 사용 obj["params"]하거나 수행 할 수 있습니다 obj["background-color"].
Martin Ender

606

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;

또한 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;

설명서 : 동적으로 JSON 쿼리


9
@HotLicks : 역 동성을 조사하려면 stuff다음과 같이하십시오 :foreach (Newtonsoft.Json.Linq.JProperty jproperty in stuff) { Console.WriteLine("jproperty.Name = {0}", jproperty.Name);}
Matthias

11
JsonConvert.DeserializeObject와 JObject.Parse의 차이점은 무엇입니까? 대답은 똑같은 방식으로 두 가지를 모두 사용하지만 차이점을 설명하지는 않습니다.
cja

7
@TomPeplow 이것을 시도했다. 그것은 나를 위해 작동하지 않았다. "JObject는 '이름'을 구현하지 않습니다"라고 말합니다.
Lee Louviere

4
@ cja 차이가 없습니다 : stackoverflow.com/questions/23645034/…
nawfal

8
나는 이것을 작동시킬 수 없다. async메서드 내부로 문제를 좁혔습니다 . 메소드를 동기식으로 만들면 예상대로 작동합니다. 그러나 메서드 async를 만들고을 얻을 수 없으며dynamic 단지을 얻습니다 object. 명시 적 캐스팅은 아무것도하지 않지만 여전히 나에게 object. 다른 사람이 이것을 경험하고 있습니까?
codeConcussion

295

System.Web.Helpers.Json을 사용 하여이 작업을 수행 할 수 있습니다 .Decode 메서드는 원하는대로 통과 할 수있는 동적 객체를 반환합니다.

System.Web.Helpers 어셈블리 (.NET 4.0)에 포함되어 있습니다.

var dynamicObject = Json.Decode(jsonString);

25
FYI System.Web.Helpers.dll에는 .net 4.0이 필요하지만 .net 4.0에는 포함되어 있지 않습니다. ASP.NET MVC 3과 함께 설치 가능
jbtule

7
이 어셈블리는 Visual Studio 2012의 어셈블리
W3Max

1
동적을 사용하는 데 문제가 있습니까? 입력 JSON에 특성이 포함되지 않은 경우 예외를 효율적으로 처리하는 방법 ..
Usama Khalil

5
모델을 강력하게 입력하려면 Json.Decode <T> (string) 메소드를 사용해야합니다.
Mike

2
이 라이브러리를 프로젝트에 추가하려면 : stackoverflow.com/questions/8037895/…

80

.NET 4.0에는이를위한 내장 라이브러리가 있습니다.

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

이것이 가장 간단한 방법입니다.


27
이것을 시도 했습니까? 를 반환합니다 Dictionary<string,object>. 내가 빠진 것이 아닌 한, 귀하의 예제는 동적 객체를 반환하지 않습니다.
sergiopereira 2016 년

18
이것은 작동하지 않습니다, 그것은 단지 역동적 인 형태로 dict를 반환합니다
mattmanser

55
@ 피터 롱 나는 내 사건을 명확하게 밝히지 못했다고 생각한다. 내 오류를 바로 잡도록하겠습니다. 나는 역 동성이 무엇인지 안다. 따라서 JSON 객체를 전달하고 d.code를 사용할 수 없으며 d [ "code"]를 수행해야합니다.이 답변을 찾는 대부분의 사람들이 원하는 것은 아닙니다. 사전을 가져와 동적으로 캐스팅하는 것은 총 시간 낭비입니다. 나는 정중하게 동의하지 않습니다.
mattmanser

4
@mattmanser we already know how to get the dictionary and casting it to a dynamic. 사전 일 필요는 없습니다. Json에는 사전 외에도 목록이 있습니다. 또한 목록과 사전은 중첩 될 수 있습니다. 내 코드는 이러한 모든 상황을 처리 할 수 ​​있습니다. 그러나 당신의 방법은 할 수 없습니다.
피터 롱

4
@mattmanser가 옳습니다. 속성을 가로 채서 내부 사전에서 찾아 볼 수있는 구현 IDynamicMetaObjectProvider(또는 예를 들어 사용 ExpandoObject)이 가능합니다. 이를 사용 dynamic하면 코드를 사용할 수 d.code있습니다. 사전을 역동적으로 캐스트하는 것은 무의미합니다.
Stephen Drew

78

타사 DLL 파일없이 객체에 대한 간단한 "문자열 JSON 데이터":

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

참고 : 사용자 정의 개체를 사용할 수도 있습니다.

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

4
나는 그것을 얻지 못한다. 이것은 가장 간단한 해결책이며 아무도 언급하지 않습니다.
cikatomo

2
네, 그것은 간단합니다 :) 언젠가 당신은 직렬화가 필요하지만 제 3 부분 dll을 포함하고 싶지 않습니다
İbrahim Özbölük

다음을 통해 동적으로 역 직렬화 된 객체에 어떻게 액세스 할 수 myObject["myprop"]있습니까? 나는 그것이 런타임에 완료되었음을 알고 있지만 그것을 통해 액세스하는 것이 어떻게 myObject["myprop"]유효합니까?
Royi Namir

1
Personel item = serializer.Deserialize <Personel> (getString);과 같이 객체를 직렬화 해제 할 수 있습니다. 동적 객체를 사용하면 배열을 사용할 수 있으며 모든 객체와 같은 모든 것이 가능합니다
İbrahim Özbölük

3
System.Web.Script.Serialization 네임 스페이스를 사용하려면 프로젝트에 System.Web.Extensions에 대한 참조가 필요합니다.
StilgarISCA

28

JsonFx 는 JSON 컨텐츠를 동적 오브젝트로 직렬화 해제 할 수 있습니다.

동적 유형과의 직렬화 (.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

Expando Objects를 사용하는 DynamicJsonConverter의 새 버전을 만들었습니다. Json.NET을 사용하여 동적을 JSON으로 다시 직렬화하려고했기 때문에 expando 객체를 사용했습니다.

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


14

Newtonsoft.Json의 도움으로이를 달성 할 수 있습니다. Nuget에서 Newtonsoft.Json을 설치하십시오.

using Newtonsoft.Json;

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

8

가장 간단한 방법은 다음과 같습니다.

DLL 파일 만 포함 하십시오 .

다음과 같은 코드를 사용하십시오.

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

JavaScriptSerializer를 확장하여 객체를 확장하기 위해 작성한 사전을 재귀 적으로 복사 한 다음 동적으로 사용할 수 있습니다.

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

그런 다음 확장명을 정의한 네임 스페이스에 대해 using 문만 있으면됩니다 (System.Web.Script.Serialization에서 확장명을 정의하는 것만 고려하면됩니다. 다른 트릭은 네임 스페이스를 사용하지 않는 것입니다. 진술)) 그리고 당신은 그렇게 소비 할 수 있습니다 :

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

당신이 사용할 수있는 using Newtonsoft.Json

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

resolvedEvent.Event.Data 핵심 이벤트 호출에서 오는 응답입니다.


6

http://json2csharp.com/ 을 사용 하여 JSON 객체를 나타내는 클래스를 얻습니다.

입력:

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

산출:

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

그런 다음 Newtonsoft.Json 을 사용하여 클래스를 채 웁니다.

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

다음과 같이 호출 할 수 있습니다.

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

string stringJson = JObjects.Get(jsonClass);

추신:

JSON 변수 이름이 유효한 C # 이름이 아닌 경우 (이름은로 시작 $) 다음과 같이 수정할 수 있습니다.

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

이를 위해 JSON.NET을 사용하여 JSON 스트림의 저수준 파싱을 수행 한 다음 ExpandoObject클래스 인스턴스에서 객체 계층을 구축합니다 .


5

내 코드에서 이와 같이 사용하고 있으며 잘 작동합니다.

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

1
그러나 그것은 질문이 요구하는 것이 아닙니다. 모든 json 문자열에 유형을 지정하고 동적 유형으로 작업해야 할 때 다릅니다.
Illuminati

5

내가 CodeProject에 작성한 기사를 보아라.

JSON.NET을 사용한 동적 유형

여기에 모두 다시 게시하는 방법이 너무 많으며 해당 기사에 키 / 필수 소스 파일이 첨부되어 있으므로 덜 중요합니다.


5

또 다른 옵션은 "JSON을 클래스로 붙여 넣기"로 빠르고 쉽게 역 직렬화 할 수 있습니다.

  1. 전체 JSON을 복사하기 만하면됩니다
  2. Visual Studio에서 : 편집 → 선택하여 붙여 넣기JSON을 클래스로 붙여 넣기를 클릭 하십시오 .

다음은 ASP.NET 및 웹 도구 2012.2 RC의 'Paste JSON As Classes'입니다.


이것은 나에게 많은 시간을 절약했다! 최고의 답변으로 선택해야합니다!
jsiot

4

JSON.NET에서 역 직렬화는 JObject해당 라이브러리에 포함 된 클래스를 사용하여 동적 일 수 있습니다 . 내 JSON 문자열은 다음 클래스를 나타냅니다.

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

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

이제 위의 클래스를 참조하지 않고 문자열을 역 직렬화합니다.

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

또는 더 깊이 가고 싶다면 :

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

완전한 예는 post 를 참조하십시오 .


이 방법을 사용하면 jSON 문서를 "순회"할 수 있으므로 JSON 구조를 알 수 없거나 가변적 인 상황을 관리 할 수 ​​있습니다 (예를 들어, 많은 API는 오류가 발생할 때 완전히 다른 JSON 문서를 리턴 함). Newtonsoft.JSON (일명 JSON.NET) 외에 다른 라이브러리도 있습니다.
Alex 75

4

DynamicJSONObject를 원하는 개체는 WebMatrix의 일부인 ASP.NET 웹 페이지 패키지의 System.Web.Helpers.dll에 포함되어 있습니다.


4

C #을위한 간단한 JSON 라이브러리 인 SimpleJson이 있습니다.

.NET 3.5 이상, Silverlight 및 Windows Phone 7을 지원합니다.

.NET 4.0에 대한 동적 지원

NuGet 패키지로 설치할 수도 있습니다

Install-Package SimpleJson

4

JavaScript와 함께 DataSet (C #)을 사용하십시오. DataSet 입력으로 JSON 스트림을 생성하기위한 간단한 함수입니다. (다중 테이블 데이터 세트)와 같은 JSON 컨텐츠를 작성하십시오.

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

클라이언트 측에서만 eval을 사용하십시오. 예를 들어

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}]]')

그런 다음 사용하십시오.

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

ExpandoObject를 얻으려면 :

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

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

3

이 시도:

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

3

동적 및 JavaScript로 쉬운 JSON 컨텐츠를 구문 분석하는 방법

System.Web.Extensions의 참조를 추가하고이 네임 스페이스 using System.Web.Script.Serialization;를 맨 위에 추가하십시오 .

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

동적 및 JavaScript를 사용하여 중첩 및 복잡한 JSON을 구문 분석하는 방법

System.Web.Extensions의 참조를 추가하고이 네임 스페이스 using System.Web.Script.Serialization;를 맨 위에 추가하십시오 .

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

Cinchoo의 ETL - 동적 객체로 JSON을 구문 분석하기 위해 사용할 수있는 오픈 소스 라이브러리 :

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

산출:

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

면책 조항 : 나는이 도서관의 저자입니다.


0

이 방법으로 시도하십시오!

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"]
        }]

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()}");
        }
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.