नहीं, यह सुविधा इस समय समर्थित नहीं है, लेकिन कुछ ऐसा है जिस पर हमें vNext के लिए विचार करना चाहिए। क्या आपके पास सुविधा अनुरोध को प्रेरित करने के लिए एक उदाहरण उपयोग है?

भविष्य के रूप में चिह्नित करना।

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

@ahsonkhan GraphQL एक अच्छा उदाहरण है।

युक्ति JSON की सिफारिश करती है लेकिन यह प्रतिक्रिया में किसी विशिष्ट क्रमांकन से बंधी नहीं है।
इसका मतलब यह है कि प्रतिक्रिया का "डेटा" क्षेत्र इस तरह का है: गतिशील। चूंकि यह अनुमान नहीं लगाया जा सकता है।
ExpandoObject के बिना डिसेरिएलाइज़ेशन डायनेमिक को JSON मेकिंग का एक प्रकार बनाता है। तो उस अमूर्त गतिशील "डेटा" तक पहुंचना यह जानते हुए किया जाना चाहिए कि वास्तव में गतिशील एक JToken है।

ExpandoObject के साथ मुझे लगता है कि हम एक सामान्य वस्तु की तरह गतिशील "डेटा" की पहुंच को लागू कर सकते हैं

@ahsonkhan एक और उदाहरण हमारी परियोजना में कॉन्फ़िगरेशन सेवा है। यह आरईएसटी एंडपॉइंट्स जैसे संग्रह को उजागर करता है, जो मोंगोडीबी में संग्रह बनाता है (यह सिर्फ एक डमी आरईएसटी रैपर नहीं है, और बाकी संग्रह और मोंगो संग्रह में सटीक 1-1 मैपिंग नहीं है, यह कुछ नियमों का भी दावा करता है)।

तो हमारी परियोजना में हमें गतिशील/ExpandoObject समर्थन की आवश्यकता है।

हम इसे अन्य माइक्रोसर्विसेज में भी इस्तेमाल करते हैं।

हम भी इस सीमा में भागे। हमारा उपयोग मामला धीरे-धीरे जेसन क्रमांकन से पहले एक गतिशील वस्तु का निर्माण कर रहा है। अधिक परिपक्व Json.NET धारावाहिक पर वापस चला गया।

हे लोगों

अभी के लिए क्या घूमना है?
क्या मैं कॉन्फ़िगर कर सकता हूं कि किसका उपयोग करना है?
@SidShetye आपने कुछ और अधिक परिपक्व होने के बारे में कहा, क्या आप कृपया समझा सकते हैं?

@MickeyReznikov : देखें https://stackoverflow.com/questions/15455304/deserialize-a-property-as-an-expandoobject-use-json-net या google "json.netexpandoobject"

@MickeyReznikov , क्या आपके प्रश्न का उत्तर दिया गया था? मेरा मानना ​​​​है कि @SidShetye का मतलब गतिशील वस्तुओं को क्रमबद्ध करने के लिए Newtonsoft.Json का उपयोग करना है क्योंकि इन-बॉक्स लाइब्रेरी (System.Text.Json) के पास अभी तक उनके लिए समर्थन नहीं है। एएसपीनेट ऐप्स के मामले में, आप इसे AddNewtonsoftJson बैक में कॉन्फ़िगर कर सकते हैं।

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

मेरे पास इसके लिए उपयोग-मामला भी है - मैं सिर्फ एचटीपी क्लाइंट के साथ एक आरईएसटी एपीआई कॉल करना चाहता हूं और प्रतिक्रिया से एक संपत्ति पुनर्प्राप्त करना चाहता हूं। मैं केवल प्रतिक्रिया को पार्स करने के लिए एक समर्पित वर्ग नहीं बनाना चाहता ... JSON.NET के साथ मैं केवल "गतिशील" का उपयोग कर सकता हूं और पसंद की संपत्ति तक पहुंच सकता हूं।

https://github.com/dotnet/corefx/issues/41472 द्वारा @ghost1372 से :

नमस्ते मुझे आशा है कि यह प्रश्न पूछने के लिए यह एक अच्छी जगह है
ऐसा लगता है कि हम गतिशील वस्तुओं को deserialize नहीं कर सकते हैं
मैंने इस कोड का इस्तेमाल किया लेकिन काम नहीं किया क्या ऐसा करने का कोई तरीका है?

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

हमारे कई अनुप्रयोगों में हम संग्रहीत प्रक्रियाओं से डेटा के क्षेत्रों को नियंत्रित कर रहे हैं और गतिशील रूप से सूची और खोज सूची पृष्ठों को jquery.jtable के साथ प्रस्तुत करते हैं

JsonSerializer के बिना ExpandoObject के लिए अंतर्निहित समर्थन के बिना हम dotnet कोर अंतर्निहित Json Serialization का उपयोग नहीं कर सकते हैं

हम उसी उपयोग के मामले को साझा करते हैं जैसा कि पहले ही @estiler और @SidShetye द्वारा उल्लेख किया गया है
इस बीच हमें वापस Json.NET पर स्विच करना पड़ा।

क्या भविष्य की तुलना में _now_ के करीब एक मील का पत्थर होना संभव है? मैं

ExpandoObject काफी समय से BCL में है

क्या ExpandoObject के लिए कोई विकल्प है?

@fatihyildizhan नहीं, कोई विकल्प नहीं है।

लेकिन हमने अपना खुद का ExpandoObject कन्वर्टर लिखा है, आप इस लेख से संकेत ले सकते हैं ASP.NET Core 3.0: Custom JsonConverter नए System.Text.Json के लिए

हमें केवल क्रमांकन की आवश्यकता है, इसलिए हम केवल क्रमांकन बनाते हैं

मुझे आश्चर्य हुआ कि यह अभी तक समर्थित नहीं है।

इसे 5.0 पर ले जाना।

5.0 पर जा रहे हैं? इसका मतलब है कि हमें कम से कम एक साल इंतजार करना होगा? 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.json को हटाना था।

क्या मैं यह मान सकता हूं कि इस टिकट/मुद्दे को संबोधित करने से हमारी उस समस्या का समाधान हो जाता है जिसका हम अनुभव कर रहे हैं? यह संबोधित करने के लिए थोड़ा जरूरी मुद्दा लगता है, तो क्या इसे जल्द से जल्द संबोधित किया जा सकता है?

/सीसी @ahsonkhan @terrajobst

.NET कोर 3.0 JsonSerializer. गतिशील वस्तु के लिए Deserialize

ExpandoObject के लिए JsonSerializer समर्थन (अंतरिम उपाय)
मैं नौसिखिया हूं, कई जगह सही नहीं हैं, संशोधित करने के लिए सभी का स्वागत है
.net Core3 कोई समर्थन नहीं

जेसन कन्वर्टर जोड़ें

का उपयोग करके जोड़ें:

• System.Text.Json का उपयोग करना;
• System.Text.Json.Serialization का उपयोग करना;

```सी#
///

        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 , मैंने आपके कोड में कुछ संशोधन किए हैं - इसे फिर से काम करना ताकि यह ExpandoObject के बजाय गतिशील रूप से जेनरेट किए गए "प्रोजेक्शन" प्रकारों (बेस प्रकार से गुणों का सबसेट) का उपयोग कर सके। मैंने यहां कोड (नमूना कंसोल प्रोजेक्ट में) पोस्ट किया है: EDennis.DynamicDeserialization ।

मैं अधिक जटिल वस्तुओं के साथ और विभिन्न परिदृश्यों के तहत इस दृष्टिकोण का परीक्षण करूंगा (उदाहरण के लिए, मौजूदा, पूरी तरह से टाइप की गई ईएफ कोर इकाइयों को पैच करने के लिए उपयोग की जाने वाली गतिशील वस्तुओं का deserialization; परीक्षण मामलों के लिए जेसन ऑब्जेक्ट्स और सरणी का deserialization)। मुझे बताएं कि क्या आपको यह उपयोगी लगता है या यदि आप कुछ भी समस्याग्रस्त देखते हैं।

सामुदायिक कामकाज के लिए धन्यवाद। यह आश्चर्य की बात है कि Microsoft इस सुविधा को एक उचित समय सीमा में बाहर करने में असमर्थ है। किसी प्रकार की गतिशील वस्तु के बिना ग्राफ़क्यूएल प्रतिक्रियाओं के साथ काम करने से बहुत सारे वर्बोज़ और बदसूरत कोड होते हैं। या यहां तक ​​​​कि सिर्फ गहराई से नेस्टेड गुणों के अस्तित्व की जांच कर रहा है।

मैं टिप्पणियों के धागे के माध्यम से पढ़ता हूं और अधिकांश deserialization पर ध्यान केंद्रित कर रहे हैं, मुझे एक ऐसे मुद्दे का सामना करना पड़ रहा है जहां गतिशील वस्तुओं का क्रमिकरण स्पष्ट रूप से चुपचाप "विफल हो जाता है"। अपने परिदृश्य को पुन: पेश करने के प्रयास में मैं निम्नलिखित न्यूनतम रेप्रो के साथ आया:

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 चलाया जाता है तो {} , इसलिए क्रमबद्धता विफल नहीं होती है लेकिन एक खाली जेसन ऑब्जेक्ट उत्पन्न करती है।

क्या यह सही मुद्दा है? या मुझे किसी अन्य को उठाना/अनुसरण करना चाहिए?

क्या यह सही मुद्दा है? या मुझे किसी अन्य को उठाना/अनुसरण करना चाहिए?

यह सही मुद्दा है। एक ही फीचर के दो हिस्सों के लिए एक खोलने की जरूरत नहीं है। यह मुद्दा एक्सपेंडो ऑब्जेक्ट के लिए समर्थन जोड़ने के बारे में है (जिसका अर्थ है दोनों पक्षों के लिए, क्रमबद्ध और deserialize)।

मैं आज इस मुद्दे से मिला हूं - यह कहना चाहता था कि JsonElement ठीक काम करेगा यदि यह निपटाए गए JsonDocument पर निर्भर नहीं है। एक तरह से मैं इस मुद्दे के आसपास जाने के बारे में सोच सकता हूं कि JsonDocument लिए एक विनाशक को लागू करना है, इसलिए इसका निपटान बाद के समय में स्थगित किया जा सकता है - एक बार सभी JsonElement वस्तुओं को एकत्र कर लिया जाता है।

मुझे एक गतिशील वस्तु की भी आवश्यकता थी। हालांकि, इसे अभी तक लागू नहीं किया गया है। मेरा समाधान एक शब्दकोश का उपयोग करना था।
JsonSerializer.Deserialize<Dictionary<string, string>>(response)
और फिर उस कुंजी की तलाश करें जिसकी मुझे आवश्यकता है :)

सिर्फ मेरी अपनी विवेक के लिए - क्या समस्या 5.0 विशेष रूप से ExpandoObject समर्थन या गतिशील वस्तु में deserialize करने की क्षमता के लिए दायर की गई है? यहाँ सभी वार्तालाप समस्या के शीर्षक से मेल नहीं खाते, और मुझे निश्चित रूप से बाद वाले की आवश्यकता है। मेरे मामले में मैं एक नेस्टेड गतिशील deserializing हूँ, विशेष रूप से List<Dictionary<string, dynamic>> । अभी के लिए न्यूटनसॉफ्ट पर वापस स्विच किया गया :(

बस कुछ सी # 8 सिंटैक्स चीनी मोड @tchivs सहायक कोड साझा करना चाहता था :)

/// <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 के बारे में है। मैं नए .NET SDK का उपयोग करके क्वेरी कर रहा हूं जो इस JsonSerializer का उपयोग करता है और चूंकि यह एक स्कीमालेस डेटाबेस है, इसलिए मैं डेटाबेस डेटा के प्रत्येक प्रक्षेपण के लिए एक वर्ग नहीं बनाना चाहता जो मुझे करने की आवश्यकता है (विभिन्न प्रश्नों का एक समूह है) .
मुझे गतिशील वस्तुओं की सूची के रूप में प्रश्नों के परिणामों की आवश्यकता है।

@ SocVi100 इसके लिए Microsoft पर अपनी आशा न @layomia ने निकट भविष्य के एकीकरण के लिए सभी आशाओं को

आप योगदान क्यों नहीं देते? इसे लागू करें और एक पीआर में डालें!

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)

आप योगदान क्यों नहीं देते? इसे लागू करें और एक पीआर में डालें!

काश मैं।

मेरा परिदृश्य CosmosDB के बारे में है। मैं नए .NET SDK का उपयोग करके क्वेरी कर रहा हूं जो इस JsonSerializer का उपयोग करता है और चूंकि यह एक स्कीमालेस डेटाबेस है, इसलिए मैं डेटाबेस डेटा के प्रत्येक प्रक्षेपण के लिए एक वर्ग नहीं बनाना चाहता जो मुझे करने की आवश्यकता है (विभिन्न प्रश्नों का एक समूह है) .
मुझे गतिशील वस्तुओं की सूची के रूप में प्रश्नों के परिणामों की आवश्यकता है।

CosmosClientBuilder.WithCustomSerializer का उपयोग करके, एक अलग

यहाँ एक उदाहरण है: CosmosJsonNetSerializer

हम इस सुविधा को 5.0 में फिट नहीं कर सके। हमें बाकी 5.0 फीचर काम के साथ प्राथमिकता देनी थी, और यह फिट नहीं था। एफडब्ल्यूआईडब्ल्यू यह कट लाइन के बहुत करीब था, इस प्रकार देर से कदम।

@layomia ने निकट भविष्य के एकीकरण के लिए सभी आशाओं को

@RobbyDeLaet क्या हम इस चर्चा को रचनात्मक रखने की कोशिश कर सकते हैं? हम डिज़ाइन सिद्धांतों को बनाए रखते हुए शीर्ष अनुरोधित ग्राहक सुविधाओं का जवाब देने के लिए अपनी पूरी कोशिश कर रहे हैं। Newtonsoft.Json के साथ फीचर समानता के संबंध में, यहाँ हमें क्या कहना है ।

System.Text.Json मुख्य रूप से प्रदर्शन, सुरक्षा और मानकों के अनुपालन पर केंद्रित है। कुछ परिदृश्यों के लिए, System.Text.Json में कोई अंतर्निहित कार्यक्षमता नहीं है, लेकिन अनुशंसित समाधान हैं। यदि आपका आवेदन किसी अनुपलब्ध विशेषता पर निर्भर करता है, तो यह पता लगाने के लिए समस्या दर्ज करने पर विचार करें कि क्या आपके परिदृश्य के लिए समर्थन जोड़ा जा सकता है।

हमारा उद्देश्य Newtonsoft.JSON को बदलना नहीं है। अगर यह आपके लिए काम करता है, तो इसका इस्तेमाल करना जारी रखें। प्रदर्शन, सुरक्षा, मानकों के अनुपालन और लेयरिंग में हमने जो लाभ हासिल किया है, उसे बनाए रखते हुए हम System.Text.Json को यथासंभव उपयोगी बनाने की पूरी कोशिश करेंगे। समय के साथ हम इसे अधिक से अधिक लोगों के लिए काम करने की उम्मीद करते हैं। मैं यहां रुचि सुन रहा हूं और यह सुनिश्चित करूंगा कि हम आगे बढ़ने पर ध्यान केंद्रित करें।

आपके सुझावों के लिए धन्यवाद। मैं अंत में बीच में चला गया, न्यूटनसॉफ्ट सीरिएलाइज़र का उपयोग केवल deserialization के लिए, लेकिन मुझे अभी भी परीक्षण करना है। मुझे आशा है कि यह 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 ) में गतिशील कनवर्टर जोड़ते हैं जो परिनियोजन आकार (जैसे स्वयं निहित ऐप या ब्लेज़र) की परवाह करते हैं क्लाइंट ऐप)।

सिर्फ मेरी अपनी विवेक के लिए - क्या समस्या 5.0 विशेष रूप से ExpandoObject समर्थन या गतिशील वस्तु में deserialize करने की क्षमता के लिए दायर की गई है? यहाँ सभी वार्तालाप समस्या के शीर्षक से मेल नहीं खाते, और मुझे निश्चित रूप से बाद वाले की आवश्यकता है। मेरे मामले में मैं एक नेस्टेड गतिशील deserializing हूँ, विशेष रूप से List<Dictionary<string, dynamic>> । अभी के लिए न्यूटनसॉफ्ट पर वापस स्विच किया गया :(

अब मैं एक पुराने फ़ंक्शन का परीक्षण कर रहा हूं जिसे मैंने नेस्टेड ऑब्जेक्ट्स को deserialize करने के लिए लागू किया है और इस विषय में "valueKind" के साथ एक ही मुद्दे को नोट किया गया है।

क्या नए neetonsoft.json संकुल का उपयोग करके इसे ठीक करने का कोई तरीका था? क्योंकि उपरोक्त कोड रूट लेवल ऑब्जेक्ट के लिए काम करता है लेकिन नेस्टेड ऑब्जेक्ट्स के लिए नहीं।

@ericstj क्षमा याचना, मेरी प्रतिक्रिया शायद थोड़ी अधिक नकारात्मक और कठोर थी, लेकिन @ SocVi100 की तरह मैं एक स्वतंत्र डेवलपर हूं और कभी-कभी निराशाओं को ऊपरी हाथ मिलता है। लेकिन कम से कम हमने यहां एक चर्चा शुरू की। आपकी प्रतिक्रिया के लिए धन्यवाद, अब हमें इस अनुरोध की स्थिति के बारे में कम से कम एक स्पष्ट संदेश मिला है।

सिर्फ मेरे अपने विवेक के लिए - क्या समस्या 5.0 विशेष रूप से ExpandoObject समर्थन या गतिशील वस्तु में deserialize करने की क्षमता के लिए दायर की गई है

मुझे लगता है कि वांछित अर्थशास्त्र एक गतिशील प्रकार होना चाहिए ताकि deserializing के बाद आप देर से बाध्य तरीके से सभी गुणों (नेस्टेड समेत) तक पहुंच सकते हैं:

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 साथ उपयोग किया जा सकता है। यह आज से अलग है जो केवल मूल गुणों के लिए विस्तार-गुण बनाता है और सभी नेस्टेड गुणों के लिए JsonElement उदाहरण बनाता है।
• Serialize<ExpandoObect>() उम्मीद के
• Serialize<IDynamicMetaObjectProvider ()> लागू किया जा सकता है या नहीं इस पर निर्भर करता है कि क्या ऐसे परिदृश्य हैं जहां ExpandoObject का उपयोग नहीं किया जाता है।

3.0 - 5.0 में शब्दार्थ:

• ExpandoObject काम करता है क्योंकि ExpandoObject लागू होता है IDictionary<string, object> और STJ प्रत्येक object मान को सही ढंग से क्रमबद्ध करेगा चाहे वह एक आदिम, संग्रह या वस्तु हो।
• एक ExpandoObject प्रकार के कार्यों में अक्रमांकन करना लेकिन केवल मूल गुण "उचित" विस्तार-गुण हैं; कोई भी नेस्टेड गुण JsonElement होगा, इसलिए प्रोग्रामिंग मॉडल में असंगति है, इस प्रकार ExpandoObject को डिसेरिएलाइज़ करने से बचना चाहिए जब तक कि उसके लिए एक कस्टम कनवर्टर का उपयोग नहीं किया जाता है।

3.0-5.0 के लिए विकल्प:

• ExpandoObject और\या object लिए एक कस्टम कनवर्टर लिखें जैसा कि ऊपर पोस्ट में बताया गया है; मैं जल्द ही एक नए नमूने के लिए एक लिंक प्रदान करूंगा जो आदर्श रूप से 6.0 फीचर के लिए मैप करता है।
• यदि आप केवल क्रमबद्ध करते हैं, अक्रमांकन नहीं करते हैं, तो आप ExpandoObject (या dynamic यदि प्रकार ExpandoObject पर आधारित है) का उपयोग कर सकते हैं। चूंकि एसटीजे में आज ExpandoObject को डिसेरिएलाइज़ करना एक असंगति समस्या है, ExpandoObject डिसेरिएलाइज़ करने पर
• गतिशील वस्तुओं के बजाय JsonElement उपयोग करें। JsonElement "अनुमान" करने का प्रयास नहीं करता है कि JSON किस प्रकार के नक्शे हैं, इसलिए आपको GetString (), GetInt32 (), आदि को कॉल करके स्पष्ट होना चाहिए।

साथ ही, कार्यान्वयन के आधार पर, एक कस्टम कनवर्टर के कार्यान्वयन का मतलब है कि कुछ "अनुमान" है कि सीएलआर किस प्रकार जेएसओएन मानचित्रों को deserialization के दौरान टाइप करता है। उदाहरण के लिए, एक JSON स्ट्रिंग को या तो DateTime या string मैप किया जा सकता है, एक JSON नंबर को double या long मैप किया जा सकता है, और JSON सरणी प्रकार को निर्धारित करने की आवश्यकता है। इसकी जांच की जानी चाहिए और इसकी तुलना न्यूटनसॉफ्ट शब्दार्थ से की जानी चाहिए। जब कोई संपत्ति 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 के आधार पर अपना कोड स्निपेट ठीक कर सकते हैं?

जैसा कि वादा किया गया था, एक गतिशील कार्यान्वयन नमूना प्रदान करने वाला पीआर https://github.com/dotnet/runtime/pull/42097 पर है।

@ rs38 क्या आप @ ryan-hollister-q2 के आधार पर अपना कोड स्निपेट ठीक कर सकते हैं?

वह मेरा कोड नहीं था, इस धागे में पहले @tchivs से कुछ स्निपेट साझा किए थे।