Wie kann ein über JsonResult in asp.net mvc zurückgegebenes ExpandoObject reduziert werden?

Ich mag das ExpandoObjectbeim Kompilieren eines serverseitigen dynamischen Objekts zur Laufzeit sehr, aber ich habe Probleme, dieses Ding während der JSON-Serialisierung zu reduzieren. Zuerst instanziiere ich das Objekt:

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

So weit, ist es gut. In meinem MVC-Controller möchte ich dies dann als JsonResult senden, also mache ich Folgendes:

return new JsonResult(expando);

Dadurch wird der JSON wie folgt serialisiert, damit er vom Browser verwendet werden kann:

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

ABER was ich wirklich gerne sehen würde ist:

{SomeProp: SomeValueOrClass}

Ich weiß, dass ich dies erreichen kann, wenn ich dynamicanstelle von ExpandoObject- JsonResultdie dynamicEigenschaften und Werte in ein einzelnes Objekt serialisieren kann (ohne Schlüssel- oder Wertgeschäft), aber der Grund, den ich verwenden muss, ExpandoObjectist, dass ich nicht alle kenne Die Eigenschaften, die ich bis zur Laufzeit für das Objekt haben möchte , und soweit ich weiß, kann ich eine Eigenschaft nicht dynamisch zu einer hinzufügen, dynamicohne eine zu verwenden ExpandoObject.

Ich muss möglicherweise das Geschäft "Schlüssel", "Wert" in meinem Javascript durchsehen, aber ich hatte gehofft, dies herauszufinden, bevor ich es an den Kunden sende. Danke für Ihre Hilfe!

Sie können auch einen speziellen JSONConverter erstellen, der nur für ExpandoObject funktioniert, und ihn dann in einer Instanz von JavaScriptSerializer registrieren. Auf diese Weise können Sie Arrays von expando, Kombinationen von expando-Objekten und ... serialisieren, bis Sie eine andere Art von Objekt finden, die nicht korrekt serialisiert wird ("wie Sie wollen"), dann einen anderen Konverter erstellen oder einen anderen Typ hinzufügen dieses. Hoffe das hilft.

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

Konverter verwenden

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

Mit JSON.NET können Sie SerializeObject aufrufen, um das expando-Objekt zu "reduzieren":

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

var json = JsonConvert.SerializeObject(expando);

Wird ausgegeben:

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

Im Kontext eines ASP.NET MVC-Controllers kann das Ergebnis mit der Content-Methode zurückgegeben werden:

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");
    }
}

Folgendes habe ich getan, um das von Ihnen beschriebene Verhalten zu erreichen:

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);

Die Kosten sind, dass Sie eine Kopie der Daten erstellen, bevor Sie sie serialisieren.

Ich habe dieses Problem gelöst, indem ich eine Erweiterungsmethode geschrieben habe, die das ExpandoObject in eine JSON-Zeichenfolge konvertiert:

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();
}

Dies nutzt die ausgezeichnete Newtonsoft- Bibliothek.

JsonResult sieht dann so aus:

return JsonResult(expando.Flatten());

Und dies wird an den Browser zurückgegeben:

"{SomeProp: SomeValueOrClass}"

Und ich kann es in Javascript verwenden, indem ich dies tue ( hier referenziert ):

var obj = JSON.parse(myJsonString);

Ich hoffe das hilft!

Ich konnte das gleiche Problem mit JsonFx lösen .

        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);

Ausgabe:

{"Vorname": "John", "Nachname": "Doe", "Adresse": "1234 Home St", "Stadt": "Heimatstadt", "Bundesstaat": "CA", "Postleitzahl": "12345" "}

Ich ging noch einen Schritt weiter und suchte nach Listenobjekten, wodurch der Schlüsselwert-Unsinn beseitigt wurde. :) :)

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();
    }

Dies mag für Sie nicht nützlich sein, aber ich hatte eine ähnliche Anforderung, verwendete jedoch ein SerializableDynamicObject

Ich habe den Namen des Wörterbuchs in "Felder" geändert und dies wird dann mit Json.Net serialisiert, um json zu erzeugen, das wie folgt aussieht:

{"Felder": {"Eigenschaft1": "Wert1", "Eigenschaft2": "Wert2" usw. wobei Eigenschaft1 und Eigenschaft2 dynamisch hinzugefügte Eigenschaften sind - dh Wörterbuchschlüssel

Es wäre perfekt, wenn ich die zusätzliche Eigenschaft "Felder" entfernen könnte, die den Rest einschließt, aber ich habe diese Einschränkung umgangen.

Die Antwort wurde auf Anfrage von dieser Frage verschoben

Dies ist eine späte Antwort, aber ich hatte das gleiche Problem, und diese Frage half mir, sie zu lösen. Zusammenfassend dachte ich, ich sollte meine Ergebnisse veröffentlichen, in der Hoffnung, dass dies die Implementierung für andere beschleunigt.

Zuerst das ExpandoJsonResult, von dem Sie eine Instanz in Ihrer Aktion zurückgeben können. Oder Sie können die Json-Methode in Ihrem Controller überschreiben und dort zurückgeben.

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

Dann den Konverter (der sowohl Serialisierung als auch De-Serialisierung unterstützt. Ein Beispiel für die De-Serialisierung finden Sie weiter unten).

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

In der ExpandoJsonResult-Klasse können Sie sehen, wie Sie sie für die Serialisierung verwenden. Erstellen Sie zum De-Serialisieren den Serializer und registrieren Sie den Konverter auf die gleiche Weise, verwenden Sie ihn jedoch

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

Ein großes Dankeschön an alle Teilnehmer hier, die mir geholfen haben.

Bei Verwendung der Rückgabe von dynamischem ExpandoObject von WebApi in ASP.Net 4 scheint der Standard-JSON-Formatierer ExpandoObjects in ein einfaches JSON-Objekt zu reduzieren.

JsonResultverwendet, JavaScriptSerializerdie tatsächlich (den Beton) deserialisieren, Dictionary<string, object>wie Sie wollen.

Es gibt eine Überlastung des Dictionary<string, object>Konstruktors, die benötigt wird IDictionary<string, object>.

ExpandoObjectGeräte IDictionary<string, object> ^{_{(ich denke, Sie können sehen, wohin ich hier gehe ...)}}

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

Eine Codezeile mit allen integrierten Typen :)

Verschachtelte ExpandoObjects

Wenn Sie ExpandoObjects verschachteln, müssen Sie sie natürlich alle rekursiv in Dictionary<string, object>s konvertieren :

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

Ihr endgültiger Code wird

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);

Es scheint, als würde der Serializer das Expando in ein Wörterbuch umwandeln und es dann serialisieren (also das Schlüssel- / Wertgeschäft). Haben Sie versucht, Deserializing als Wörterbuch zu verwenden und dieses dann auf ein Expando zurückzuführen?

Ich hatte nur das gleiche Problem und fand etwas ziemlich Seltsames heraus. Wenn ich mache:

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

Es funktioniert, aber nur, wenn meine Methode das HttpPost-Attribut verwendet. Wenn ich HttpGet benutze, erhalte ich eine Fehlermeldung. Meine Antwort funktioniert also nur auf HttpPost. In meinem Fall war es ein Ajax-Aufruf, damit ich HttpGet durch HttpPost ändern konnte.