कैसे एक ExpandoObject को समतल करने के लिए asp.net mvc में JsonResult के माध्यम से लौटा?

Question 1

मैं ExpandoObjectरन-टाइम पर सर्वर-साइड डायनामिक ऑब्जेक्ट को कंप्लीट करते समय वास्तव में पसंद करता हूं, लेकिन मुझे JSON कॉन्ट्रिब्यूशन के दौरान इस चीज को समतल करने में परेशानी हो रही है। सबसे पहले, मैं वस्तु को तत्काल:

dynamic expando = new ExpandoObject();
var d = expando as IDictionary<string, object>;
expando.Add("SomeProp", SomeValueOrClass);

अब तक सब ठीक है। मेरे MVC कंट्रोलर में, मैं इसे एक JsonResult के रूप में भेजना चाहता हूं, इसलिए मैं ऐसा करता हूं:

return new JsonResult(expando);

यह नीचे दिए गए JSON को क्रमबद्ध करता है, ब्राउज़र द्वारा भस्म होने के लिए:

[{"Key":"SomeProp", "Value": SomeValueOrClass}]

लेकिन, मैं वास्तव में क्या देखना चाहूंगा:

{SomeProp: SomeValueOrClass}

मुझे पता है कि मैं इसे प्राप्त कर सकता हूं अगर मैं dynamicइसके बजाय का उपयोग करता हूं ExpandoObject- गुणों और मूल्यों को एक ही वस्तु (कोई कुंजी या मूल्य व्यवसाय के साथ) में JsonResultअनुक्रमित करने में सक्षम है dynamic, लेकिन मुझे जो उपयोग करने की आवश्यकता है ExpandoObjectवह इसलिए है क्योंकि मैं सभी को नहीं जानता हूं गुण जो मैं रनटाइम तक ऑब्जेक्ट पर चाहता हूं , और जहां तक मुझे पता है, मैं गतिशील रूप से एक dynamicका उपयोग किए बिना एक संपत्ति नहीं जोड़ सकता ExpandoObject।

मुझे अपनी जावास्क्रिप्ट में "कुंजी", "मूल्य" व्यवसाय के माध्यम से झारना पड़ सकता है, लेकिन मैं इसे ग्राहक को भेजने से पहले यह पता लगाने की उम्मीद कर रहा था। आपकी सहायताके लिए धन्यवाद!

Question 2

आप एक विशेष JSONConverter भी बना सकते हैं, जो केवल ExpandoObject के लिए काम करता है और फिर इसे JavaScriptSerializer की आवृत्ति में पंजीकृत करता है। इस तरह से आप एक्सपेंडो के एसेसरीज, एक्सपेंडेओ ऑब्जेक्ट्स के कॉम्बिनेशन को क्रिएट कर सकते हैं और ... जब तक आपको दूसरी तरह की ऑब्जेक्ट नहीं मिल जाती है जो सही तरीके से सीरीज़ नहीं हो रही है ("जिस तरह से आप चाहते हैं"), तो आप एक और कन्वर्टर बनाते हैं, या दूसरे टाइप को एड करते हैं यह वाला। उम्मीद है की यह मदद करेगा।

using System.Web.Script.Serialization;    
public class ExpandoJSONConverter : JavaScriptConverter
{
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        throw new NotImplementedException();
    }
    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {         
        var result = new Dictionary<string, object>();
        var dictionary = obj as IDictionary<string, object>;
        foreach (var item in dictionary)
            result.Add(item.Key, item.Value);
        return result;
    }
    public override IEnumerable<Type> SupportedTypes
    {
        get 
        { 
              return new ReadOnlyCollection<Type>(new Type[] { typeof(System.Dynamic.ExpandoObject) });
        }
    }
}

कनवर्टर का उपयोग करना

var serializer = new JavaScriptSerializer(); 
serializer.RegisterConverters(new JavaScriptConverter[] { new ExpandoJSONConverter()});
var json = serializer.Serialize(obj);

Question 3

JSON.NET का उपयोग करके आप विस्तारक ऑब्जेक्ट को "समतल" करने के लिए SerializeObject को कॉल कर सकते हैं:

dynamic expando = new ExpandoObject();
expando.name = "John Smith";
expando.age = 30;

var json = JsonConvert.SerializeObject(expando);

उत्पादन होगा:

{"name":"John Smith","age":30}

ASP.NET MVC नियंत्रक के संदर्भ में, सामग्री-विधि का उपयोग करके परिणाम लौटाया जा सकता है:

public class JsonController : Controller
{
    public ActionResult Data()
    {
        dynamic expando = new ExpandoObject();
        expando.name = "John Smith";
        expando.age = 30;

        var json = JsonConvert.SerializeObject(expando);

        return Content(json, "application/json");
    }
}

Question 4

आपके द्वारा बताए गए व्यवहार को प्राप्त करने के लिए मैंने यहां क्या किया है:

dynamic expando = new ExpandoObject();
expando.Blah = 42;
expando.Foo = "test";
...

var d = expando as IDictionary<string, object>;
d.Add("SomeProp", SomeValueOrClass);

// After you've added the properties you would like.
d = d.ToDictionary(x => x.Key, x => x.Value);
return new JsonResult(d);

लागत यह है कि आप इसे क्रमबद्ध करने से पहले डेटा की एक प्रति बना रहे हैं।

Question 5

मैंने इसे एक एक्सटेंशन विधि लिखकर हल किया, जो ExpandoObject को JSON स्ट्रिंग में रूपांतरित करता है:

public static string Flatten(this ExpandoObject expando)
{
    StringBuilder sb = new StringBuilder();
    List<string> contents = new List<string>();
    var d = expando as IDictionary<string, object>;
    sb.Append("{");

    foreach (KeyValuePair<string, object> kvp in d) {
        contents.Add(String.Format("{0}: {1}", kvp.Key,
           JsonConvert.SerializeObject(kvp.Value)));
    }
    sb.Append(String.Join(",", contents.ToArray()));

    sb.Append("}");

    return sb.ToString();
}

यह उत्कृष्ट Newtonsoft पुस्तकालय का उपयोग करता है ।

JsonResult तो इस तरह दिखता है:

return JsonResult(expando.Flatten());

और यह ब्राउज़र में वापस आ गया है:

"{SomeProp: SomeValueOrClass}"

और मैं इसे ( यहाँ संदर्भित ) करके जावास्क्रिप्ट में इसका उपयोग कर सकता हूं :

var obj = JSON.parse(myJsonString);

आशा है कि ये आपकी मदद करेगा!

Question 6

मैं JsonFx का उपयोग करके इसी समस्या को हल करने में सक्षम था ।

        dynamic person = new System.Dynamic.ExpandoObject();
        person.FirstName  = "John";
        person.LastName   = "Doe";
        person.Address    = "1234 Home St";
        person.City       = "Home Town";
        person.State      = "CA";
        person.Zip        = "12345";

        var writer = new JsonFx.Json.JsonWriter();
        return writer.Write(person);

उत्पादन:

{"फर्स्टनाम": "जॉन", "लास्टनेम": "डो", "एड्रेस": "1234 होम सेंट", "सिटी": "होम टाउन", "स्टेट": "सीए", "जिप": "12345 "}

Question 7

मैंने चपटे करने की प्रक्रिया को एक कदम आगे बढ़ाया और सूची वस्तुओं के लिए जाँच की, जो मुख्य मूल्य बकवास को हटा देता है। :)

public string Flatten(ExpandoObject expando)
    {
        StringBuilder sb = new StringBuilder();
        List<string> contents = new List<string>();
        var d = expando as IDictionary<string, object>;
        sb.Append("{ ");

        foreach (KeyValuePair<string, object> kvp in d)
        {       
            if (kvp.Value is ExpandoObject)
            {
                ExpandoObject expandoValue = (ExpandoObject)kvp.Value;
                StringBuilder expandoBuilder = new StringBuilder();
                expandoBuilder.Append(String.Format("\"{0}\":[", kvp.Key));

                String flat = Flatten(expandoValue);
                expandoBuilder.Append(flat);

                string expandoResult = expandoBuilder.ToString();
                // expandoResult = expandoResult.Remove(expandoResult.Length - 1);
                expandoResult += "]";
                contents.Add(expandoResult);
            }
            else if (kvp.Value is List<Object>)
            {
                List<Object> valueList = (List<Object>)kvp.Value;

                StringBuilder listBuilder = new StringBuilder();
                listBuilder.Append(String.Format("\"{0}\":[", kvp.Key));
                foreach (Object item in valueList)
                {
                    if (item is ExpandoObject)
                    {
                        String flat = Flatten(item as ExpandoObject);
                        listBuilder.Append(flat + ",");
                    }
                }

                string listResult = listBuilder.ToString();
                listResult = listResult.Remove(listResult.Length - 1);
                listResult += "]";
                contents.Add(listResult);

            }
            else
            { 
                contents.Add(String.Format("\"{0}\": {1}", kvp.Key,
                   JsonSerializer.Serialize(kvp.Value)));
            }
            //contents.Add("type: " + valueType);
        }
        sb.Append(String.Join(",", contents.ToArray()));

        sb.Append("}");

        return sb.ToString();
    }

Question 8

यह आपके लिए उपयोगी नहीं हो सकता है, लेकिन मुझे एक समान आवश्यकता थी, लेकिन एक SerializableDynamicObject का उपयोग किया

मैंने डिक्शनरी का नाम बदलकर "फील्ड्स" कर दिया और फिर यह Json.Net के साथ मिलकर जस का निर्माण करता है जो इस प्रकार है:

{"फ़ील्ड्स": {"प्रॉपर्टी 1": "वैल्यू 1", "प्रॉपर्टी 2": "वैल्यू 2" आदि जहां प्रॉपर्टी 1 और प्रॉपर्टी 2 को डायनामिकली जोड़ा गया गुण है - यानी डिक्शनरी कीज़

यह सही होगा यदि मैं अतिरिक्त "फील्ड्स" संपत्ति से छुटकारा पा सकता हूं जो बाकी को घेर लेता है, लेकिन मैंने उस सीमा के आसपास काम किया है।

अनुरोध पर इस प्रश्न का उत्तर दिया गया

Question 9

यह एक देर से जवाब है, लेकिन मुझे भी यही समस्या थी और इस सवाल ने मुझे उन्हें हल करने में मदद की। एक सारांश के रूप में, मुझे लगा कि मुझे अपना परिणाम पोस्ट करना चाहिए, इस उम्मीद में कि यह दूसरों के लिए कार्यान्वयन को गति देगा।

सबसे पहले ExpandoJsonResult, जिसे आप अपनी कार्रवाई में एक उदाहरण वापस कर सकते हैं। या आप अपने कंट्रोलर में Json मेथड को ओवरराइड कर सकते हैं और इसे वहां लौटा सकते हैं।

public class ExpandoJsonResult : JsonResult
{
    public override void ExecuteResult(ControllerContext context)
    {
        HttpResponseBase response = context.HttpContext.Response;
        response.ContentType = !string.IsNullOrEmpty(ContentType) ? ContentType : "application/json";
        response.ContentEncoding = ContentEncoding ?? response.ContentEncoding;

        if (Data != null)
        {
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            serializer.RegisterConverters(new JavaScriptConverter[] { new ExpandoConverter() });
            response.Write(serializer.Serialize(Data));
        }
    }
}

तब कनवर्टर (जो क्रमबद्धता और डी-क्रमांकन दोनों का समर्थन करता है। नीचे देखें कि कैसे क्रमबद्ध करें)।

public class ExpandoConverter : JavaScriptConverter
{
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    { return DictionaryToExpando(dictionary); }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    { return ((ExpandoObject)obj).ToDictionary(x => x.Key, x => x.Value); }

    public override IEnumerable<Type> SupportedTypes
    { get { return new ReadOnlyCollection<Type>(new Type[] { typeof(System.Dynamic.ExpandoObject) }); } }

    private ExpandoObject DictionaryToExpando(IDictionary<string, object> source)
    {
        var expandoObject = new ExpandoObject();
        var expandoDictionary = (IDictionary<string, object>)expandoObject;
        foreach (var kvp in source)
        {
            if (kvp.Value is IDictionary<string, object>) expandoDictionary.Add(kvp.Key, DictionaryToExpando((IDictionary<string, object>)kvp.Value));
            else if (kvp.Value is ICollection)
            {
                var valueList = new List<object>();
                foreach (var value in (ICollection)kvp.Value)
                {
                    if (value is IDictionary<string, object>) valueList.Add(DictionaryToExpando((IDictionary<string, object>)value));
                    else valueList.Add(value);
                }
                expandoDictionary.Add(kvp.Key, valueList);
            }
            else expandoDictionary.Add(kvp.Key, kvp.Value);
        }
        return expandoObject;
    }
}

आप ExpandationJsonResult वर्ग में देख सकते हैं कि इसे क्रमांकन के लिए कैसे उपयोग किया जाए। डी-सीरीज़ करने के लिए, सीरलाइज़र बनाएं और कनवर्टर को उसी तरह पंजीकृत करें, लेकिन उपयोग करें

dynamic _data = serializer.Deserialize<ExpandoObject>("Your JSON string");

एक बड़ा धन्यवाद सभी प्रतिभागियों के लिए, जिन्होंने मेरी मदद की।

Question 10

ASP.Net 4 में वेबएपीआई से डायनामिक एक्सपेंडेओबजेक्ट का उपयोग करते हुए, डिफ़ॉल्ट JSON फॉर्मैटर को विस्तार से साधारण JSON ऑब्जेक्ट में समतल करना प्रतीत होता है।

Question 11

JsonResultका उपयोग करता है JavaScriptSerializerजो वास्तव में deserializes (कंक्रीट) Dictionary<string, object>जैसा आप चाहते हैं।

Dictionary<string, object>कंस्ट्रक्टर का एक अधिभार है जो लेता हैIDictionary<string, object> ।

ExpandoObjectऔजार IDictionary<string, object> ^{_{(मुझे लगता है कि आप देख सकते हैं कि मैं यहाँ कहाँ जा रहा हूँ ...)}}

एकल स्तर ExpandoObject

dynamic expando = new ExpandoObject();

expando.hello = "hi";
expando.goodbye = "cya";

var dictionary = new Dictionary<string, object>(expando);

return this.Json(dictionary); // or new JsonResult { Data = dictionary };

सभी प्रकारों का उपयोग करके कोड की एक पंक्ति :)

नेस्टेड एक्सपेंडिऑबजेक्ट्स

बेशक, यदि आप नेस्ट कर रहे हैं ExpandoObjectतो आपको उन सभी को पुन: रूपांतरित करने की आवश्यकता होगी Dictionary<string, object>:

public static Dictionary<string, object> RecursivelyDictionary(
    IDictionary<string, object> dictionary)
{
    var concrete = new Dictionary<string, object>();

    foreach (var element in dictionary)
    {
        var cast = element.Value as IDictionary<string, object>;
        var value = cast == null ? element.Value : RecursivelyDictionary(cast);
        concrete.Add(element.Key, value);
    }

    return concrete;
}

आपका अंतिम कोड बन रहा है

dynamic expando = new ExpandoObject();
expando.hello = "hi";
expando.goodbye = "cya";
expando.world = new ExpandoObject();
expando.world.hello = "hello world";

var dictionary = RecursivelyDictionary(expando);

return this.Json(dictionary);

Question 12

ऐसा लगता है कि सीरियलाइज़र एक्सपेंडो को डिक्शनरी में डाल रहा है और फिर इसे सीरीज़ कर रहा है (इस प्रकार की / वैल्यू बिज़नेस)। क्या आपने डिस्क्रिअलाइज़िंग की कोशिश एक डिक्शनरी के रूप में की है और फिर उसे एक एक्सपेंडो में वापस लाना है?

Question 13

मैं सिर्फ एक ही समस्या थी और कुछ बहुत अजीब लगा। यदि मैं करता हूँ:

dynamic x = new ExpandoObject();
x.Prop1 = "xxx";
x.Prop2 = "yyy";
return Json
(
    new
    {
        x.Prop1,
        x.Prop2
    }
);

यह काम करता है, लेकिन केवल अगर मेरी विधि HttpPost विशेषता का उपयोग करें। अगर मैं HttpGet का उपयोग करता हूं तो मुझे त्रुटि मिलती है। तो मेरा जवाब HttpPost पर ही काम करता है। मेरे मामले में यह एक अजाक्स कॉल था ताकि मैं HttpPost द्वारा HttpGet को बदल सकूं।