Runtime: 새로운 Asp.NET Core 3.0 Json은 사전을 직렬화하지 않습니다.<key/>

"지원되지 않는 예외" 오류는 모두 기본 제공 직렬 변환기 내의 제한 사항이며 의도적으로 설계된 것입니다(적어도 3.0에서 제공되는 경우).

이 지원은 언제 추가되나요? 이것은 Json.net 및 기타 직렬 변환기에서 잠시 동안 지원되었기 때문에 이것이 레이더에 있기를 바랍니다.
Json.net을 다시 사용하도록 선택할 수 있다는 사실에 감사드립니다. 이에 대해 대단히 감사합니다!

vNext(따라서 5.0) 이상에서 지원하기 위해 우리 레이더에 있는 일련의 직렬 변환기 기능이 있으며 사용자 지정 사전 지원이 그 중 하나입니다.

Asp.NET Web Apis, 사전을 반환할 때 NotSupportedException과 함께 실패합니다.

직렬화할 때 현재 Dictionary<string, TValue> 만 지원됩니다(즉, 문자열인 TKey). 귀하의 사전은 지원되지 않는 <int, string> 입니다.
https://github.com/dotnet/corefx/blob/93d7aa1c1737b6da29d04b78557215e18eb786d4/src/System.Text.Json/tests/Serialization/DictionaryTests.cs#L385 -L390

@steveharter , @layomia - 그 동안 여기에 잠재적인 해결 방법이 있습니까? 5.0용 직렬 변환기 내에서 문자열이 아닌 키 사전에 대한 지원을 추가하려면 무엇이 필요합니까?

System.NotSupportedException: 컬렉션 형식 'Microsoft.AspNetCore.Mvc.SerializableError'가 지원되지 않습니다.

~ SerializableError와 같은 유형에 대한 지원을 추가하는 것은 내 레이더에 없었습니다. @pranavkm , @rynowak - 여기서 컨텍스트는 무엇입니까? ModelStateDictionary 익숙하지 않습니다. 이것이 사용자 정의 변환기를 사용하여 mvc 자체 내에서 지원될 수 있습니까?~

편집: 신경 쓰지 마세요. 이미 수정되었습니다.

System.NotSupportedException: 컬렉션 형식 'Microsoft.AspNetCore.Mvc.SerializableError'가 지원되지 않습니다.

이것은 알려진 문제( https://github.com/aspnet/AspNetCore/issues/11459) 로 최근에 수정되었습니다(미리 보기 8의 일부로): https://github.com/dotnet/corefx/pull/39001

@ahsonkhan 빠른 답변 감사합니다!

내가 생각할 때 키가 문자열이라는 "제한"은 실제로 의미가 있습니다. 이제 Json.net이 키를 문자열로 사용하여 json을 생성한다는 것을 알았습니다. 역직렬화하면 int를 다시 얻을 수 있습니다. 미래에 문자열이 아닌 키를 지원하는 것은 확실히 좋겠지만 쇼 스토퍼는 아닙니다.

좋아, 지원되지 않는 Mvc.SerializableError가 수정되었다는 소식을 듣게 되어 기쁩니다. Preview 8의 출시 날짜가 예상되는지에 대한 아이디어가 있습니까? 검색하고 뭔가를 찾으려고했지만 그것에 대해 아무것도 보지 못했습니다.

미리보기 8이 나오면 .net core 3 json 직렬화 라이브러리를 다시 시도하겠지만 지금은 Json.net을 고수해야 합니다.

@steveharter , @layomia - 그 동안 여기에 잠재적인 해결 방법이 있습니까? 5.0용 직렬 변환기 내에서 문자열이 아닌 키 사전에 대한 지원을 추가하려면 무엇이 필요합니까?

>

@ahsonkhan @willyt150 이에 대한 해결 방법은 JsonConverter<T> 를 구현하는 사용자 지정 변환기를 사용하는 것입니다. 여기서 T 는 Dictionary<int, string> 입니다.
몇 가지 예는 https://github.com/dotnet/corefx/issues/36639#issue -429928740을 참조

Preview 8의 출시 날짜가 예상되는지에 대한 아이디어가 있습니까?

이달 말쯤.

이에 대해 좀 더 생각해보면 기본적으로 지원하지 않을 수도 있기 때문에 당장은 제거해야 합니다.

@layomia 감사합니다. 살펴보겠습니다.

@ahsonkhan에게 감사드립니다. 수정 사항이 나오기를 기대합니다!

@namse에서 (https://github.com/dotnet/corefx/issues/40404에서):

안녕하세요. 정수 키로 Dictionary를 직렬화하려고하면 System.NotSupportedException이 발생합니다.

Dictionary에 ToString -able 키가 있는 Json 직렬화를 지원하는 것이 합리적이라고 생각합니다. 예를 들어, int 또는 boolean에 대해 ToString을 실행하면 "123" 또는 "true"가 반환됩니다. 나는 그 키가 ToString -able 키라고 생각합니다.

Verison

System.Text.Json Nuget 버전: 4.6.0-preview8.19405.3

암호

var dictionary = new Dictionary<int, string>
{
  [5] = "five"
};
JsonSerializer.Serialize(dictionary);

예상되는

"{"5": "five"}"

하지만 무슨 일이

오류 System.NotSupportedException

사실 Newtonsoft.Json을 System.Text.Json으로 변경하면 호환성 문제가 있습니다. 그들은 내가 예상한 대로 문자열을 반환합니다. System.Text.Json이 호환될 필요는 없다고 생각하지만... 아시죠?

IDictionary<TKey, TValue> 대한 직렬화 및 역직렬화를 모두 지원하는 변환기를 구현했습니다. 여기서 TKey 에는 TKey Parse(string) 정적 메서드가 있습니다.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace JsonDictionaryConverter
{
    sealed class JsonNonStringKeyDictionaryConverter<TKey, TValue> : JsonConverter<IDictionary<TKey, TValue>>
    {
        public override IDictionary<TKey, TValue> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            var convertedType = typeof(Dictionary<,>)
                .MakeGenericType(typeof(string), typeToConvert.GenericTypeArguments[1]);
            var value = JsonSerializer.Deserialize(ref reader, convertedType, options);
            var instance = (Dictionary<TKey, TValue>)Activator.CreateInstance(
                typeToConvert,
                BindingFlags.Instance | BindingFlags.Public,
                null,
                null,
                CultureInfo.CurrentCulture);
            var enumerator = (IEnumerator)convertedType.GetMethod("GetEnumerator")!.Invoke(value, null);
            var parse = typeof(TKey).GetMethod("Parse", 0, BindingFlags.Public | BindingFlags.Static, null, CallingConventions.Any, new[] { typeof(string) }, null);
            if (parse == null) throw new NotSupportedException($"{typeof(TKey)} as TKey in IDictionary<TKey, TValue> is not supported.");
            while (enumerator.MoveNext())
            {
                var element = (KeyValuePair<string?, TValue>)enumerator.Current;
                instance.Add((TKey)parse.Invoke(null, new[] { element.Key }), element.Value);
            }
            return instance;
        }

        public override void Write(Utf8JsonWriter writer, IDictionary<TKey, TValue> value, JsonSerializerOptions options)
        {
            var convertedDictionary = new Dictionary<string?, TValue>(value.Count);
            foreach (var (k, v) in value) convertedDictionary[k?.ToString()] = v;
            JsonSerializer.Serialize(writer, convertedDictionary, options);
            convertedDictionary.Clear();
        }
    }

    sealed class JsonNonStringKeyDictionaryConverterFactory : JsonConverterFactory
    {
        public override bool CanConvert(Type typeToConvert)
        {
            if (!typeToConvert.IsGenericType) return false;
            if (typeToConvert.GenericTypeArguments[0] == typeof(string)) return false;
            return typeToConvert.GetInterface("IDictionary") != null;
        }

        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
        {
            var converterType = typeof(JsonNonStringKeyDictionaryConverter<,>)
                .MakeGenericType(typeToConvert.GenericTypeArguments[0], typeToConvert.GenericTypeArguments[1]);
            var converter = (JsonConverter)Activator.CreateInstance(
                converterType,
                BindingFlags.Instance | BindingFlags.Public,
                null,
                null,
                CultureInfo.CurrentCulture);
            return converter;
        }
    }
}

시험:

class Entity
{
    public string Value { get; set; }
}
class TestClass
{
    public Dictionary<int, Entity> IntKey { get; set; }
    public Dictionary<float, Entity> FloatKey { get; set; }
    public Dictionary<double, Entity> DoubleKey { get; set; }
    public Dictionary<DateTime, Entity> DateTimeKey { get; set; }
    public Dictionary<string, Entity> StringKey { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        var options = new JsonSerializerOptions();
        options.Converters.Add(new JsonNonStringKeyDictionaryConverterFactory());
        var x = new TestClass
        {
            IntKey = new Dictionary<int, Entity> { [1] = new Entity { Value = "test" } },
            FloatKey = new Dictionary<float, Entity> { [1.3f] = new Entity { Value = "test" } },
            DoubleKey = new Dictionary<double, Entity> { [1.35] = new Entity { Value = "test" } },
            DateTimeKey = new Dictionary<DateTime, Entity> { [DateTime.Now] = new Entity { Value = "test" } },
            StringKey = new Dictionary<string, Entity> { ["test"] = new Entity { Value = "test" } }
        };

        var value = JsonSerializer.Serialize(x, options);
        Console.WriteLine(value);
        var obj = JsonSerializer.Deserialize<TestClass>(value, options);
        Console.WriteLine(JsonSerializer.Serialize(obj, options));
    }
}

결과:

{"IntKey":{"1":{"Value":"test"}},"FloatKey":{"1.3":{"Value":"test"}},"DoubleKey":{"1.35":{"Value":"test"}},"DateTimeKey":{"8/25/2019 6:47:48 PM":{"Value":"test"}},"StringKey":{"test":{"Value":"test"}}}
{"IntKey":{"1":{"Value":"test"}},"FloatKey":{"1.3":{"Value":"test"}},"DoubleKey":{"1.35":{"Value":"test"}},"DateTimeKey":{"8/25/2019 6:47:48 PM":{"Value":"test"}},"StringKey":{"test":{"Value":"test"}}}

그러나 System.Text.Json이 내부 유형 Dictionary<int, int> 허용하지 않기 때문에 Dictionary<int, Dictionary<int, int>> 와 같은 중첩 사전을 직렬화할 수 없습니다. 버그라고 생각합니다.

그러나 여전히 Dictionary와 같은 중첩 사전을 직렬화할 수 없습니다.> System.Text.Json은 내부 유형 사전을 허용하지 않기 때문에. 버그라고 생각합니다.

<string, x> 만 지원하는 것은 v3.0용으로 제공하기 위한 범위 축소로 인해 의도적으로 설계된 것입니다. 3.0 릴리스는 가장 일반적인 시나리오가 지원되는 최소한의 실행 가능한 제품입니다.

@steveharter 적어도 사용 가능한 변환기가 있을 때

.net core 3.1에서 이를 지원할 계획이 있습니까?

신규 이민자의 경우 임시 해결책은 Newtonsoft.Json 로 되돌리는 것입니다.

1. Microsoft.AspNetCore.Mvc.NewtonsoftJson 패키지 참조를 추가합니다.
2. .AddControllers() / .AddMvc() 또는 다른 조합 바로 뒤에 .AddNewtonsoftJson() 추가합니다.

@steveharter 적어도 사용 가능한 변환기가 있을 때

예, 그것은 정당한 지적입니다. 아마도 우리는 3.1에서 이 제한을 제거할 수 있을 것입니다. cc @layomia

또한 오늘날 사전 요소는 키가 문자열이기 때문에 가능한 속성처럼 직렬화된다는 점을 명확히 하기 위해서입니다. 문자열이 아닌 키를 지원하면 요소가 KeyValuePair로 직렬화됩니다.

이런, 3.0으로 업그레이드한 직후에 이 문제가 발생했습니다.

AddNewtonsoftJson으로 newton 패키지를 설치해야 했습니다.

https://github.com/dotnet/corefx/issues/41345의 @israellot 에서

var dictionary = new Dictionary<int, int>()
            {
                [0] = 1
            };

 var serialized = System.Text.Json.JsonSerializer.Serialize(dictionary);

이 간단한 직렬화는 int 키를 문자열로 직렬화하여 이전 기본 Newtonsoft json 라이브러리에서 잘 처리됩니다. System.Text.Json에서 지원되지 않는 예외가 발생합니다.

@israellot , @unruledboy 및 기타 스레드의 경우 시나리오에서 개체 모델에 정수 키가 있는 사전이 필요한 이유와 이를 Dictionary<string, TValue> 변경하면 작동하지 않는 이유에 대한 세부 정보를 제공할 수 있습니까? 요구 사항을 수집하고 수정 사항에 동기를 부여하는 데 도움이 되는 몇 가지 사용법을 보고 싶습니다.

어쨌든 문자열로 직렬화되므로 기본 사전에 대신 int32 키를 사용하려는 시나리오를 이해할 수 없습니다.

@ahsonkhan 핵심 동기는 호환성이라고 생각합니다.
이전 기본 직렬 변환기는 Newtonsoft였으므로 사용자는 임의 클래스를 직렬화 및 역직렬화하는 기능에 의존하여 전체 모델을 작성했을 수 있습니다. 2.X에서 3.0으로 마이그레이션하면 런타임 시 비호환성만 알 수 있으므로 이제 조용한 주요 변경 사항이 발생합니다.

많은 시나리오가 유선을 통한 전송으로 json을 사용하는 것과 관련이 있다고 생각합니다. 이 경우 도메인 모델은 사전일 수 있습니다.. 귀하의 제안은 별도의 DTO 객체 사전을 만드는 것으로 요약됩니다.그리고 둘 사이의 변환은 직렬 변환기와 호환되도록 다른 개체를 할당해야 하므로 다소 비효율적입니다.
직렬 변환기를 엄격히 살펴보면 사전에 문자열 키를 사용하도록 제한하는 것은 가능한 유일한 json 표현이므로 논리적입니다. 그러나 직렬 변환기가 응용 프로그램에서 역할을 한다는 점을 고려하면 가능한 한 많은 마찰을 제거하는 것이 가장 좋습니다.

버전 레이블의 일부가 json 파일을 통해 제공되는 곳에서 작성 중인 작은 프로그램에서 이 문제에 부딪쳤습니다.
레이블 부분에는 레이블 부분을 삽입할 수 있는 인덱스를 지정하는 키가 있습니다. 이것은 키가 숫자 값임을 의미합니다. 예를 들어

{
  "parts" : {
    "1" : "alpha",
    "3" : "beta"
  }
}

Newtonsoft를 사용하면 json을 Dictionary<int, string> 문제 없이 역직렬화할 수 있습니다. System.Text.Json으로 변환한 후 직렬화에 실패했습니다.

내 자신의 DictionaryConverter 및 DictionaryConverter를 만들어 이 문제를 해결했습니다. .
또한 문자열에서 정수를 역직렬화할 수 있는 간단한 변환기 를 만들었습니다.

그런 다음 직렬 변환기 옵션을 통해 등록됩니다. https://github.com/Kieranties/SimpleVersion/blob/master/src/SimpleVersion.Core/Serialization/Serializer.cs#L22

이러한 변경을 통해 사전의 키를 문자열로 직접 읽는 대신 역직렬화할 수 있습니다. 이것은 직렬화를 위해 등록된 자체 변환기를 가질 수 있는 임의 유형(예: 고유 키로 직렬화될 수 있는 열거형/유형/유형 등)이 될 키에 대한 지원을 추가로 엽니다.

공식적으로 테스트하지는 않았지만 현재 개발 내에서 이것이 문제를 해결한 것 같습니다.

TKey 대한 Dictionary<TKey,TValue> TKey 를 처리할 수 있는 사용자 지정 변환기가 생성되지 않도록 하는 모든 제한을 제거하기 위해 3.1에 대한 마일스톤을 설정합니다.

업데이트: 3.0에서 작동하는 샘플을 추가했습니다. 위에서 보고된 중첩 사전과 같은 문제를 발견하지 못했습니다.

샘플에는 두 가지 JSON 형식이 사용됩니다.

• 문자열 속성이 있는 JSON 객체: {"1":"val1","2":"val2"} TKey 는 문자열이 아니지만 {"1":"val1","2":"val2"} 입니다.
  
  
  
  • 이는 지원되는 해당 키 유형의 TryParse 메소드에 의존합니다. v3.0의 경우 TryParse 메서드는 TKey 대해 다를 수 있고 제공해야 하는 문화 설정이 있기 때문에 일반화된 TKey 에 대한 지원을 제공하는 것이 가능하지 않습니다 TryParse (일반적으로 불변). 따라서 아래 샘플은 단일 TKey 유형에 대한 것입니다.
  
  
  • Sample Dictionary<int, string> . 이것은 TValue == string 대한 간단한 예입니다.
  
  
  • Sample Dictionary<Guid, TValue> . 이것은 모든 TValue 처리할 수 있습니다.
  
  
  • Sample Dictionary<TKey, TValue> where TKey is Enum . 열거형의 경우 이것은 모든 TValue 처리할 수 있습니다.
  
  
• KeyValuePair 항목이 있는 JSON 배열: [{"Key":1,"Value":"val1"},{"Key":2,"Value":"val2"}]
  
  
  
  • Sample Dictionary<int, string> . 이것은 TValue == string 대한 간단한 예입니다.
  
  
  • Sample Dictionary<TKey, TValue> . 유형이 기본적으로 JSON으로 표시되고 TryParse 필요하지 않기 때문에 이것은 모든 TKey 및 TValue 를 처리할 수 있습니다.
  
  

이러한 샘플이 만족스러운 경우 사용자 지정 변환기가 필요하지 않은 기본 제공 지원을 제공하는지 여부를 논의하기 위해 이 문제를 5.0으로 변경하겠습니다.

고려를 위해 마일스톤을 5.0으로 설정합니다(위의 예 중 하나라도 기본적으로 작동해야 하는 경우).

또한 역직렬화는 일반 객체 유형을 일반(기본?) 유형이 아닌 JsonDocument에 매핑하는 것으로 보입니다.

예시:

string test = "[{\"id\":86,\"name\":\"test\"}]";
var SystemTextJson = System.Text.Json.JsonSerializer.Deserialize<List<Dictionary<string, object>>>(test);
var NewtonSoftJson = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Dictionary<string, object>>>(test);

SystemTextJson[0]["id"]는 다음과 같이 표시됩니다. ValueKind = Number: "86"
NewtonSoftJson[0]["id"]는 다음과 같이 표시됩니다. 86

@steveharter 해당 변환기가 있는 열거형 키 사전은 다음과 같이 직렬화됩니다.
{ "Stuff": [ { "Key": 1, "Value": "String" }, { "Key": 3, "Value": "String" }, { "Key": 2, "Value": "String" } ] }

JSON.NET은 대부분의 사람들이 예상할 것이라고 가정하는 것을 제공하지만:
{ "Stuff": { "Item1": "String", "Item2": "String", "Item3": "String" }

또한 역직렬화는 일반 객체 유형을 일반(기본?) 유형이 아닌 JsonDocument에 매핑하는 것으로 보입니다.

예, 그것은 의도된 것입니다. https://github.com/dotnet/corefx/issues/38713 참조

@steveharter 해당 변환기가 있는 열거형 키 사전은 다음과 같이 직렬화됩니다.
{ "내용": [ { "키": 1, "값": "문자열" }, { "키": 3, "값": "문자열" }, { "키": 2, "값": " 끈" } ] }
JSON.NET은 대부분의 사람들이 예상할 것이라고 가정하는 것을 제공하지만:
{ "내용": { "항목1": "문자열", "항목2": "문자열", "항목3": "문자열" }

"샘플 사전"을 사용하고 있다고 가정합니다."? 그렇다면 "Key" 및 "Value" 속성이 있는 KeyValuePair를 사용한 것입니다. 속성 이름으로 직렬화되는 TKey 기반 열거형 사전에 대한 샘플을 제공하지 않았지만 추가하는 작업을 할 것입니다.

그래, 그거야. 그리고 아 좋아, 나는 당신이 그것을 일반 사전 직렬 변환기로 의미한다고 생각했습니다.
우리가 현재 사용하고 있는 샘플이 내가 원하는 것만큼 빠르지 않은 것 같아서 사용 가능한 경우 새 샘플을 보고 싶습니다.

@roguecode 다음은 Dictionary<TKey, TValue> 대한 Enum 샘플 입니다. 여기서 TKey는 Enum이고 KeyValuePair 대신 "속성" JSON 구문을 사용합니다. 또한 이 새 샘플을 포함하도록 위의 샘플 목록을 업데이트했습니다.

안녕하세요, 비슷하지만 다른 것이 있습니다. 다른 곳을 볼 수 있는지 알려주실 수 있는지 궁금합니다.

Newtonsoft.Json: 12.0.2
Microsoft.AspNetCore.Mvc.NewtonsoftJson: 3.0.0

3.0으로 실행 시작:

                .AddMvc(mvcOptions => mvcOptions.EnableEndpointRouting = false)
                .SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
                .AddNewtonsoftJson();

이 problemDetails 개체가 있는 경우:

// problemDetails has 2 extension items
{Microsoft.AspNetCore.Mvc.ValidationProblemDetails}
    Detail: "Please refer to the 'errors' property for additional details."
    Errors: Count = 1
    Extensions: Count = 2
    Instance: "/api/test/complex-binding-from-query"
    Status: 400
    Title: "One or more validation errors occurred."
    Type: "https://tools.ietf.org/html/rfc7231#section-6.5.1"

2.2에서 Newtonsoft.Json.JsonConvert.SerializeObject(problemDetails) 실행하면

{"errors":{"Int":["The value 'a' is not valid for Int."]},"type":"https://tools.ietf.org/html/rfc7231#section-6.5.1","title":"One or more validation errors occurred.","status":400,"detail":"Please refer to the 'errors' property for additional details.","instance":"/api/test/complex-binding-from-query","traceId":"0HLQQ40AFBJNG","correlationId":"0HLQQ40AFBJNG"}

3.0에서는 다음을 반환합니다.

{"Errors":{"param":["The value 'a' is not valid."]},"Type":"https://tools.ietf.org/html/rfc7231#section-6.5.1","Title":"One or more validation errors occurred.","Status":400,"Detail":"Please refer to the 'errors' property for additional details.","Instance":"/bad-request","Extensions":{"traceId":"|d0d40f80-48b6c9184401b0e1.","correlationId":"0HLQR10NSMRGD:00000009"}}

3.0 버전 직렬화 문자열에는 IDictionary가 포함됩니다.속성 이름 Extensions 이며 3.0에서 해당 문자열을 올바르게 역직렬화할 수 있습니다. 이 속성 이름은 2.x 버전에서 제외된 것을 볼 수 있습니다.

문제는 아래 코드에서 BadRequestObjectResult 사용하여 필터에서 응답이 반환될 때 발생하는 3.0 직렬화입니다.

public sealed class ProblemDetailsResultFilterAttribute : Attribute, IAlwaysRunResultFilter
{
        public void OnResultExecuting(ResultExecutingContext context)
        {
             context.Result = new BadRequestObjectResult(problemDetails);
        }
}

..., 반환되는 응답 내용은 2.2 버전과 동일한 형식( Extensions 속성 이름 제외)이므로 Extensions 속성이 빈 컬렉션으로 역직렬화됩니다(사용 Newtonsoft.Json.JsonConvert.DeserializeObject<ValidationProblemDetails>() )

여하튼 이 직렬화는 우리가 역직렬화하려는 Newtonsoft 라이브러리와 동일한 직렬화를 사용하지 않습니다.

고려해주셔서 감사합니다!

비슷하면서도 다른게 있어요

@ts46235 이 문제는 현재 문제와 다르기 때문에 새 문제를 열어 주시겠습니까?

@ts46235 여기에서 연 다른 문제( https://github.com/aspnet/AspNetCore/issues/16618) 에서 귀하의 질문에 답변했습니다

Core 3.1로 업데이트되었지만 여전히 수정되지 않음

방금 3.1로 업그레이드하고 이것에 부딪쳤습니다. JSON.NET으로 돌아가기 ... (GUID 키 사용)

닷넷 코어 3.1
사전

나도 방금 이것을 쳤고 다른 사람들이 지적했듯이 컴파일 타임에는 이것을 볼 수 없기 때문에 무서운 침묵의 제한입니다. 제 경우에는 Dictionary<int, List<string>> 를 직렬화하고 싶습니다. 이것은 특별히 이국적이라고 생각하지 않습니다.

그들은 그것을 고쳐야 하지만 나는 예전 포맷터, 바이너리 포맷터 early newtsoft, 사전에 있는 사전, 인터페이스가 있는 사전을 사용해도 이 시간에 몇 번이고 다시 보게 됩니다. 그들은 그것을 고쳐야 하지만 당신이 문제를 원하지 않는다면 사람들은 문제를 요구하는 직렬화 계약에 사전과 같은 복잡한 객체를 두어서는 안 됩니다. newtsoft는 사람들을 망쳤습니다. 이것을 매핑하기 위해 직렬 변환기의 사용자 정의에 의존하고 있는 Dictionary count 등의 모든 공용 속성을 살펴보십시오.

불행히도 C#에는 속성 이름에 대한 간단한 유형이 없으므로 사전이 강제 적용됩니다. 그래서 그냥 슬프다..

다음은 해결 방법이지만 완전한 솔루션은 아닙니다.

   [JsonConverter(typeof(DictionaryConverter))]
   public Dictionary<string, object> ExtraProperties { get; set; } = new Dictionary<string, object>();

public class DictionaryConverter : JsonConverter<Dictionary<string, object>>
{
    public override Dictionary<string, object> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        var dictionary = JsonSerializer.Deserialize<Dictionary<string, object>>(ref reader, options);

        foreach (string key in dictionary.Keys.ToList())
        {
            if (dictionary[key] is JsonElement je)
            {
                dictionary[key] = Unwrap(je);
            }
        }

        return dictionary;
    }

    public override void Write(Utf8JsonWriter writer, Dictionary<string, object> value, JsonSerializerOptions options)
        => JsonSerializer.Serialize(writer, value, options);

    private static object Unwrap(JsonElement je)
    {
        return je.ValueKind switch
        {
            JsonValueKind.String => je.ToString(),
            JsonValueKind.Number => je.TryGetInt64(out var l) ? l : je.GetDouble(),
            JsonValueKind.True => true,
            JsonValueKind.False => false,
            JsonValueKind.Array => je.EnumerateArray().Select(Unwrap).ToList(),
            JsonValueKind.Object => je.EnumerateObject().ToDictionary(x => x.Name, x => Unwrap(x.Value)),
            _ => null
        };
    }

아마도 시리얼 라이저는 OOTB를 추가 할 수 있습니다 일반적인 유형 (의 일부), 예에 대한 지원 이 목록 , 또한 이러한 유형 중 하나가 .IsAssignableFrom(systemDotObjectInstance.GetType()) 지원하기 Dictionary<<ins i="7">object</ins>, V> .

다음은 사전에서 문자열이 아닌 TKey 유형에 대한 지원을 추가하기 위한 제안입니다.
https://github.com/dotnet/runtime/pull/32676

어떤 생각이나 우려 사항이 있으면 알려주십시오.

특히 @Jozkee 가 사전 키를 지원할 계획인 유형 세트에 대한 피드백을 제공하세요. 특히 지원해야 할 다른 유형이 필요한 경우(기본적으로 모든 기본 제공 기본 숫자 유형, 열거형 및 기타 몇 가지):
https://github.com/dotnet/runtime/blob/a5d96c0e280b56412d4614848f5ee3b1e0d7f216/src/libraries/System.Text.Json/docs/KeyConverter_spec.md#keyconverter

사전

@andrew-vdb, 임의 개체 키의 직렬화 지원은 계속 지원되지 않을 것입니다. 그러나 개체 키의 런타임 유형이 "새로 지원되는" 유형 중 하나인 경우 기능이 완료되면 직렬화가 작동합니다. 그러나 역직렬화는 박스형 JsonElement로 유지됩니다(다른 동작을 선택하기 위한 이 관련 문제가 해결될 때까지): https://github.com/dotnet/runtime/issues/29960

@Jozkee TValue 대해 활성화된 유형은 무엇입니까? 아마도 현재 독립 실행형 개체로 직렬화할 수 있는 것은 무엇입니까?

아마도 현재 독립 실행형 개체로 직렬화할 수 있는 것은 무엇입니까?

예.

https://docs.microsoft.com/en-gb/dotnet/standard/serialization/system-text-json-converters-how-to#support -dictionary-with-non-string-key

또한 역직렬화는 일반 객체 유형을 일반(기본?) 유형이 아닌 JsonDocument에 매핑하는 것으로 보입니다.

예시:

string test = "[{\"id\":86,\"name\":\"test\"}]";
var SystemTextJson = System.Text.Json.JsonSerializer.Deserialize<List<Dictionary<string, object>>>(test);
var NewtonSoftJson = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Dictionary<string, object>>>(test);

SystemTextJson[0]["id"]는 다음과 같이 표시됩니다. ValueKind = Number: "86"
NewtonSoftJson[0]["id"]는 다음과 같이 표시됩니다. 86

언급된 모든 문제 중에서 이것이 나를 가장 괴롭히는 문제입니다. 목록또는 T[] 또는 사전Json이 가지고 있는 몇 가지 유형에서 CLR 유형으로 직접 매핑할 수 있는 모든 유형에 대해 적절하게 역직렬화해야 합니다.

3.0 릴리스는 가장 일반적인 시나리오가 지원되는 최소한의 실행 가능한 제품입니다.

나는 어떻게 목록> 가장 일반적인 시나리오 중 하나가 아닙니다.

[// N objects
{"a":4},
{"b","Bla"},
]

이것은 또한 System.Text.JsonElement로 역직렬화하기 때문에 이중(숫자) 및 문자열(문자열)이 예상됩니다.

버전 레이블의 일부가 json 파일을 통해 제공되는 곳에서 작성 중인 작은 프로그램에서 이 문제에 부딪쳤습니다.
레이블 부분에는 레이블 부분을 삽입할 수 있는 인덱스를 지정하는 키가 있습니다. 이것은 키가 숫자 값임을 의미합니다. 예를 들어

{
  "parts" : {
    "1" : "alpha",
    "3" : "beta"
  }
}

Newtonsoft를 사용하면 json을 Dictionary<int, string> 문제 없이 역직렬화할 수 있습니다. System.Text.Json으로 변환한 후 직렬화에 실패했습니다.

내 자신의 DictionaryConverter 및 DictionaryConverter를 만들어 이 문제를 해결했습니다. .
또한 문자열에서 정수를 역직렬화할 수 있는 간단한 변환기 를 만들었습니다.

그런 다음 직렬 변환기 옵션을 통해 등록됩니다. https://github.com/Kieranties/SimpleVersion/blob/feature/netcore3/src/SimpleVersion.Core/Serialization/Serializer.cs#L20

이러한 변경을 통해 사전의 키를 문자열로 직접 읽는 대신 역직렬화할 수 있습니다. 이것은 직렬화를 위해 등록된 자체 변환기를 가질 수 있는 임의 유형(예: 고유 키로 직렬화될 수 있는 열거형/유형/유형 등)이 될 키에 대한 지원을 추가로 엽니다.

공식적으로 테스트하지는 않았지만 현재 개발 내에서 이것이 문제를 해결한 것 같습니다.

안녕하세요 @Kieranties , github 링크 404

안녕하세요 @Kieranties , github 링크 404

@AirEssY 원래 의견의 링크를 수정했습니다. 이제 https://github.com/Kieranties/SimpleVersion/tree/master/src/SimpleVersion.Core/Serialization 에서 마스터에 있다고 생각합니다.

사전이 JavaScript 맵과 동일하면 모든(C#으로 표현되는 JS 유형)이 허용되어야 합니다.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

A Map's keys can be any value (including functions, objects, or any primitive).

JS에서 맵을 역직렬화하는 표준 접근 방식의 예는 다음과 같습니다.

const countries = new Map(JSON.parse('[[1,"Bahamas (the)"],[2,"Bolivia (Plurinational State of)"]]'))

console.log(countries)

다음을 생성합니다.

Map(2) {
  1 => 'Bahamas (the)',
  2 => 'Bolivia (Plurinational State of)'
}

TL; DR: 키를 문자열로 제한하는 것은 JS에서 잘 작동하지 않습니다.

@Jozkee 그래서 이것은 .NET 5에서만 제공됩니까 아니면 3.*으로 들어갈 것입니까?

@onionhammer .NET 5.0, 다음 미리보기(5.0 미리보기8)에서 기능을 사용해 볼 수도 있습니다.
이것을 3.x로 이식할 계획은 없습니다.

asp net core 3.x용 솔루션:

var dic1 = new Dictionary<TKey, TValue>(); 
return Json(new { dic1 }); // does not work

var dic2 = from i in new Dictionary<TKey, TValue>() select new { i.Key, i.Value }
return Json(new { dic2 });  //works prety well

@verloka 는 원하는 출력이 아닙니다.

@Jozkee 그래서 이것은 .NET 5에서만 제공됩니까 아니면 3.*으로 들어갈 것입니까?

이것은 3.x로 백포트되지 않지만 프로젝트에서 System.Text.Json NuGet 패키지 를 사용하여 .NET 5의 모든 새로운 기능을 추가할 수 있습니다.