將對象數組序列化爲JSON

Question

我有一個類型，它是一個字典上的包裝 - 基本上是一個鍵/值存儲。我想將這種類型的對象序列化爲JSON。我對JSON和Json.NET（newtonsoft.json）非常陌生。

我喜歡的類型有一個名爲方法 - 的toJSON其序列化的字典JSON如下

public string ToJson() 
{ 
    return JsonConvert.SerializeObject(this.values); 
}  

然後我試圖序列這些對象

var json = JsonConvert.SerializeObject(objectArray) 

當然這並不數組因爲數組中的每個對象都是序列化的，我不知道如何將序列化過程指向每個對象的'ToJson'方法。

我可以讓它正常工作，就像我想要的一樣，如果我傳遞一個Dictionary對象的數組。

也許我缺少一些序列化屬性？

編輯：

閱讀一些文件我嘗試了更短的方式（考慮JsonConverter方法之前）之後 - 使用「JsonPropertyAttribute」。將它應用到私有字典成員幾乎做了這項工作，除了我也獲得序列化的成員名稱，我不想。任何方式只是通過使用JsonPropertyAttribute序列化成員值而不是成員名稱？

Answer 1

試試這個你有任何類型的對象。這是一個普通的JSON序列代碼，我用

public class JsonUtils 
{ 
    #region 
    public static string JsonSerializer<T>(T t) 
    { 
     DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T)); 
     MemoryStream ms = new MemoryStream(); 
     ser.WriteObject(ms, t); 
     string jsonString = Encoding.UTF8.GetString(ms.ToArray()); 
     ms.Close(); 
     return jsonString; 
    } 
    /// <summary> 
    /// JSON Deserialization 
    /// </summary> 
    public static T JsonDeserialize<T>(string jsonString) 
    { 
     DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T)); 
     MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)); 
     T obj = (T)ser.ReadObject(ms); 
     return obj; 
    } 
    #endregion 
} 

Answer 2

爲了您的序列化包裝類，使得其內部字典出現在JSON彷彿包裝都沒有，你需要自定義JsonConverter。 A JsonConverter可讓您直接控制對特定類別進行序列化和/或反序列化的內容。

下面是一個適合您情況的轉換器。既然你沒有真正提供關於你的包裝類的任何細節，除了它有一個名爲values的字段來存放字典，我使用了反射來訪問它。如果你的類有公共方法直接操縱字典，你可以改變轉換器來使用這些方法，如果你願意的話。下面是代碼：

class DictionaryWrapperConverter : JsonConverter 
{ 
    public override bool CanConvert(Type objectType) 
    { 
     return (objectType == typeof(MyWrapper)); 
    } 

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     MyWrapper wrapper = (MyWrapper)value; 
     FieldInfo field = typeof(MyWrapper).GetField("values", BindingFlags.NonPublic | BindingFlags.Instance); 
     JObject jo = JObject.FromObject(field.GetValue(wrapper)); 
     jo.WriteTo(writer); 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     JObject jo = JObject.Load(reader); 
     MyWrapper wrapper = new MyWrapper(); 
     FieldInfo field = typeof(MyWrapper).GetField("values", BindingFlags.NonPublic | BindingFlags.Instance); 
     field.SetValue(wrapper, jo.ToObject(field.FieldType)); 
     return wrapper; 
    } 
} 

扳平自定義轉換到你的包裝類，您可以在[JsonConverter]屬性添加到類定義：

[JsonConverter(typeof(DictionaryWrapperConverter))] 
class MyWrapper : IEnumerable 
{ 
    Dictionary<string, string> values = new Dictionary<string, string>(); 

    public void Add(string key, string value) 
    { 
     values.Add(key, value); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return values.GetEnumerator(); 
    } 
} 

這裏是在運行中的轉換器的完整演示，第一序列化和反序列化包裝類的一個實例，則串行化和反序列化包裝的列表：

class Program 
{ 
    static void Main(string[] args) 
    { 
     MyWrapper wrapper = new MyWrapper(); 
     wrapper.Add("foo", "bar"); 
     wrapper.Add("fizz", "bang"); 

     // serialize single wrapper instance 
     string json = JsonConvert.SerializeObject(wrapper, Formatting.Indented); 

     Console.WriteLine(json); 
     Console.WriteLine(); 

     // deserialize single wrapper instance 
     wrapper = JsonConvert.DeserializeObject<MyWrapper>(json); 

     foreach (KeyValuePair<string, string> kvp in wrapper) 
     { 
      Console.WriteLine(kvp.Key + "=" + kvp.Value); 
     } 
     Console.WriteLine(); 
     Console.WriteLine("----------\n"); 

     MyWrapper wrapper2 = new MyWrapper(); 
     wrapper2.Add("a", "1"); 
     wrapper2.Add("b", "2"); 
     wrapper2.Add("c", "3"); 

     List<MyWrapper> list = new List<MyWrapper> { wrapper, wrapper2 }; 

     // serialize list of wrappers 
     json = JsonConvert.SerializeObject(list, Formatting.Indented); 

     Console.WriteLine(json); 
     Console.WriteLine(); 

     // deserialize list of wrappers 
     list = JsonConvert.DeserializeObject<List<MyWrapper>>(json); 

     foreach (MyWrapper w in list) 
     { 
      foreach (KeyValuePair<string, string> kvp in w) 
      { 
       Console.WriteLine(kvp.Key + "=" + kvp.Value); 
      } 
      Console.WriteLine(); 
     } 
    } 
} 

輸出：

{ 
    "foo": "bar", 
    "fizz": "bang" 
} 

foo=bar 
fizz=bang 

---------- 

[ 
    { 
    "foo": "bar", 
    "fizz": "bang" 
    }, 
    { 
    "a": "1", 
    "b": "2", 
    "c": "3" 
    } 
] 

foo=bar 
fizz=bang 

a=1 
b=2 
c=3