Serialisieren Wörterbücher mit JavaScriptSerializer

Offenbar IDictionary<string,object> serialisiert wird als ein array von KeyValuePair Objekte (z.B. [{Key:"foo", Value:"bar"}, ...]). Ist es möglich, um es zu serialisieren, wie ein Objekt statt (z.B. {foo:"bar"})?

  • ja, dont verwenden Sie JavaScriptSerializer seiner ganz Mist. Verwenden Newtonsoft Json.NET
InformationsquelleAutor Daniel | 2011-06-20
  1. 11

    Obwohl ich bin damit einverstanden, dass JavaScriptSerializer ist ein Mist und Json.Net ist eine bessere option, es ist ein Weg, in dem Sie machen können, JavaScriptSerializer serialisieren, wie Sie wollen.
    Sie müssen registrieren Sie einen Konverter aus, und überschreiben Sie die Serialize-Methode, mit so etwas wie dieses:

        public class KeyValuePairJsonConverter : JavaScriptConverter
{
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        var instance = Activator.CreateInstance(type);

        foreach (var p in instance.GetType().GetPublicProperties())
        {
            instance.GetType().GetProperty(p.Name).SetValue(instance, dictionary[p.Name], null);
            dictionary.Remove(p.Name);
        }

        foreach (var item in dictionary)
            (instance).Add(item.Key, item.Value);

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

JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
javaScriptSerializer.RegisterConverters(new JavaScriptConverter[] { new ExpandoJsonConverter() });
jsonOfTest = javaScriptSerializer.Serialize(test);
//{"x":"xvalue","y":"\/Date(1314108923000)\/"}

    Hoffe, das hilft!

    • Ich versuche, Ihre Klasse, aber es scheint Ihr instance variable ` Class-Objekt` hat keine Methode add.
    InformationsquelleAutor Tomas Ojeda
  2. 4

    Nein, es ist nicht möglich, mit JavaScriptSerializer. Es ist möglich, mit Json.NET:

    public class Bar
{
    public Bar()
    {
        Foos = new Dictionary<string, string>
        {
            { "foo", "bar" }
        };
    }

    public Dictionary<string, string> Foos { get; set; }
}

    dann:

    var bar = new Bar();
string json = JsonConvert.SerializeObject(bar, new KeyValuePairConverter());

    produzieren würde, die gewünschten:

    {"Foos":{"foo":"bar"}}
    • Ich ging, die route auf den ersten. Siehe meine Vorherige Frage: stackoverflow.com/questions/6416017/.... Ich hatte ein problem Deserialisieren verschachtelten dictionaries mit Json.NET.
    • Json.NET ist Zucker im Vergleich zu JavaScriptSerializer. Also, wenn Sie Probleme haben mit Json.NET ich weiß nicht, was zu sagen über die alternative 🙂 Wie weit, wie Ihre andere Frage betrifft, das ist völlig normales Verhalten. Alle von Ihnen angegebenen der serializer ist ein dictionary von string-und Objekt. So sind Sie bei arbeiten mit schwach typisierte Wörterbücher in Ihrem code, was erwarten Sie im Gegenzug? Alles, was Sie bekommen können, sind natürlich eine schwach typisierte JObjects. Verwenden Sie ein stark typisiertes dictionary: Dictionary<string, SomeModel> gibt es einen Unterschied.
    • Was ist der Unterschied beziehen Sie sich? Ich bin nicht es zu sehen.
    • Arbeit vs non-working Unterschied 🙂
    • Sorry, ich war eben sehen Dictionary vs IDictionary -- es bekam. Danke.
    InformationsquelleAutor Darin Dimitrov
  3. 3

    Konnte ich lösen mit JavaScriptSerializer mit Linq Wählen Sie:

    var dictionary = new Dictionary<int, string>();
var jsonOutput = new JavaScriptSerializer().Serialize(dictionary.Select(x => new { Id = x.Key, DisplayText = x.Value  }));
    • Dies funktioniert nicht bei komplexen Fällen (d.h. komplexen, hierarchischen Strukturen), aber Sie löst das problem in dem einfachen Fall, also ist es eine Lösung zu prüfen, wenn Sie möchten, um zu vermeiden, hinzufügen von Textbausteinen zu JavaScriptSerializer oder eine Drittanbieter-Bibliothek.
    • Für mich es hat funktioniert, auch in komplexen Fällen, nur die änderung zu .Serialize(dictionary). Seine einfacher dann JsonConvert, bereit zu verwenden. Ich wünschte, ich könnte geben +2 auf diese Antwort
    InformationsquelleAutor Agiz
  4. 1

    Konnte ich lösen es mithilfe der JavaScriptSerializer, der trick ist, zu erstellen Sie Ihren eigenen Konverter. Der folgende code funktioniert code:

    public class KeyValuePairJsonConverter : JavaScriptConverter {
    public override object Deserialize(IDictionary<string, object> dictionary
                                        , Type type
                                        , JavaScriptSerializer serializer) {
        throw new InvalidOperationException("Sorry, I do serializations only.");
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer) {
        Dictionary<string, object> result = new Dictionary<string, object>();
        Dictionary<string, MyClass> dictionaryInput = obj as Dictionary<string, MyClass>;

        if (dictionaryInput == null) {
            throw new InvalidOperationException("Object must be of Dictionary<string, MyClass> type.");
        }

        foreach (KeyValuePair<string, MyClass> pair in dictionaryInput)
            result.Add(pair.Key, pair.Value);

        return result;
    }

    public override IEnumerable<Type> SupportedTypes {
        get {
            return new ReadOnlyCollection<Type>(new Type[] { typeof(Dictionary<string, MyClass>) });
        }
    }
}

    Und hier ist, wie Sie es verwenden:

    JavaScriptSerializer js = new JavaScriptSerializer();
js.RegisterConverters(new JavaScriptConverter[] { new KeyValuePairJsonConverter() });
Context.Response.Clear();
Context.Response.ContentType = "application/json";
Context.Response.Write(js.Serialize(myObject));
    InformationsquelleAutor Zinan Xing
  5. 1

    Hier ist eine glaube ich eine verbesserte version von Tomas Antwort. Funktioniert wie ein Charme. Wir könnten auch einen Scheck für die ScriptIgnore Attribut aber gut, tobt Euch aus.

    BTW, ich wählte JavaScriptSerializer, weil meiner Meinung nach third-party-Lösungen sind die meisten der Zeit: weniger bekannt, lange zu installieren, oft vergessene pre-requities und blur-Kopie-Recht besagt, dass Sie riskant zu verteilen in der Wirtschaft.

    P-S: ich habe nicht verstanden, warum wir haben versucht, zu Deserialisieren sowohl auf die Instanz und die Instanz als ein Wörterbuch, so dass ich ausgezogen, das Teil.

    public class KeyValuePairJsonConverter : JavaScriptConverter
{
    public override object Deserialize(IDictionary<string, object> deserializedJSObjectDictionary, Type targetType, JavaScriptSerializer javaScriptSerializer)
    {
        Object targetTypeInstance = Activator.CreateInstance(targetType);

        FieldInfo[] targetTypeFields = targetType.GetFields(BindingFlags.Public | BindingFlags.Instance);

        foreach (FieldInfo fieldInfo in targetTypeFields)
            fieldInfo.SetValue(targetTypeInstance, deserializedJSObjectDictionary[fieldInfo.Name]);

        return targetTypeInstance;
    }

    public override IDictionary<string, object> Serialize(Object objectToSerialize, JavaScriptSerializer javaScriptSerializer)
    {
       IDictionary<string, object> serializedObjectDictionary = new Dictionary<string, object>();

       FieldInfo[] objectToSerializeTypeFields = objectToSerialize.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);

       foreach (FieldInfo fieldInfo in objectToSerializeTypeFields)
           serializedObjectDictionary.Add(fieldInfo.Name, fieldInfo.GetValue(objectToSerialize));

       return serializedObjectDictionary;
    }

    public override IEnumerable<Type> SupportedTypes
    {
        get
        {
            return new ReadOnlyCollection<Type>(new Type[] { typeof(YOURCLASSNAME) });
        }
    }
}
    • In Bezug auf meine PS Hinweis. Vielleicht war es specidying eine generische dictionary-Typ eher als ein Typ, aber ehrlich gesagt sehe ich nicht den Punkt von der Angabe eines generischen dictionary-Typ als diese ganze Sache ist über Deserialisieren <String, XYZ - > Wörterbücher. Und es ist cubersome.
    InformationsquelleAutor Olograph
Schreibe einen Kommentar