it-swarm.com.de

Wie konvertiere ich ein Wörterbuch in C # in einen JSON-String?

Ich möchte meinen Dictionary<int,List<int>> in eine JSON-Zeichenfolge konvertieren. Weiß jemand, wie man dies in C # erreicht?

106
daehaai

Das Serialisieren von Datenstrukturen , die nur numerische oder boolesche Werte enthalten, ist recht einfach. Wenn Sie nicht viel zu serialisieren haben, können Sie eine Methode für Ihren speziellen Typ schreiben.

Für einen Dictionary<int, List<int>>, wie Sie angegeben haben, können Sie Linq verwenden:

string MyDictionaryToJson(Dictionary<int, List<int>> dict)
{
    var entries = dict.Select(d =>
        string.Format("\"{0}\": [{1}]", d.Key, string.Join(",", d.Value)));
    return "{" + string.Join(",", entries) + "}";
}

Wenn Sie jedoch mehrere verschiedene Klassen oder komplexere Datenstrukturen serialisieren, oder insbesondere, wenn Ihre Daten Zeichenfolgenwerte enthalten , wäre es besser, eine seriöse JSON-Bibliothek zu verwenden, die bereits weiß, wie man mit Escape-Zeichen und Zeilenumbrüchen umgeht. Json.NET ist eine beliebte Option.

112
gilly3

Json.NET serialisiert wahrscheinlich die C # -Wörterbücher jetzt ausreichend, aber als das OP diese Frage ursprünglich veröffentlichte, haben viele MVC-Entwickler möglicherweise die Klasse JavaScriptSerializer verwendet, da dies die Standardoption aus der Box.

Wenn Sie an einem älteren Projekt (MVC 1 oder MVC 2) arbeiten und Json.NET nicht verwenden können, empfehle ich die Verwendung eines List<KeyValuePair<K,V>> anstelle eines Dictionary<K,V>>. Die ältere JavaScriptSerializer-Klasse serialisiert diesen Typ problemlos, hat jedoch Probleme mit einem Wörterbuch.

Dokumentation: SERIALISIERUNG VON SAMMLUNGEN MIT JSON.NET

67
Jim G.

Diese Antwort erwähnt Json.NET, sagt Ihnen aber nicht, wie Sie mit Json.NET ein Wörterbuch serialisieren können:

return JsonConvert.SerializeObject( myDictionary );

Im Gegensatz zu JavaScriptSerializer muss myDictionary kein Wörterbuch des Typs <string, string> sein, damit JsonConvert funktioniert.

64
David Kennedy
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Json;
using System.IO;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<int, List<int>> foo = new Dictionary<int, List<int>>();

            foo.Add(1, new List<int>( new int[] { 1, 2, 3, 4 }));
            foo.Add(2, new List<int>(new int[] { 2, 3, 4, 1 }));
            foo.Add(3, new List<int>(new int[] { 3, 4, 1, 2 }));
            foo.Add(4, new List<int>(new int[] { 4, 1, 2, 3 }));

            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Dictionary<int, List<int>>));

            using (MemoryStream ms = new MemoryStream())
            {
                serializer.WriteObject(ms, foo);
                Console.WriteLine(Encoding.Default.GetString(ms.ToArray()));
            }
        }
    }
}

Dies schreibt an die Konsole:

[{\"Key\":1,\"Value\":[1,2,3,4]},{\"Key\":2,\"Value\":[2,3,4,1]},{\"Key\":3,\"Value\":[3,4,1,2]},{\"Key\":4,\"Value\":[4,1,2,3]}]
17
Merritt

Sorry, wenn die Syntax das kleinste bisschen ist, aber der Code, von dem ich diesen Code bekomme, war ursprünglich in VB :)

using System.Web.Script.Serialization;

...

Dictionary<int,List<int>> MyObj = new Dictionary<int,List<int>>();

//Populate it here...

string myJsonString = (new JavaScriptSerializer()).Serialize(MyObj);
12
riwalk

Einfache einzeilige Antwort

(using System.Web.Script.Serialization)

Dieser Code konvertiert jeden Dictionary<Key,Value> in Dictionary<string,string> und serialisiert ihn dann als JSON-String:

var json = new JavaScriptSerializer().Serialize(yourDictionary.ToDictionary(item => item.Key.ToString(), item => item.Value.ToString()));

Es lohnt sich zu beachten, dass so etwas wie Dictionary<int, MyClass> auch auf diese Weise serialisiert werden kann, während der komplexe Typ/das Objekt erhalten bleibt.


Erklärung (Aufschlüsselung)

var yourDictionary = new Dictionary<Key,Value>(); //This is just to represent your current Dictionary.

Sie können die Variable yourDictionary durch Ihre tatsächliche Variable ersetzen.

var convertedDictionary = yourDictionary.ToDictionary(item => item.Key.ToString(), item => item.Value.ToString()); //This converts your dictionary to have the Key and Value of type string.

Wir machen dies, weil sowohl der Schlüssel als auch der Wert vom Typ string sein müssen, um eine Dictionary zu serialisieren.

var json = new JavaScriptSerializer().Serialize(convertedDictionary); //You can then serialize the Dictionary, as both the Key and Value is of type string, which is required for serialization.
11
HowlinWulf

Sie können System.Web.Script.Serialization.JavaScriptSerializer verwenden:

Dictionary<string, object> dictss = new Dictionary<string, object>(){
   {"User", "Mr.Joshua"},
   {"Pass", "4324"},
};

string jsonString = (new JavaScriptSerializer()).Serialize((object)dictss);
7
Salim

In Asp.net Core verwenden Sie:

using Newtonsoft.Json

var obj = new { MyValue = 1 };
var json = JsonConvert.SerializeObject(obj);
var obj2 = JsonConvert.DeserializeObject(json);
5

Es scheint eine Menge verschiedener Bibliotheken zu sein und was in den vergangenen Jahren nicht zu kommen und zu gehen scheint. Ab April 2016 hat diese Lösung jedoch für mich gut funktioniert. Strings können leicht durch ints ersetzt werden.

TL/DR; Kopieren Sie dies, wenn Sie dafür gekommen sind:

    //outputfilename will be something like: "C:/MyFolder/MyFile.txt"
    void WriteDictionaryAsJson(Dictionary<string, List<string>> myDict, string outputfilename)
    {
        DataContractJsonSerializer js = new DataContractJsonSerializer(typeof(Dictionary<string, List<string>>));
        MemoryStream ms = new MemoryStream();
        js.WriteObject(ms, myDict); //Does the serialization.

        StreamWriter streamwriter = new StreamWriter(outputfilename);
        streamwriter.AutoFlush = true; // Without this, I've run into issues with the stream being "full"...this solves that problem.

        ms.Position = 0; //ms contains our data in json format, so let's start from the beginning
        StreamReader sr = new StreamReader(ms); //Read all of our memory
        streamwriter.WriteLine(sr.ReadToEnd()); // and write it out.

        ms.Close(); //Shutdown everything since we're done.
        streamwriter.Close();
        sr.Close();
    }

Zwei Importpunkte. Stellen Sie zunächst sicher, dass Sie System.Runtime.Serliazation als Referenz in Ihrem Projekt im Projektmappen-Explorer von Visual Studio hinzufügen. Zweitens fügen Sie diese Zeile hinzu, 

using System.Runtime.Serialization.Json;

am oberen Rand der Datei mit den restlichen Verwendungen, sodass die DataContractJsonSerializer-Klasse gefunden werden kann. Dieser Blogbeitrag enthält weitere Informationen zu dieser Serialisierungsmethode.

Datenformat (Eingabe/Ausgabe)

Meine Daten sind ein Wörterbuch mit 3 Zeichenfolgen, von denen jede auf eine Liste von Zeichenfolgen zeigt. Die Listen der Strings haben die Längen 3, 4 und 1 ..__ Die Daten sehen folgendermaßen aus:

StringKeyofDictionary1 => ["abc","def","ghi"]
StringKeyofDictionary2 => ["String01","String02","String03","String04"]
Stringkey3 => ["someString"]

Die in die Datei geschriebene Ausgabe erfolgt in einer Zeile. Hier ist die formatierte Ausgabe:

 [{
     "Key": "StringKeyofDictionary1",
     "Value": ["abc",
     "def",
     "ghi"]
 },
 {
     "Key": "StringKeyofDictionary2",
     "Value": ["String01",
     "String02",
     "String03",
     "String04",
 ]
 },
 {
     "Key": "Stringkey3",
     "Value": ["SomeString"]
 }]
1
mwjohnson

Sie könnten JavaScriptSerializer verwenden.

1
Twelve47

Dies ist ähnlich wie bei Meritt. Einfach den vollständigen Code posten

    string sJSON;
    Dictionary<string, string> aa1 = new Dictionary<string, string>();
    aa1.Add("one", "1"); aa1.Add("two", "2"); aa1.Add("three", "3");
    Console.Write("JSON form of Person object: ");

    sJSON = WriteFromObject(aa1);
    Console.WriteLine(sJSON);

    Dictionary<string, string> aaret = new Dictionary<string, string>();
    aaret = ReadToObject<Dictionary<string, string>>(sJSON);

    public static string WriteFromObject(object obj)
    {            
        byte[] json;
            //Create a stream to serialize the object to.  
        using (MemoryStream ms = new MemoryStream())
        {                
            // Serializer the object to the stream.  
            DataContractJsonSerializer ser = new DataContractJsonSerializer(obj.GetType());
            ser.WriteObject(ms, obj);
            json = ms.ToArray();
            ms.Close();
        }
        return Encoding.UTF8.GetString(json, 0, json.Length);

    }

    // Deserialize a JSON stream to object.  
    public static T ReadToObject<T>(string json) where T : class, new()
    {
        T deserializedObject = new T();
        using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json)))
        {

            DataContractJsonSerializer ser = new DataContractJsonSerializer(deserializedObject.GetType());
            deserializedObject = ser.ReadObject(ms) as T;
            ms.Close();
        }
        return deserializedObject;
    }
0
Karshan