Runtime: नया Asp.NET Core 3.0 Json डिक्शनरी को क्रमबद्ध नहीं करता है<key/>

दोनों "समर्थित अपवाद नहीं" त्रुटियां अंतर्निर्मित धारावाहिक के भीतर सीमाएं हैं और डिज़ाइन द्वारा हैं (कम से कम 3.0 में शिपिंग के लिए)।

यह समर्थन कब जोड़ा जाएगा? चूंकि यह थोड़ी देर के लिए Json.net और अन्य धारावाहिकों में समर्थित है, मुझे आशा है कि यह रडार पर है।
मैं इस तथ्य की सराहना करता हूं कि मैं Json.net का उपयोग करने का विकल्प चुन सकता हूं, इसलिए इसके लिए आपका बहुत-बहुत धन्यवाद!

सीरियलाइज़र क्षमताओं का एक गुच्छा है जो हमारे रडार पर vNext (इसलिए 5.0) और उससे आगे का समर्थन करने के लिए है, जिसमें कस्टम डिक्शनरी समर्थन उनमें से एक है।

Asp.NET वेब एपिस, जब एक डिक्शनरी लौटाता है तो यह एक समर्थित अपवाद के साथ विफल हो जाता है

क्रमबद्ध करते समय, आज केवल Dictionary<string, TValue> समर्थित है (अर्थात TKeys जो कि स्ट्रिंग हैं)। आपका शब्दकोश <int, string> जो समर्थित नहीं है।
https://github.com/dotnet/corefx/blob/93d7aa1c1737b6da29d04b78557215e18eb786d4/src/System.Text.Json/tests/Serialization/DictionaryTests.cs#L385 -L390

@steveharter , @layomia - क्या इस बीच यहां कोई संभावित समाधान है? 5.0 के लिए सीरिएलाइज़र के भीतर गैर-स्ट्रिंग key'd शब्दकोश के लिए समर्थन जोड़ने में क्या लगेगा?

System.NotSupportedException: संग्रह प्रकार 'Microsoft.AspNetCore.Mvc.SerializableError' समर्थित नहीं है।

~ SerializableError जैसे प्रकार के लिए समर्थन जोड़ना मेरे रडार पर नहीं था। @pranavkm , @rynowak - यहाँ क्या संदर्भ है? मैं ModelStateDictionary परिचित नहीं हूं, क्या इसे कस्टम कनवर्टर के साथ एमवीसी के भीतर ही समर्थित किया जा सकता है?~

संपादित करें: कोई बात नहीं, यह पहले से ही तय है।

System.NotSupportedException: संग्रह प्रकार 'Microsoft.AspNetCore.Mvc.SerializableError' समर्थित नहीं है।

यह एक ज्ञात मुद्दा था https://github.com/aspnet/AspNetCore/issues/11459 जिसे हाल ही में तय किया गया था (पूर्वावलोकन 8 के भाग के रूप में): https://github.com/dotnet/corefx/pull/39001

आपके त्वरित उत्तरों के लिए बहुत-बहुत धन्यवाद @ahsonkhan!

एक स्ट्रिंग होने की कुंजी की "सीमा" वास्तव में समझ में आती है जब मैं इसके बारे में सोचता हूं। अब मैं देखता हूं कि Json.net वास्तव में एक स्ट्रिंग होने की कुंजी के साथ जेसन उत्पन्न करता है, जब इसे deserializing मुझे बस एक int वापस मिल जाएगा। भविष्य में गैर-स्ट्रिंग कुंजियों के लिए समर्थन होना निश्चित रूप से अच्छा होगा, लेकिन शो स्टॉपर नहीं।

ठीक है, यह जानकर खुशी हुई कि Mvc.SerializableError का समर्थन नहीं किया जा रहा है, इसे ठीक कर दिया गया है। पूर्वावलोकन 8 की रिलीज की तारीख की उम्मीद है या नहीं, इस पर कोई विचार? कुछ खोजने और खोजने की कोशिश की, लेकिन उसके बारे में कुछ नहीं देखा।

एक बार पूर्वावलोकन 8 आने के बाद हम .net core 3 json क्रमांकन पुस्तकालय को फिर से देने का प्रयास करेंगे, लेकिन अभी के लिए हमें Json.net के साथ रहना होगा

@steveharter , @layomia - क्या इस बीच यहां कोई संभावित समाधान है? 5.0 के लिए सीरिएलाइज़र के भीतर गैर-स्ट्रिंग key'd शब्दकोश के लिए समर्थन जोड़ने में क्या लगेगा?

>

@ahsonkhan @ willyt150 इसके लिए एक कस्टम कनवर्टर का उपयोग करना है जो JsonConverter<T> जहां T Dictionary<int, string> ।
कुछ उदाहरणों के लिए https://github.com/dotnet/corefx/issues/36639#issue -429928740 देखें।

पूर्वावलोकन 8 की रिलीज की तारीख की उम्मीद है या नहीं, इस पर कोई विचार?

इस महीने के कुछ समय बाद।

इसके बारे में कुछ और सोचते हुए, अभी के लिए अप-फॉर-ग्रैब्स को हटा दें क्योंकि यह कुछ ऐसा हो सकता है जिसे हम डिफ़ॉल्ट रूप से समर्थन नहीं करना चाहते हैं।

धन्यवाद @layomia मैं उस पर एक नज़र

धन्यवाद @ahsonkhan , आने वाले सुधार की प्रतीक्षा कर रहा हूँ!

@namse से (https://github.com/dotnet/corefx/issues/40404 से):

नमस्ते। जब मैं पूर्णांक कुंजी के साथ शब्दकोश को क्रमबद्ध करने का प्रयास करता हूं, तो यह System.NotSupportedException को फेंक देता है।

मुझे लगता है कि यह जेसन सीरियलाइजेशन का समर्थन करने के लिए समझ में आता है जिसमें शब्दकोश में ToString -सक्षम कुंजी है। उदाहरण के लिए, जब हम int या बूलियन के लिए ToString चलाते हैं, तो यह "123" या "true" लौटाता है। मुझे लगता है कि कुंजी ToString -सक्षम कुंजी है।

Verizon

System.Text.Json Nuget संस्करण: 4.6.0-पूर्वावलोकन8.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"}}}

हालांकि यह अभी भी Dictionary<int, Dictionary<int, int>> जैसे नेस्टेड डिक्शनरी को क्रमबद्ध नहीं कर सकता क्योंकि System.Text.Json आंतरिक प्रकार Dictionary<int, int> स्वीकार नहीं करता है। मुझे लगता है कि यह एक बग है।

हालाँकि यह अभी भी एक नेस्टेड डिक्शनरी जैसे डिक्शनरी को क्रमबद्ध नहीं कर सकता है> क्योंकि System.Text.Json आंतरिक प्रकार को स्वीकार नहीं करता है Dictionary. मुझे लगता है कि यह एक बग है।

v3.0 के लिए शिप करने के लिए स्कोप-कटिंग के कारण केवल <string, x> का समर्थन डिज़ाइन द्वारा है। 3.0 रिलीज़ का उद्देश्य न्यूनतम व्यवहार्य उत्पाद होना है जिसमें समर्थित सबसे सामान्य परिदृश्य हैं।

@steveharter उपयोग करने योग्य कनवर्टर होने पर कम से कम आपको एक गैर-समर्थन अपवाद नहीं फेंकना चाहिए।

क्या .net core 3.1 में इसका समर्थन करने की कोई योजना है?

नवागंतुकों के लिए, अस्थायी समाधान Newtonsoft.Json पर वापस लौटना है।

1. Microsoft.AspNetCore.Mvc.NewtonsoftJson पैकेज संदर्भ जोड़ें।
2. .AddNewtonsoftJson() को .AddControllers() / .AddMvc() या किसी अन्य संयोजन के ठीक बाद जोड़ें।

@steveharter उपयोग करने योग्य कनवर्टर होने पर कम से कम आपको एक गैर-समर्थन अपवाद नहीं फेंकना चाहिए।

हाँ यह एक उचित बिंदु है। शायद हम 3.1 के लिए इस प्रतिबंध को हटा सकते हैं। सीसी @layomia

यह भी स्पष्ट करने के लिए कि आज शब्दकोश तत्व गुणों की तरह क्रमबद्ध हैं जो संभव है क्योंकि कुंजी एक स्ट्रिंग है। गैर-स्ट्रिंग कुंजियों का समर्थन करने का अर्थ है कि तत्वों को KeyValuePair के रूप में क्रमबद्ध किया जाएगा।

ओह बॉय, मुझे 3.0 में अपग्रेड करने के ठीक बाद यह समस्या थी।

AddNewtonsoftJson के साथ न्यूटन पैकेज स्थापित करना पड़ा।

https://github.com/dotnet/corefx/issues/41345 . में @israellot से

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

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

यह सरल क्रमांकन पूर्व डिफ़ॉल्ट न्यूटनसॉफ्ट जोंस लाइब्रेरी द्वारा स्ट्रिंग के रूप में इंट कुंजी को क्रमबद्ध करके अच्छी तरह से नियंत्रित किया जाता है। System.Text.Json पर एक समर्थित अपवाद नहीं फेंकता है।

@israellot , @unruledboy , और थ्रेड पर अन्य, क्या आप इस बारे में विवरण प्रदान कर सकते हैं कि आपके ऑब्जेक्ट मॉडल को आपके परिदृश्यों में पूर्णांक कुंजियों वाले Dictionary<string, TValue> बदलने से काम क्यों नहीं चलेगा? मुझे आवश्यकताओं को इकट्ठा करने और फिक्स को प्रेरित करने में मदद करने के लिए कुछ उपयोग देखना अच्छा लगेगा।

वे वैसे भी तारों के रूप में क्रमबद्ध हो जाएंगे, इसलिए मुझे समझ में नहीं आता कि आप अपने अंतर्निहित शब्दकोश में किस परिदृश्य में int32 कुंजी रखना चाहते हैं।

@ahsonkhan मेरा मानना ​​​​है कि मुख्य प्रेरणा संगतता है।
पिछला डिफ़ॉल्ट सीरिएलाइज़र न्यूटनसॉफ्ट था, इसलिए उपयोगकर्ताओं ने मनमाने वर्गों को क्रमबद्ध और deserialize करने की क्षमता पर भरोसा करते हुए पूरे मॉडल लिखे हो सकते हैं। 2.X से 3.0 पर माइग्रेट करने से अब एक मूक ब्रेकिंग परिवर्तन होगा क्योंकि हम केवल रनटाइम पर असंगति को जानेंगे।

मेरा मानना ​​​​है कि कई परिदृश्यों में तार के पार परिवहन के रूप में जसन का उपयोग करना शामिल है, और इस मामले में, डोमेन मॉडल हो सकता है Dictionary. आपका सुझाव एक अलग डीटीओ ऑब्जेक्ट डिक्शनरी बनाने के लिए उबलता हैऔर दोनों के बीच कनवर्ट करना, बल्कि अक्षम लगता है क्योंकि अब हमें सीरियलाइज़र के अनुरूप होने के लिए एक और ऑब्जेक्ट आवंटित करने की आवश्यकता है।
सीरिएलाइज़र को सख्ती से देखते हुए, स्ट्रिंग कुंजी रखने के लिए शब्दकोश को प्रतिबंधित करना तार्किक है क्योंकि यह एकमात्र संभावित जेसन प्रतिनिधित्व है। लेकिन यह देखते हुए कि धारावाहिक अनुप्रयोगों में एक भूमिका निभाता है, मेरा मानना ​​​​है कि जितना संभव हो उतना घर्षण दूर करना सबसे अच्छा है।

मैं इस मुद्दे में एक छोटे से प्रोग्राम के साथ भाग गया हूं जिसे मैं लिख रहा हूं जहां एक संस्करण लेबल के कुछ हिस्सों को एक जेसन फ़ाइल के माध्यम से प्रदान किया जाता है।
लेबल भागों में एक कुंजी होती है जो उस अनुक्रमणिका को निर्दिष्ट करती है जहां लेबल भाग डाला जा सकता है। इसका मतलब है कि कुंजियाँ संख्यात्मक मान हैं, उदाहरण के लिए

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

न्यूटनसॉफ्ट का उपयोग करते हुए, जेसन को बिना किसी समस्या के Dictionary<int, string> deserialized किया जा सकता है। System.Text.Json क्रमांकन में कनवर्ट करने के बाद विफल रहा।

मैंने अपना खुद का DictionaryConverter , और DictionaryConverter बनाकर इस मुद्दे को हल किया है .
मैंने एक साधारण कनवर्टर भी बनाया है जो पूर्णांकों को एक स्ट्रिंग से अक्रमांकन करने की अनुमति देता है

फिर इन्हें धारावाहिक विकल्पों के माध्यम से पंजीकृत किया जाता है: https://github.com/Kieranties/SimpleVersion/blob/master/src/SimpleVersion.Core/Serialization/Serializer.cs#L22

ये परिवर्तन एक स्ट्रिंग के रूप में सीधे पढ़ने के बजाय किसी शब्दकोश की कुंजियों को डीसेरियलाइज़ करने की अनुमति देते हैं। यह आगे चाबियों के लिए मनमाने प्रकार के समर्थन को खोलता है जो कि अपने स्वयं के कन्वर्टर्स को क्रमबद्धता के लिए पंजीकृत कर सकते हैं (उदाहरण के लिए एनम/प्रकार/प्रकार जिन्हें अद्वितीय कुंजी आदि के रूप में क्रमबद्ध किया जा सकता है)

मैंने औपचारिक रूप से चीजों का परीक्षण नहीं किया है लेकिन वर्तमान विकास के भीतर ऐसा लगता है कि इस मुद्दे को हल किया गया है।

3.1 के लिए मील का पत्थर की स्थापना किसी प्रतिबंध से बनाया जा रहा है कि किसी भी संभाल कर सकते हैं एक कस्टम कनवर्टर से बचाता है दूर करने के लिए TKey के लिए Dictionary<TKey,TValue> ।

अपडेट करें: मैंने ऐसे नमूने जोड़े हैं जो 3.0 के साथ काम करते हैं। जैसा कि ऊपर बताया गया है, मैंने नेस्टेड शब्दकोशों जैसे किसी भी मुद्दे पर ध्यान नहीं दिया।

नमूने में दो JSON प्रारूपों का उपयोग किया जा रहा है:

• स्ट्रिंग गुणों के साथ JSON ऑब्जेक्ट: {"1":"val1","2":"val2"} भले ही TKey एक स्ट्रिंग नहीं है।
  
  
  
  • ये संगत समर्थित कुंजी प्रकार पर TryParse पद्धति पर निर्भर करते हैं। V3.0 के लिए सामान्यीकृत TKey लिए समर्थन प्रदान करना संभव नहीं है क्योंकि TryParse तरीके किसी भी TKey लिए भिन्न हो सकते हैं और क्योंकि ऐसी संस्कृति सेटिंग्स हैं जिन्हें प्रदान करने की आवश्यकता है (आमतौर पर अपरिवर्तनीय)। तो नीचे दिए गए नमूने एकल TKey प्रकार के लिए हैं।
  
  
  • Sample Dictionary<int, string> । यह केवल TValue == string लिए एक सरल उदाहरण है।
  
  
  • Sample Dictionary<Guid, TValue> । यह किसी भी TValue को संभाल सकता है।
  
  
  • Sample Dictionary<TKey, TValue> where TKey is Enum । Enums के लिए; यह किसी भी TValue को संभाल सकता है।
  
  
• KeyValuePair प्रविष्टियों के साथ JSON सरणी: [{"Key":1,"Value":"val1"},{"Key":2,"Value":"val2"}]
  
  
  
  • Sample Dictionary<int, string> । यह केवल TValue == string लिए एक सरल उदाहरण है।
  
  
  • Sample Dictionary<TKey, TValue> । यह किसी भी TKey और TValue को संभाल सकता है क्योंकि प्रकार JSON में मूल रूप से दर्शाए जाते हैं और TryParse आवश्यकता नहीं होती है।
  
  

यदि ये नमूने संतोषजनक हैं, तो मैं इस मुद्दे को 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 = संख्या: "86"
न्यूटन सॉफ्टजसन [0] ["आईडी"] इस प्रकार दिखाता है: 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": "स्ट्रिंग"}

मुझे लगता है कि आप "नमूना शब्दकोश" का उपयोग कर रहे हैं"? यदि ऐसा है, तो हाँ, जिसमें KeyValuePair का उपयोग किया गया है जिसमें "कुंजी" और "मान" गुण हैं। मैंने TKey- आधारित एनम शब्दकोशों के लिए एक नमूना प्रदान नहीं किया है जो संपत्ति के नाम के रूप में क्रमबद्ध हैं, लेकिन मैं इसे जोड़ने पर काम करूंगा।

हाँ, वही। और आह ठीक है, मैंने सोचा था कि आपका मतलब था कि एक सामान्य शब्दकोश धारावाहिक के रूप में।
उपलब्ध होने पर आपका नया नमूना देखने में दिलचस्पी है, क्योंकि वर्तमान में हम जिस नमूने का उपयोग कर रहे हैं वह उतना तेज़ नहीं लगता जितना मैं चाहता हूँ।

@roguecode यहां Dictionary<TKey, TValue> लिए एक Enum नमूना है जहां TKey एक Enum है और KeyValuePair के बजाय "संपत्ति" 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 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 में उस स्ट्रिंग को सही ढंग से deserialize कर सकते हैं। आप देख सकते हैं कि यह गुण नाम 2.x संस्करण से छूट गया है।

समस्या यह है कि 3.0 क्रमांकन जो तब होता है जब एक फिल्टर से प्रतिक्रिया वापस आती है BadRequestObjectResult , नीचे दिए गए कोड से:

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

..., जो प्रतिक्रिया सामग्री लौटाई जाती है वह 2.2 संस्करण के समान रूप है ( Extensions संपत्ति का नाम बाहर रखा गया है), जो Extensions संपत्ति को खाली संग्रह के रूप में deserialize करने का कारण बनता है (उपयोग करके) Newtonsoft.Json.JsonConvert.DeserializeObject<ValidationProblemDetails>() )

किसी तरह यह क्रमांकन न्यूटनसॉफ्ट पुस्तकालय के समान क्रमांकन का उपयोग नहीं कर रहा है जिसके साथ हम deserialize करने की कोशिश कर रहे हैं।

विचार के लिए धन्यवाद!

मेरे पास कुछ ऐसा ही है लेकिन अलग है

@ ts46235 क्या आप कृपया इसके लिए एक नया अंक खोल सकते हैं क्योंकि यह वर्तमान मुद्दे से अलग है?

@ ts46235 मैंने आपके द्वारा यहां खोले गए अन्य अंक में आपके प्रश्न का उत्तर दिया - https://github.com/aspnet/AspNetCore/issues/16618। यहां बातचीत को विषय से बाहर के रूप में चिह्नित कर रहा है।

कोर 3.1 में अपडेट किया गया और अभी भी तय नहीं है

मैंने अभी 3.1 में अपग्रेड किया है और इससे प्रभावित हुआ हूं। JSON.NET पर वापस मैं जाता हूं... (मैं GUID कुंजियों का उपयोग करता हूं)

डॉट नेट कोर 3.1
शब्दकोश

मैंने भी इसे अभी मारा है, और यह कितनी डरावनी मूक सीमा है, क्योंकि जैसा कि अन्य ने बताया है कि आप इसे संकलन समय पर नहीं देख पाएंगे। मेरे मामले में, मैं Dictionary<int, List<string>> को क्रमबद्ध करना चाहता हूं, जो मुझे विशेष रूप से विदेशी के रूप में नहीं मारता है।

उन्हें इसे ठीक करना चाहिए लेकिन मैं इस बार और समय को पुराने फॉर्मेटर, बाइनरी फॉर्मेटर अर्ली न्यूटसॉफ्ट, डिक्शनरी में डिक्शनरी, इंटरफेस वाले डिक्शनरी के साथ भी देखता हूं। उन्हें इसे ठीक करना चाहिए, लेकिन अगर आप परेशानी नहीं चाहते हैं तो लोगों को वास्तव में जटिल वस्तुओं को नहीं रखना चाहिए जैसे कि सीरियलाइजेशन कॉन्ट्रैक्ट्स में डिक्शनरी आपकी परेशानी पूछ रही है - न्यूटसॉफ्ट ने लोगों को खराब कर दिया है। डिक्शनरी गिनती आदि पर सभी सार्वजनिक संपत्तियों को देखें, आप इसे मैप करने के लिए धारावाहिक में कुछ कस्टम पर भरोसा कर रहे हैं।

दुर्भाग्य से संपत्ति के नामों के लिए सी # में इसके लिए कोई आसान प्रकार नहीं है, इसलिए शब्दकोश मजबूर है। तो बस उदास हूँ..

यहां एक समाधान है लेकिन किसी भी तरह से पूर्ण समाधान नहीं है:

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

शायद (कुछ) सामान्य प्रकार के धारावाहिकों के लिए समर्थन ओओटीबी जोड़ा जा सकता है, उदाहरण के लिए यह सूची , और यदि इनमें से एक प्रकार .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

शब्दकोश

@ एंड्रयू-वीडीबी, मनमानी वस्तु कुंजियों के क्रमांकन का समर्थन करने की संभावना असमर्थित रहेगी। हालाँकि, यदि ऑब्जेक्ट कुंजियों का रनटाइम प्रकार "नए समर्थित" प्रकारों में से एक है, तो सुविधा हो जाने के बाद क्रमांकन उसके लिए काम करेगा। अक्रमांकन, हालांकि, बॉक्सिंग 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 = संख्या: "86"
न्यूटन सॉफ्टजसन [0] ["आईडी"] इस प्रकार दिखाता है: 86

सभी उल्लिखित मुद्दों में से, यह मुझे सबसे ज्यादा परेशान करता है। सूचीया टी[] या डिक्शनरीकिसी भी प्रकार के लिए ठीक से deserialize करना चाहिए जिसे सीधे कुछ प्रकार से मैप किया जा सकता है जोसन को सीएलआर प्रकारों से है।

3.0 रिलीज़ का उद्देश्य न्यूनतम व्यवहार्य उत्पाद होना है जिसमें सबसे सामान्य परिदृश्य समर्थित हैं

मुझे आश्चर्य है कि कैसे List> सबसे आम परिदृश्यों में से एक नहीं है:

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

चूंकि यह System.Text.JsonElement में भी deserialize करता है, जहां मैं डबल (संख्या) और स्ट्रिंग (स्ट्रिंग) की अपेक्षा करता हूं

मैं इस मुद्दे में एक छोटे से प्रोग्राम के साथ भाग गया हूं जिसे मैं लिख रहा हूं जहां एक संस्करण लेबल के कुछ हिस्सों को एक जेसन फ़ाइल के माध्यम से प्रदान किया जाता है।
लेबल भागों में एक कुंजी होती है जो उस अनुक्रमणिका को निर्दिष्ट करती है जहां लेबल भाग डाला जा सकता है। इसका मतलब है कि कुंजियाँ संख्यात्मक मान हैं, उदाहरण के लिए

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

न्यूटनसॉफ्ट का उपयोग करते हुए, जेसन को बिना किसी समस्या के Dictionary<int, string> deserialized किया जा सकता है। 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

यदि डिक्शनरी एक जावास्क्रिप्ट मानचित्र के बराबर है, तो कोई भी (जेएस प्रकार सी # में दर्शाया गया है) स्वीकार्य होना चाहिए,

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

टीएल; डीआर: स्ट्रिंग्स को चाबियों को प्रतिबंधित करना जेएस के साथ अच्छा नहीं खेलता है

@Jozkee तो क्या यह केवल .NET 5 में आ रहा है या यह 3.* में जाएगा?

@onionhammer .NET 5.0, आप इस सुविधा को अगले पूर्वावलोकन (5.0 पूर्वावलोकन8) में भी आज़मा सकते हैं।
इसे 3.x में पोर्ट करने की कोई योजना नहीं है।

एएसपी नेट कोर 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 पर बैकपोर्ट नहीं किया जाएगा, लेकिन आप .NET 5 में सभी नई सुविधाओं को प्राप्त करने के लिए अपने प्रोजेक्ट में System.Text.Json NuGet पैकेज का उपयोग कर सकते हैं।