如何将字典转换为 C# 中的 JSON 字符串？

Question

我想将我的Dictionary<int,List<int>>转换为 JSON 字符串。 有谁知道如何在 C# 中实现这一点？

Answer 1

这个答案提到了 Json.NET，但没有告诉你如何使用 Json.NET 来序列化字典：

return JsonConvert.SerializeObject( myDictionary );

与 JavaScriptSerializer 不同， myDictionary不必是<string, string>类型的字典才能让 JsonConvert 工作。

Answer 2

序列化仅包含数字或布尔值的数据结构相当简单。 如果您没有太多要序列化的内容，您可以为您的特定类型编写一个方法。

对于您指定的Dictionary<int, List<int>> ，您可以使用 Linq：

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

但是，如果您要序列化几个不同的类，或更复杂的数据结构，或者特别是如果您的数据包含字符串值，那么最好使用已经知道如何处理转义字符和换行符等问题的信誉良好的 JSON 库。 Json.NET是一种流行的选择。

Answer 3

Json.NET现在可能会充分序列化 C# 字典，但是当 OP 最初发布此问题时，许多 MVC 开发人员可能一直在使用JavaScriptSerializer类，因为这是开箱即用的默认选项。

如果您正在处理遗留项目（MVC 1 或 MVC 2），并且您不能使用 Json.NET，我建议您使用List<KeyValuePair<K,V>>而不是Dictionary<K,V>> . 遗留的 JavaScriptSerializer 类可以很好地序列化这种类型，但它会遇到字典问题。

文档： 使用 Json.NET 序列化集合

Answer 4

简单的一行回答

（ using System.Web.Script.Serialization ）

此代码将任何Dictionary<Key,Value>转换为Dictionary<string,string> ，然后将其序列化为 JSON 字符串：

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

值得注意的是，像Dictionary<int, MyClass>这样的东西也可以通过这种方式序列化，同时保留复杂的类型/对象。

---

说明（分解）

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

您可以将变量yourDictionary替换为您的实际变量。

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.

我们这样做是因为 Key 和 Value 都必须是字符串类型，这是对Dictionary序列化的要求。

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.

Answer 5

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

这将写入控制台：

[{\"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]}]

Answer 6

对不起，如果语法是最小的一点，但我从中得到的代码最初是在 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);

Answer 7

在 Asp.net Core 中使用：

using Newtonsoft.Json

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

Answer 8

您可以使用System.Web.Script.Serialization.JavaScriptSerializer ：

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

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

Answer 9

似乎有很多不同的图书馆和过去几年似乎没有的东西。 但是，截至 2016 年 4 月，此解决方案对我来说效果很好。 字符串很容易被 ints 替换。

TL/DR； 如果这就是您来这里的目的，请复制此内容：

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

两个进口点。 首先，确保在 Visual Studio 的解决方案资源管理器中的项目中添加 System.Runtime.Serliazation 作为引用。 其次，添加这一行，

using System.Runtime.Serialization.Json;

在文件的顶部与您的其余使用，因此可以找到DataContractJsonSerializer类。 这篇博文提供了有关这种序列化方法的更多信息。

数据格式（输入/输出）

我的数据是一个包含 3 个字符串的字典，每个字符串都指向一个字符串列表。 字符串列表的长度为 3、4 和 1。数据如下所示：

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

写入文件的输出将在一行上，这是格式化的输出：

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

Answer 10

以下是仅使用来自 Microsoft 的标准 .Net 库的方法……

using System.IO;
using System.Runtime.Serialization.Json;

private static string DataToJson<T>(T data)
{
    MemoryStream stream = new MemoryStream();

    DataContractJsonSerializer serialiser = new DataContractJsonSerializer(
        data.GetType(),
        new DataContractJsonSerializerSettings()
        {
            UseSimpleDictionaryFormat = true
        });

    serialiser.WriteObject(stream, data);

    return Encoding.UTF8.GetString(stream.ToArray());
}

Answer 11

如果您的上下文允许（技术限制等），请使用Newtonsoft.Json 中的JsonConvert.SerializeObject方法：它会让您的生活更轻松。

Dictionary<string, string> localizedWelcomeLabels = new Dictionary<string, string>();
localizedWelcomeLabels.Add("en", "Welcome");
localizedWelcomeLabels.Add("fr", "Bienvenue");
localizedWelcomeLabels.Add("de", "Willkommen");
Console.WriteLine(JsonConvert.SerializeObject(localizedWelcomeLabels));

// Outputs : {"en":"Welcome","fr":"Bienvenue","de":"Willkommen"}

Answer 12

您可以使用JavaScriptSerializer 。

Answer 13

这与 Meritt 之前发布的内容类似。 只是发布完整的代码

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

Answer 14

仅供参考，在所有较旧的解决方案中：UWP 有自己的内置 JSON 库Windows.Data.Json 。

JsonObject是一个地图，您可以直接使用它来存储您的数据：

var options = new JsonObject();
options["foo"] = JsonValue.CreateStringValue("bar");
string json = options.ToString();

Answer 15

网络核心：System.Text.Json.JsonSerializer.Serialize(dict)

Answer 16

改进了 mwjohnson 的版本：

string WriteDictionaryAsJson_v2(Dictionary<string, List<string>> myDict)
{
    string str_json = "";
    DataContractJsonSerializerSettings setting = 
        new DataContractJsonSerializerSettings()
        {
            UseSimpleDictionaryFormat = true
        };

    DataContractJsonSerializer js = 
        new DataContractJsonSerializer(typeof(Dictionary<string, List<string>>), setting);

    using (MemoryStream ms = new MemoryStream())
    {                
        // Serializer the object to the stream.  
        js.WriteObject(ms, myDict);
        str_json = Encoding.Default.GetString(ms.ToArray());

    }
    return str_json;
}