아니요, 이 기능은 현재 지원되지 않지만 vNext에 대해 고려해야 할 사항입니다. 기능 요청에 동기를 부여하는 사용 예가 있습니까?

미래로 표시.

System.NotSupportedException : The collection type 'System.Dynamic.ExpandoObject' is not supported.

@ahsonkhan GraphQL이 좋은 예입니다.

사양은 JSON을 권장하지만 응답의 특정 직렬화와 관련이 없습니다.
이것은 응답의 "데이터" 필드가 동적 유형임을 의미합니다. 유추할 수 없기 때문입니다.
ExpandoObject가 없으면 역직렬화는 JSON 생성 유형을 동적으로 만듭니다. 따라서 동적이 JToken이라는 사실을 알고 추상 동적 "데이터"에 액세스해야 합니다.

ExpandoObject를 사용하면 공통 개체처럼 동적 "데이터"에 대한 액세스를 강제할 수 있다고 생각합니다.

@ahsonkhan 또 다른 예는 우리 프로젝트의 Configuration Service입니다. MongoDB에서 컬렉션을 생성하는 REST 끝점과 같은 컬렉션을 노출합니다(단순한 더미 REST 래퍼가 아니며 나머지 컬렉션과 mongo 컬렉션에는 정확한 1-1 매핑이 없으며 특정 규칙도 지정합니다).

따라서 우리 프로젝트에서는 동적/ExpandoObject 지원이 필요합니다.

다른 마이크로서비스에서도 사용합니다.

우리는 또한 이 한계에 부딪쳤습니다. 우리의 사용 사례는 json 직렬화 전에 동적 객체를 점진적으로 구축하는 것입니다. 더 성숙한 Json.NET 직렬 변환기로 돌아갔습니다.

얘들 아

지금 산책은 무엇입니까?
어느 것을 사용할 것인지 구성할 수 있습니까?
@SidShety 님 이 말씀하신 내용이 좀 더 성숙한 것으로 돌아갔습니다. 설명해 주시겠습니까?

@MickeyReznikov : https://stackoverflow.com/questions/15455304/deserialize-a-property-as-an-expandoobject-using-json-net 또는 Google "json.net expandoobject" 참조

@MickeyReznikov , 질문에 대한 답변이 되었습니까? @SidShetye 는 인박스 라이브러리(System.Text.Json)가 아직 동적 개체를 지원하지 않기 때문에 동적 개체를 직렬화하기 위해 Newtonsoft.Json 를 사용하는 것을 의미했다고 생각합니다. asp.net 앱의 경우 다시 AddNewtonsoftJson으로 구성할 수 있습니다.

https://docs.microsoft.com/en-us/aspnet/core/migration/22-to-30?view=aspnetcore-3.0&tabs=visual-studio#jsonnet -support를 참조

이에 대한 사용 사례도 있습니다. HttpClient를 사용하여 REST API를 호출하고 응답에서 단일 속성을 검색하고 싶습니다. 응답을 구문 분석하기 위해 전용 클래스를 만들고 싶지 않습니다... JSON.NET을 사용하면 "동적"을 사용하고 선택한 속성에 액세스할 수 있습니다.

https://github.com/dotnet/corefx/issues/41472 에서 @ghost1372 :

안녕하세요 이곳이 이 질문을 하기에 좋은 곳이기를 바랍니다
동적 개체를 역직렬화할 수 없는 것 같습니다.
이 코드를 사용했지만 작동하지 않았습니다. 이 작업을 수행할 수 있는 방법이 있습니까?

var objList = System.Text.Json.JsonSerializer.Deserialize<List<dynamic>>(json);

많은 애플리케이션에서 저장 프로시저의 데이터 필드를 제어하고 jquery.jtable을 사용하여 목록 및 검색 목록 페이지를 동적으로 렌더링합니다.

ExpandoObject에 대한 JsonSerializer 기본 제공 지원이 없으면 dotnet 핵심 기본 제공 Json 직렬화를 사용할 수 없습니다.

@estiller 와 @SidShetye가 이미 언급한 것과 동일한 사용 사례를 공유합니다.
그동안 Json.NET으로 다시 전환해야 했습니다.

미래 보다 _지금_에 더 가까운 이정표를 가질 수 있습니까? 🤔

ExpandoObject는 오랫동안 BCL에 있었습니다.

ExpandoObject에 대한 대안이 있습니까?

@fatihyildizhan 아니요 대안이 없습니다.

그러나 우리는 자체 ExpandoObject 변환기를 작성했습니다. 이 기사에서 힌트를 얻을 수 있습니다. ASP.NET Core 3.0: 새 System.Text.Json에 대한 사용자 지정 JsonConverter

직렬화만 필요하므로 직렬화만 생성합니다.

나는 이것이 아직 지원되지 않는다는 것에 놀랐다.

이것을 5.0으로 옮기십시오.

5.0으로 이동하시겠습니까? 최소 1년은 기다려야 한다는 뜻인가요? JSON.Net으로 돌아가십시오.

5.0? 와우, 확실히 짜증납니다.

일시적인 문제 해결을 위해 사용자 지정 변환기와 함께 JsonDocument를 사용할 수 있지만 IDisposable입니다.

public sealed class EventObject
    {
        [JsonPropertyName("id")]
        public long Id
        {
            get; set;
        }

        [JsonPropertyName("eventData")]
        [JsonConverter(typeof(JsonDocumentConverter))]
        public System.Text.Json.JsonDocument EventData
        {
            get; set;
        }
    }

    internal sealed class JsonDocumentConverter
        : JsonConverter<System.Text.Json.JsonDocument>
    {
        public override JsonDocument Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return JsonDocument.ParseValue(ref reader);
        }

        public override void Write(Utf8JsonWriter writer, JsonDocument value, JsonSerializerOptions options)
        {
            value.WriteTo(writer);
        }
    }

System.Text.Json이 있는 경우 더 이상 다음 POST 작업을 사용할 수 없습니다.

[HttpPost]
public async Task<IActionResult> SubmitAsync(dynamic model)

대신 다음 방법을 사용해야 했지만 다운스트림 백엔드 코드에서 '모델'을 사용하는 방법은 없었습니다.

[HttpPost]
public async Task<IActionResult> SubmitAsync(JsonElement model)

'모델'은 복잡한 개체이며 개체 및/또는 기타 중첩된 복합 개체의 컬렉션을 포함할 수 있습니다. 결론을 내릴 수 있으려면 dynamic 중 객체 JsonElement , 우리는 model.GetRawText을 (전화) 및 Newtonsoft 동적 객체로 디코딩해야했다. 이 연습의 주요 목적은 프로젝트에서 Newtonsoft.json을 해제하는 것이기 때문에 이 방법은 원하는 방법이 아닙니다.

이 티켓/문제를 해결하는 것이 우리가 겪고 있는 문제에 대한 수정을 의미한다고 가정할 수 있습니까? 조금 시급한 문제인 것 같은데, 좀 더 빨리 처리할 수 있을까요?

/cc @ahsonkhan @terrajobst

.NET Core 3.0 JsonSerializer.Deserialize를 동적 개체로

ExpandoObject에 대한 JsonSerializer 지원(임시 조치)
나는 초보자, 많은 곳이 완벽하지 않습니다. 수정하는 모든 사람을 환영합니다
.net Core3 지원 안 함

Json 변환기 추가

다음을 사용하여 추가:

• System.Text.Json 사용;
• System.Text.Json.Serialization 사용;

```C#
///

        if (reader.TokenType == JsonTokenType.True)
        {
            return true;
        }

        if (reader.TokenType == JsonTokenType.False)
        {
            return false;
        }

        if (reader.TokenType == JsonTokenType.Number)
        {
            if (reader.TryGetInt64(out long l))
            {
                return l;
            }

            return reader.GetDouble();
        }

        if (reader.TokenType == JsonTokenType.String)
        {
            if (reader.TryGetDateTime(out DateTime datetime))
            {
                return datetime;
            }

            return reader.GetString();
        }

        if (reader.TokenType == JsonTokenType.StartObject)
        {
            using JsonDocument documentV = JsonDocument.ParseValue(ref reader);
            return ReadObject(documentV.RootElement);
        }
        // Use JsonElement as fallback.
        // Newtonsoft uses JArray or JObject.
        JsonDocument document = JsonDocument.ParseValue(ref reader);
        return document.RootElement.Clone();
    }

    private object ReadObject(JsonElement jsonElement)
    {
        IDictionary<string, object> expandoObject = new ExpandoObject();
        foreach (var obj in jsonElement.EnumerateObject())
        {
            var k = obj.Name;
            var value = ReadValue(obj.Value);
            expandoObject[k] = value;
        }
        return expandoObject;
    }
    private object? ReadValue(JsonElement jsonElement)
    {
        object? result = null;
        switch (jsonElement.ValueKind)
        {
            case JsonValueKind.Object:
                result = ReadObject(jsonElement);
                break;
            case JsonValueKind.Array:
                result = ReadList(jsonElement);
                break;
            case JsonValueKind.String:
                //TODO: Missing Datetime&Bytes Convert
                result = jsonElement.GetString();
                break;
            case JsonValueKind.Number:
                //TODO: more num type
                result = 0;
                if (jsonElement.TryGetInt64(out long l))
                {
                    result = l;
                }
                break;
            case JsonValueKind.True:
                result = true;
                break;
            case JsonValueKind.False:
                result = false;
                break;
            case JsonValueKind.Undefined:
            case JsonValueKind.Null:
                result = null;
                break;
            default:
                throw new ArgumentOutOfRangeException();
        }
        return result;
    }

    private object? ReadList(JsonElement jsonElement)
    {
        IList<object?> list = new List<object?>();
        foreach (var item in jsonElement.EnumerateArray())
        {
            list.Add(ReadValue(item));
        }
        return list.Count == 0 ? null : list;
    }
    public override void Write(Utf8JsonWriter writer,
        object value,
        JsonSerializerOptions options)
    {
       // writer.WriteStringValue(value.ToString());
    }
}

## How to Use?

```C#
var serializerOptions = new JsonSerializerOptions
{
    Converters = { new DynamicJsonConverter() }
};
return JsonSerializer.Deserialize<dynamic>("{OK:"200"}", serializerOptions);

@tchivs , 귀하의 솔루션이 저에게
c# var serializerOptions = new JsonSerializerOptions(); serializerOptions.Converters.Add(new DynamicJsonConverter()); return JsonSerializer.Deserialize<dynamic>("{OK:"200"}", serializerOptions);

JsonElement 유형을 사용해 보십시오.

public JsonElement MyProperty {get; set;}

@tchivs , 코드를 일부 수정했습니다. EDennis.DynamicDeserialization 에 코드(샘플 콘솔 프로젝트에 있음)를 게시했습니다.

더 복잡한 개체와 다양한 시나리오에서 이 접근 방식을 테스트할 것입니다(예: 기존의 완전한 형식의 EF Core 엔터티를 패치하는 데 사용되는 동적 개체의 역직렬화, 테스트 사례를 위한 json 개체 및 배열의 ​​역직렬화). 이 기능이 유용하거나 문제가 있는 경우 알려주십시오.

커뮤니티 해결 방법에 감사드립니다. 마이크로소프트가 합리적인 시간 내에 이 기능을 내놓을 수 없다는 것은 놀라운 일입니다. 일종의 동적 개체 없이 GraphQL 응답으로 작업하면 장황하고 보기 흉한 코드가 많이 생성됩니다. 또는 깊이 중첩된 속성의 존재 여부를 확인하는 것만으로도 충분합니다.

나는 주석 스레드를 읽었고 대부분은 역직렬화에 중점을 두고 있습니다. 동적 개체의 직렬화도 분명히 자동으로 "실패"하는 문제에 직면하고 있습니다. 내 시나리오를 재현하기 위해 다음과 같은 최소한의 재현을 생각해 냈습니다.

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Text.Json;

namespace SampleConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic d = new CustomDynamicObject();
            d.AProperty = 10;
            var s = JsonSerializer.Serialize(d);

            Console.WriteLine(s);
            Console.Read();
        }
    }

    class CustomDynamicObject : DynamicObject 
    {
        private readonly IDictionary<string, object> properties = new Dictionary<string, object>();

        public override bool TryGetMember(GetMemberBinder binder, out object result) => properties.TryGetValue(binder.Name, out result);

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            properties[binder.Name] = value;
            return true;
        }

        public override IEnumerable<string> GetDynamicMemberNames()
        {
            foreach (var item in properties.Keys)
            {
                yield return item;
            }
        }
    }
}

s 실행 시 {} 이므로 직렬화는 실패하지 않지만 빈 json 객체를 생성합니다.

이것이 올바른 문제입니까? 아니면 다른 것을 올리거나 팔로우해야 하나요?

이것이 올바른 문제입니까? 아니면 다른 것을 올리거나 팔로우해야 하나요?

이것은 올바른 문제입니다. 동일한 기능의 두 절반에 대해 하나를 열 필요가 없습니다. 이 문제는 expando 개체에 대한 지원 추가에 관한 것입니다(양쪽 모두 직렬화 및 역직렬화를 의미함).

저는 오늘 이 문제를 만났습니다. JsonElement 폐기된 JsonDocument 에 의존하지 않으면 JsonElement 가 잘 작동한다고 말하고 싶었습니다. 이 문제를 해결할 수 있는 한 가지 방법은 JsonDocument 대한 소멸자를 구현하여 모든 JsonElement 개체가 수집되면 폐기를 나중에 연기할 수 있도록 하는 것입니다.

또한 동적 개체가 필요했습니다. 그러나 아직 구현되지 않았습니다. 내 해결책은 사전을 사용하는 것이 었습니다.
JsonSerializer.Deserialize<Dictionary<string, string>>(response)
그런 다음 필요한 키를 찾습니다. :)

제 정신을 위해 - 문제가 5.0, 특히 ExpandoObject 지원 또는 동적 개체로 역직렬화하는 기능에 대한 범위입니까? 여기의 대화가 모두 문제 제목과 일치하지 않는 것 같으며 나는 확실히 후자가 필요합니다. 제 경우에는 중첩된 동적, 특히 List<Dictionary<string, dynamic>> 역직렬화하고 있습니다. 지금은 Newtonsoft로 다시 전환했습니다.

@tchivs 유용한 코드의 일부 C# 8 구문 설탕 모드를 공유하고 싶었습니다. :)

/// <summary>
/// Temp Dynamic Converter with c# 8
/// by:[email protected]
/// </summary>
public class DynamicJsonConverter : JsonConverter<dynamic>
{
    public override dynamic Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        => reader.TokenType switch
        {
            JsonTokenType.True => true,
            JsonTokenType.False => false,
            JsonTokenType.Number => reader.TryGetInt64(out long l) ? 1 : reader.GetDouble(),
            JsonTokenType.String => reader.TryGetDateTime(out DateTime datetime) ? datetime.ToString() : reader.GetString(),
            JsonTokenType.StartObject =>  ReadObject(JsonDocument.ParseValue(ref reader).RootElement),
            // Use JsonElement as fallback.
                _ =>JsonDocument.ParseValue(ref reader).RootElement.Clone()
        };

    private object ReadObject(JsonElement jsonElement)
    {
        IDictionary<string, object> expandoObject = new ExpandoObject();
        foreach (var obj in jsonElement.EnumerateObject())
        {
            var k = obj.Name;
            var value = ReadValue(obj.Value);
            expandoObject[k] = value;
        }
        return expandoObject;
    }
    private object? ReadValue(JsonElement jsonElement)
        =>
         jsonElement.ValueKind switch
        {
            JsonValueKind.Object => ReadObject(jsonElement),
            JsonValueKind.Array => ReadList(jsonElement),
            JsonValueKind.String => jsonElement.GetString(),
            JsonValueKind.Number =>  jsonElement.TryGetInt64(out long l) ? 1 :0,
            JsonValueKind.True => true,
            JsonValueKind.False =>false,
            JsonValueKind.Undefined => null,
            JsonValueKind.Null => null,
                _ => throw new ArgumentOutOfRangeException()
        };

    private object? ReadList(JsonElement jsonElement)
    {
        var list = new List<object?>();
        jsonElement.EnumerateArray().ToList().ForEach(j => list.Add(ReadValue(j)));
        return list.Count == 0 ? null : list;
    }

    public override void Write(Utf8JsonWriter writer,
        object value,
        JsonSerializerOptions options)
        {
        // writer.WriteStringValue(value.ToString());
        }
}

@rs38 여기 코드에 감사드립니다. 정확히 제가 필요로 하는 것이었습니다. 매우 미묘하지만 중요한 변화가 필요함을 지적하고 싶었습니다. "숫자" 유형을 구문 분석하는 두 줄은 압축된 버전에서 올바르지 않습니다.

JsonTokenType.Number => reader.TryGetInt64(out long l) ? 1 : reader.GetDouble(),

해야한다

JsonTokenType.Number => reader.TryGetInt64(out long l) ? l : reader.GetDouble(),

JsonValueKind.Number => jsonElement.TryGetInt64(out long l) ? 1 :0,

해야한다

JsonValueKind.Number => jsonElement.TryGetInt64(out long l) ? l :0,

@layomia 심각하지 않습니다. 지원은 오래전에 이루어졌어야 했습니다(사실 System.Text.Json은 내 생각에 그것 없이는 시작되지 말았어야 했습니다)! 그리고 우리는 기한도 없습니다!

내 시나리오는 CosmosDB에 관한 것입니다. 이 JsonSerializer를 사용하는 새로운 .NET SDK를 사용하여 쿼리하고 있으며 스키마가 없는 데이터베이스이므로 수행해야 하는 데이터베이스 데이터의 각 프로젝션에 대한 클래스를 만들고 싶지 않습니다(다양한 쿼리가 있음) .
동적 개체 목록으로 쿼리 결과가 필요합니다.

@SocVi100 이 문제에 대해 Microsoft에 희망을 두지 마십시오. Newtonsoft의 Json.net을 사용하는 것이 좋습니다. @layomia 는 가까운 장래의 통합에 대한 모든 희망을

왜 기여하지 않습니까? 그것을 구현하고 PR을 넣어!

https://github.com/dotnet/runtime/blob/master/docs/coding-guidelines/adding-api-guidelines.md
https://github.com/dotnet/runtime/blob/master/docs/area-owners.md (리드:
@ericstj |, 소유자: @layomia @steveharter @jozkee)

왜 기여하지 않습니까? 그것을 구현하고 PR을 넣어!

내가 할 수 있었으면 좋겠어.

내 시나리오는 CosmosDB에 관한 것입니다. 이 JsonSerializer를 사용하는 새로운 .NET SDK를 사용하여 쿼리하고 있으며 스키마가 없는 데이터베이스이므로 수행해야 하는 데이터베이스 데이터의 각 프로젝션에 대한 클래스를 만들고 싶지 않습니다(다양한 쿼리가 있음) .
동적 개체 목록으로 쿼리 결과가 필요합니다.

CosmosClientBuilder.WithCustomSerializer 를 사용하여 다른 직렬 변환기를 구성할 수 있습니다.

다음은 예입니다. CosmosJsonNetSerializer

이 기능을 5.0에 맞출 수 없습니다. 나머지 5.0 기능 작업과 함께 우선 순위를 지정해야 했지만 이 작업은 적합하지 않았습니다. FWIW 이것은 컷 라인에 매우 가까웠으므로 늦은 움직임입니다.

@layomia 는 가까운 장래의 통합에 대한 모든 희망을

@RobbyDeLaet 이 토론을 건설적으로 유지할 수 있습니까? 우리는 디자인 원칙을 유지하면서 가장 많이 요청한 고객 기능에 응답하기 위해 최선을 다하려고합니다. Newtonsoft.Json의 기능 패리티와 관련하여 다음과 같이 설명 합니다.

System.Text.Json은 주로 성능, 보안 및 표준 준수에 중점을 둡니다. 일부 시나리오의 경우 System.Text.Json에는 기본 제공 기능이 없지만 권장되는 해결 방법이 있습니다. 애플리케이션이 누락된 기능에 의존하는 경우 문제를 제출하여 시나리오에 대한 지원을 추가할 수 있는지 알아보십시오.

우리는 Newtonsoft.JSON을 대체하는 것을 목표로 하지 않습니다. 효과가 있으면 계속 사용하십시오. 성능, 보안, 표준 준수 및 계층화에서 달성한 이점을 유지하면서 System.Text.Json을 최대한 유용하게 만들기 위해 최선을 다할 것입니다. 시간이 지남에 따라 가능한 한 많은 사람들이 사용할 수 있기를 바랍니다. 저는 여기에서 관심을 받고 있으며 앞으로 이 일에 집중할 것입니다.

제안해 주셔서 감사합니다. 나는 마침내 역직렬화를 위해서만 Newtonsoft 직렬 변환기를 사용하여 중간에 갔지만 여전히 테스트해야 합니다. CosmosDB의 기본 직렬 변환기에서 ExpandoObject 지원을 받는 것이 너무 오래 지속되지 않기를 바랍니다. 따라서 이전 직렬 변환기를 제거할 수 있습니다.
@RobbyDeLaet , 의견 주셔서 감사합니다! 나는 마이크로소프트가 구현하는 것에 대해 별로 기대하지 않는다. 나는 그것에 대해 너무 많이 좌절감을 느꼈다. 프리랜서 개발자로서 저는 문자 그대로 CosmosDB, EntityFramework 및 Identity 인프라에 필수 기능이 구현되기를 몇 년 동안 기다렸는데, 그들은 우리를 무시하고 제멋대로 움직였습니다. 그들이 UserVoice에 얼마나 많은 투표를 했는지는 중요하지 않습니다. 그러한 기능은 자체 개발에 필요하지 않으므로 범위를 벗어납니다 ...
문제는 항상 동일합니다. 너무 많은 마케팅 = 너무 많은 기대

이 기능이 필요한 사람들을 돕기 위해 위의 코드 샘플을 참조하여 차단을 해제하세요.

• @tchivs에서 (개체에는 ExpandoObject List<object> , 컬렉션에는
• @denmitchell에서 ( ExpandoObject 대신 개체에 대해 IL Emit 사용)

이 기능에 대한 요구 사항을 지원하기 위해 새로운 사용자 지정 변환기 샘플을 제공하고 준비가 되면 여기에 링크할 것입니다. 그 후에 Newtonsoft 해결 방법 섹션에 해당 샘플을 추가 @tdykstra

아직 논의되지 않은 한 가지 세부 사항은 dynamic 하려면 매우 큰 System.Linq.Expressions.dll 어셈블리에 대한 참조가 필요하다는 것입니다. 이 합병증은 우리가 새 어셈블리 (예에서 동적 변환을 추가 미래에 의미 System.Text.Json.Converters.dll 사람들을 위해 유료로 플레이를 얻기 위해) 이러한 자체에 포함 된 응용 프로그램 또는 Blazor로 배포 크기 (약 치료가 클라이언트 앱).

제 정신을 위해 - 문제가 5.0, 특히 ExpandoObject 지원 또는 동적 개체로 역직렬화하는 기능에 대한 범위입니까? 여기의 대화가 모두 문제 제목과 일치하지 않는 것 같으며 나는 확실히 후자가 필요합니다. 제 경우에는 중첩된 동적, 특히 List<Dictionary<string, dynamic>> 역직렬화하고 있습니다. 지금은 Newtonsoft로 다시 전환했습니다.

이제 중첩된 개체를 역직렬화하기 위해 구현한 이전 함수를 테스트하고 있으며 이 항목에서 "valueKind"로 언급된 동일한 문제를 확인하고 있습니다.

새로운 neetonsoft.json 패키지를 사용하여 이 문제를 해결할 수 있는 방법이 있습니까? 위의 코드는 루트 수준 개체에 대해 작동했지만 중첩 개체에는 작동하지 않았기 때문입니다.

@ericstj 죄송합니다. 제 반응이 너무 부정적이고 가혹했을 수도 있지만 @SocVi100 과 마찬가지로 저는 프리랜스 개발자이며 때로는 좌절감이 우위를 점하기도 합니다. 그러나 적어도 여기에서 논의가 시작되었습니다. 응답해 주셔서 감사합니다. 이제 이 요청의 상태에 대한 명확한 메시지를 받았습니다.

제 정신을 위해 - 5.0, 특히 ExpandoObject 지원 또는 동적 개체로 역직렬화하는 기능에 대한 문제입니다.

원하는 의미 체계에 동적 유형이 있다고 가정합니다. 따라서 역직렬화 후에 모든 속성(중첩 포함)에 늦은 바인딩 방식으로 액세스할 수 있습니다.

dynamic obj = JsonSerializer.Deserialize<dynamic>(json);
string s = obj.MyChildProperty.MyStringList[2];

원하는 의미 체계가 ExpandoObject 명시적으로 지원한다고 가정합니다.

ExpandoObject expando = JsonSerializer.Deserialize<ExpandoObject>(json);
dynamic obj = expando;
string s = obj.MyChildProperty.MyStringList[2];

그래서 범위에 대한 나의 이해:

• Deserialize<dynamic>(json) 는 기본, 컬렉션 또는 개체를 반환합니다. 여기서 개체는 ExpandoObject 있지만 구현에 따라 IDynamicMetaObjectProvider 또는 JITed 유형이 될 수 있습니다. 이것은 항상 JsonElement 반환하는 오늘과 다릅니다.
• Deserialize<ExpandoObject>(json) ( IDynamicMetaObjectProvider 를 구현함)은 적절한 ExpandoObject 를 생성해야 하며 이는 dynamic 와 함께 사용될 수 있습니다. 이것은 루트 속성에 대한 expando 속성만 생성하고 모든 중첩 속성에 대한 JsonElement 인스턴스만 생성하는 오늘날과 다릅니다.
• Serialize<ExpandoObect>() 는 예상대로 작동합니다
• Serialize<IDynamicMetaObjectProvider ()>는 ExpandoObject 가 사용되지 않는 시나리오가 있는지 여부에 따라 구현될 수도 있고 구현되지 않을 수도 있습니다.

3.0 - 5.0의 의미:

• ExpandoObject 직렬화는 ExpandoObject 가 IDictionary<string, object> ExpandoObject 구현하고 STJ가 각 object 값이 프리미티브, 컬렉션 또는 객체인지에 상관없이 올바르게 직렬화하기 때문에 작동합니다.
• ExpandoObject 일종의 작업으로 역직렬화하지만 루트 속성만 "적절한" expando 속성입니다. 모든 중첩 속성은 JsonElement 이므로 프로그래밍 모델에 불일치가 있으므로 사용자 지정 변환기를 사용하지 않는 한 ExpandoObject 역직렬화를 피해야 합니다.

3.0-5.0에 대한 옵션:

• 위의 게시물에서 언급한 대로 ExpandoObject 및\또는 object 대한 사용자 정의 변환기를 작성하십시오. 6.0 기능에 이상적으로 매핑되는 새 샘플에 대한 링크를 곧 제공하겠습니다.
• 당신은 단지 직렬화, 역 직렬화하지 않으면, 당신이 사용할 수있는 ExpandoObject (또는 dynamic 유형을 기반으로하는 경우 ExpandoObject ). ExpandoObject 역직렬화하면 STJ에서 오늘날 불일치 문제가 있으므로 역직렬화하는 경우 ExpandoObject 는 권장되지 않습니다.
• 동적 개체 대신 JsonElement 사용합니다. JsonElement 는 JSON이 매핑되는 유형을 "추측"하지 않으므로 GetString(), GetInt32() 등을 호출하여 명시적이어야 합니다.

또한 구현에 따라 사용자 지정 변환기의 구현은 역직렬화 중에 JSON이 매핑되는 CLR 유형에 대해 약간의 "추측"이 있음을 의미할 수 있습니다. 예를 들어 JSON 문자열은 DateTime 또는 string 에 매핑될 수 있고 JSON 번호는 double 또는 long 매핑될 수 있으며 JSON 배열 유형을 결정해야 합니다. 이것은 Newtonsoft 의미론과 비교하고 조사해야 합니다. 또한 속성이 object 유형(오늘날 JsonElement )

다음은 3.0 - 5.0 STJ 의미 체계의 몇 가지 예입니다.

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Diagnostics;
using System.Linq;
using System.Text.Json;

namespace ConsoleApp
{
    class Program
    {
        const string ExpectedJson = "{\"A\":\"A\",\"B\":[1,2],\"C\":42,\"D\":\"2020-01-01T00:00:00\",\"E\":{\"A_Child\":\"A_Child\"}}";

        static void Main(string[] args)
        {
            DateTime dateTime = new DateTime(2020, 1, 1);

            dynamic myDynamicChild = new ExpandoObject();
            myDynamicChild.A_Child = "A_Child";

            dynamic myDynamic = new ExpandoObject();
            myDynamic.A = "A";
            myDynamic.B = new List<int>() { 1, 2 };
            myDynamic.C = 42;
            myDynamic.D = dateTime;
            myDynamic.E = myDynamicChild;

            // Verify we can call late-bound property.
            int c = myDynamic.C;
            Debug.Assert(c == 42);

            // STJ can serialize with ExpandoObject since it implements IDictionary<string, object>.
            string json = JsonSerializer.Serialize<ExpandoObject>(myDynamic);
            Debug.Assert(json == ExpectedJson);

            // Using 'dynamic' against backing ExpandoObject works.
            json = JsonSerializer.Serialize<dynamic>(myDynamic);
            Debug.Assert(json == ExpectedJson);

            // Deserialize with <dynamic>, <object> and <JsonElement>.
            // For 5.0, using one of these is recommended over ExpandoObject because the programming model will be
            // consistent for the root type and all nested types.
            // Using <JsonElement> makes it clear and non-abiguous.
            // Using <object> by default uses 'JsonElement', but can be overridden by a custom converter.
            // Using <dynamic> uses 'object' which uses 'JsonElement'.
            {
                dynamic d = JsonSerializer.Deserialize<dynamic>(json);
                VerifyJsonElement(d);

                try
                {
                    // We will get an exception here if we try to access a dynamic property since 'object' is deserialized
                    // as a JsonElement and not an ExpandoObject.
                    c = d.C;
                    Debug.Fail("Should have thrown Exception!");
                }
                catch (Exception ex)
                {
                    Debug.Assert(ex.Message == "'System.Text.Json.JsonElement' does not contain a definition for 'C'");
                }

                // Serializing with <object> creates a JsonElement by default (can be changed by a custom converter).
                object o = JsonSerializer.Deserialize<object>(json);
                VerifyJsonElement((JsonElement)o);

                // Serialize with explicit <JsonElement>.
                JsonElement e = JsonSerializer.Deserialize<JsonElement>(json);
                VerifyJsonElement(e);
            }

            // Deserialize with ExpandoObject. This creates an ExpandoObject with the root Type having Expando-properties
            // but the value of those properties will be JsonElement. All other nested properties\objects\collections will
            // also be JsonElement. Due to the inconsistency of having only root-level Expando-properties (such as A_Child),
            // deserializing as ExpandoObject is not recommended (unless a ExpandoObject custom converter is used).
            {
                // When STJ deserializes, it creates ExpandoObjects via IDictionary<string, object> where 'object' is JsonElement.
                ExpandoObject expando = JsonSerializer.Deserialize<ExpandoObject>(json);
                Debug.Assert(((IDictionary<string, object>)expando).Keys.Count == 5);
                myDynamic = expando;

                JsonElement jsonElement = myDynamic.A;
                Debug.Assert(jsonElement.GetString() == "A");

                jsonElement = myDynamic.B;
                Debug.Assert(jsonElement.EnumerateArray().Count() == 2);

                jsonElement = myDynamic.C;
                Debug.Assert(jsonElement.GetInt32() == 42);

                jsonElement = myDynamic.D;
                Debug.Assert(jsonElement.GetDateTime() == dateTime);

                jsonElement = myDynamic.E;
                // Here we have an inconsistency. Nested object property must use JsonElement (not a dynamic property).
                Debug.Assert(jsonElement.GetProperty("A_Child").GetString() == "A_Child");

                // Re-serialize works as expected.
                json = JsonSerializer.Serialize<ExpandoObject>(myDynamic);
                Debug.Assert(json == ExpectedJson);

                // Re-serialize works as expected; dynamic works here since backed by ExpandoObject in this example.
                json = JsonSerializer.Serialize<dynamic>(myDynamic);
                Debug.Assert(json == ExpectedJson);
            }

            void VerifyJsonElement(JsonElement elem)
            {
                // Verify JsonElement
                Debug.Assert(elem.GetProperty("A").GetString() == "A");
                Debug.Assert(elem.GetProperty("B").EnumerateArray().Count() == 2);
                Debug.Assert(elem.GetProperty("C").GetInt32() == 42);
                Debug.Assert(elem.GetProperty("D").GetDateTime() == dateTime);
                Debug.Assert(elem.GetProperty("E").GetProperty("A_Child").GetString() == "A_Child");

                // Re-serialize
                json = JsonSerializer.Serialize<dynamic>(elem);
                Debug.Assert(json == ExpectedJson);

                json = JsonSerializer.Serialize<JsonElement>(elem);
                Debug.Assert(json == ExpectedJson);
            }
        }
    }
}

@rs38 @ryan-hollister-q2가 지적한 내용을 기반으로 코드 조각을 수정할 수 있습니까?

약속한 대로 동적 구현 샘플을 제공하는 PR은 https://github.com/dotnet/runtime/pull/42097에 있습니다.

@rs38 @ryan-hollister-q2가 지적한 내용을 기반으로 코드 조각을 수정할 수 있습니까?

그것은 내 코드가 아니 었고 이 스레드의 앞부분에서 했을 뿐입니다 .