爲Json對象生成的C＃類的好處和缺點

Question

我有示例Json，我需要將它序列化爲C＃對象。我決定爲此使用Json.Net庫。另外我需要有C＃類來代表這個Json。創建類可以使用Json C# class generator。我們有兩個選擇。 「創建屬性」和生成的類將是這樣的：

public class Address 
{ 
    private JObject __jobject; 
    public Address(JObject obj) 
    { 
     this.__jobject = obj; 
    } 
    public string street_address 
    { 
     get 
     { 
      return JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(__jobject, "street_address")); 
     } 
    } 
    public string city 
    { 
     get 
     { 
      return JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(__jobject, "city")); 
     } 
    } 
    public string state_province 
    { 
     get 
     { 
      return JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(__jobject, "state_province")); 
     } 
    } 
    public string zip_postal_code 
    { 
     get 
     { 
      return JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(__jobject, "zip_postal_code")); 
     } 
    } 
} 

，另一個選項是「生成預填充的只讀域」和類看起來就像

public class Address 
{ 

    public Address(JObject obj) 
    { 
     this.street_address = JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(obj, "street_address")); 
     this.city = JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(obj, "city")); 
     this.state_province = JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(obj, "state_province")); 
     this.zip_postal_code = JsonClassHelper.ReadString(JsonClassHelper.GetJToken<JValue>(obj, "zip_postal_code")); 
    } 

    public readonly string street_address; 
    public readonly string city; 
    public readonly string state_province; 
    public readonly string zip_postal_code; 
} 

這兩個生成的類依賴JObject和JsonClassHelper。但這些類不能與JsonSerializer用於像

var ro = jsonSerializer.Deserialize<RootObject>(reader); 

我們可以通過JObject.Load方法

var ro = new RootObject(Newtonsoft.Json.Linq.JObject.Load(reader)); 

另一種方式創建這些類的對象是使用在線json2csharp轉換器和類看起來像

public class Address 
{ 
    public string street_address { get; set; } 
    public string city { get; set; } 
    public string state_province { get; set; } 
    public string zip_postal_code { get; set; } 
} 

JsonSerializer可以處理這個類。

我的問題是什麼類生成器是最好使用，什麼是使用每種類型的生成的類的好處和缺點？
謝謝你的建議。

Answer 1

我假設你想將json字符串反序列化爲c＃對象。我通常自己創建C＃對象，並使用JsonConvert來反序列化json字符串。

class Program { 
     static void Main(string[] args) 
     { 
       string json = @" 
       { 
         ""street_address"":""My street address"", 
         ""city"":""My City"", 
         ""state_province"":""My State Province"", 
         ""zip_postal_code"":""My Zip Postal Code"", 
       }"; 

       Address address = JsonConvert.DeserializeObject<Address>(json); 
       Console.WriteLine("Street address: {0}", address.StreetAddress); 
       Console.WriteLine("City: {0}", address.City); 
       Console.WriteLine("State province: {0}", address.StateProvince); 
       Console.WriteLine("Zip postal code: {0}", address.ZipPostalCode); 
     } 
} 

public class Address { 
     [JsonProperty("street_address")] 
     public string StreetAddress { get; set; } 

     [JsonProperty("city")] 
     public string City { get; set; } 

     [JsonProperty("state_province")] 
     public string StateProvince { get; set; } 

     [JsonProperty("zip_postal_code")] 
     public string ZipPostalCode { get; set; } 
} 

Answer 2

我從來不使用類生成器。當班級很少時，我手動編寫它們。當反序列化過程需要很多類時，我傾向於使用dynamic對象，並將其用作here，這使代碼更具可讀性。

這裏是dynamic json

string json = @"{Users:[{Name:'name1',Id:1},{Name:'name2',Id:2}]}"; 
dynamic obj = JsonUtils.JsonObject.GetDynamicJsonObject(json); 
foreach (var user in obj.Users) 
{ 
    Console.WriteLine("{0} {1}", user.Name, user.Id); 
} 

Answer 3

用法的例子。如果你知道你將回到什麼樣的對象，然後看看在4.0框架使用System.Runtime.Serialization.Json命名空間。這是很多比JSON.NET更容易使用。事實上，這可能是最簡單的選擇。

包括（使用語句和）這個命名空間的引用之後，你需要你的類與[DataContract]屬性，並與[數據成員]屬性每個屬性標記。然後，你可以使用像這樣的通用程序：

/// <summary> 
/// 
/// Generic helper class to convert JSON text to in-memory objects 
/// </summary> 
/// <typeparam name="T">Type of class that the text represents</typeparam> 
public class JSONHandler<T> where T : class, new() 
{ 
    /// <summary> 
    /// Convert a JSON string to an in-memory object of class T. 
    /// The class T must be instantiable and not static. 
    /// </summary> 
    /// <param name="JSONString">JSON string describing the top level object</param> 
    /// <returns>Object of class T (and any dependent objects)</returns> 
    public T TextToJSON(string JSONString) 
    { 
     //check that we aren't passing in empty text 
     if (String.IsNullOrEmpty(JSONString)) 
     { 
      return null; 
     } 
     else 
     { 
      //create a new object 
      T JSONObject = new T(); 
      //and create a new serializer for it 
      DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T)); 
      //create a memor stream around the text 
      System.IO.MemoryStream ms = new System.IO.MemoryStream(Encoding.Unicode.GetBytes(JSONString)); 
      //do the conversion 
      JSONObject = (T)ser.ReadObject(ms); 
      //tidy up after ourselves 
      ms.Close(); 
      //and we're done! 
      return JSONObject; 
     } 
    }  
} 

這就是它的全部。