Làm cách nào để chuyển đổi từ điển thành Chuỗi JSON trong C #?

Tôi muốn chuyển đổi Dictionary<int,List<int>>chuỗi JSON của tôi . Có ai biết làm thế nào để đạt được điều này trong C #?

Việc sắp xếp các cấu trúc dữ liệu chỉ chứa các giá trị số hoặc boolean khá đơn giản. Nếu bạn không có nhiều thứ tự để tuần tự hóa, bạn có thể viết một phương thức cho loại cụ thể của bạn.

Đối với một Dictionary<int, List<int>>như bạn đã chỉ định, bạn có thể sử dụng 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) + "}";
}

Nhưng, nếu bạn đang tuần tự hóa một số lớp khác nhau hoặc cấu trúc dữ liệu phức tạp hơn hoặc đặc biệt là nếu dữ liệu của bạn chứa các giá trị chuỗi , bạn nên sử dụng thư viện JSON có uy tín, biết cách xử lý những thứ như ký tự thoát và ngắt dòng. Json.NET là một lựa chọn phổ biến.

Câu trả lời này đề cập đến Json.NET nhưng không nói cho bạn biết làm thế nào bạn có thể sử dụng Json.NET để tuần tự hóa một từ điển:

return JsonConvert.SerializeObject( myDictionary );

Trái ngược với JavaScriptSerializer, myDictionarykhông phải là một từ điển loại <string, string>để JsonConvert hoạt động.

Bây giờ Json.NET có thể tuần tự hóa từ điển C # đầy đủ, nhưng khi OP ban đầu đăng câu hỏi này, nhiều nhà phát triển MVC có thể đã sử dụng JavaScriptSerializer lớp vì đó là tùy chọn mặc định ngoài hộp.

Nếu bạn đang làm việc trên một dự án cũ (MVC 1 hoặc MVC 2) và bạn không thể sử dụng Json.NET, tôi khuyên bạn nên sử dụng List<KeyValuePair<K,V>>thay vì mộtDictionary<K,V>> . Lớp JavaScriptSerializer kế thừa sẽ tuần tự hóa loại này tốt, nhưng nó sẽ có vấn đề với một từ điển.

Tài liệu: Bộ sưu tập nối tiếp với Json.NET

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

Điều này sẽ ghi vào bàn điều khiển:

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

Câu trả lời một dòng đơn giản

( using System.Web.Script.Serialization)

Mã này sẽ chuyển đổi bất kỳ Dictionary<Key,Value>sang Dictionary<string,string>và sau đó tuần tự hóa nó thành một chuỗi JSON:

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

Điều đáng lưu ý là một cái gì đó giống như Dictionary<int, MyClass>cũng có thể được tuần tự theo cách này trong khi vẫn bảo tồn loại / đối tượng phức tạp.

Giải thích (sự cố)

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

Bạn có thể thay thế biến yourDictionarybằng biến thực tế của bạn.

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.

Chúng tôi làm điều này, bởi vì cả Khóa và Giá trị phải thuộc kiểu chuỗi, như một yêu cầu để tuần tự hóa a 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.

Xin lỗi nếu cú ​​pháp là bit nhỏ nhất, nhưng mã tôi nhận được từ ban đầu trong 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);

Trong Asp.net Core sử dụng:

using Newtonsoft.Json

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

Bạn có thể sử dụng 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);

Đây là cách thực hiện bằng cách chỉ sử dụng các thư viện .Net tiêu chuẩn từ Microsoft '

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

Bạn có thể sử dụng JavaScriptSerializer .

Có vẻ như rất nhiều thư viện khác nhau và những gì dường như không đến và đi trong những năm trước. Tuy nhiên, kể từ tháng 4 năm 2016, giải pháp này đã làm việc tốt với tôi. Chuỗi dễ dàng thay thế bởi ints .

TL / DR; Sao chép này nếu đó là những gì bạn đến đây:

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

Hai điểm nhập khẩu. Trước tiên, hãy chắc chắn thêm System.R.78.Serliazation làm tài liệu tham khảo trong dự án của bạn bên trong Solution Explorer của Visual Studio. Thứ hai, thêm dòng này,

using System.Runtime.Serialization.Json;

ở đầu tập tin với phần còn lại của việc sử dụng của bạn, vì vậy DataContractJsonSerializerlớp có thể được tìm thấy. Bài đăng blog này có thêm thông tin về phương pháp tuần tự hóa này.

Định dạng dữ liệu (Đầu vào / Đầu ra)

Dữ liệu của tôi là một từ điển có 3 chuỗi, mỗi chuỗi chỉ vào một danh sách các chuỗi. Danh sách các chuỗi có độ dài 3, 4 và 1. Dữ liệu trông như thế này:

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

Đầu ra được ghi vào tệp sẽ nằm trên một dòng, đây là đầu ra được định dạng:

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

Điều này tương tự như những gì Meritt đã đăng trước đó. chỉ cần đăng mã hoàn chỉnh

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

Nếu ngữ cảnh của bạn cho phép nó (các ràng buộc kỹ thuật, v.v.), hãy sử dụng JsonConvert.SerializeObjectphương pháp từ Newtonsoft.Json : nó sẽ giúp cuộc sống của bạn dễ dàng hơn.

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