串行化時子元素的Newtonsoft內聯格式化

Question

是否可以使用newtonsoft json.net創建一個屬性來將某些子元素內聯（Formatting.None）序列化？

我有一個非常龐大的數據集，我想保持readeable。 一些子元素不是很重要，可以內聯書寫。

{ 
    "name": "xxx", 
    "desc": "xxx", 
    "subelem": [ 
     {"val1": 1, "val2": 2, ...}, //inline, 
     {"val1": 1, "val2": 2, ...}, 
     ... 
    ] 
    "subelem2": { 
     "val1": 1, 
     "val2": 2, 
     ... 
    } 
} 

我想強制我的模型的一些子對象的內聯序列化。 在這種情況下，「subelem」項目將被內聯寫入。 謝謝

Answer 1

在類上添加轉換器JsonConverterAttribute更棘手，因爲最簡單的實現將導致轉換器自行調用時的無限遞歸。因此，有必要禁用遞歸調用轉換器以線程安全的方式，像這樣：

public class NoFormattingConverter : JsonConverter 
{ 
    [ThreadStatic] 
    static bool cannotWrite; 

    // Disables the converter in a thread-safe manner. 
    bool CannotWrite { get { return cannotWrite; } set { cannotWrite = value; } } 

    public override bool CanWrite { get { return !CannotWrite; } } 

    public override bool CanRead { get { return false; } } 

    public override bool CanConvert(Type objectType) 
    { 
     throw new NotImplementedException(); // Should be applied as a property rather than included in the JsonSerializerSettings.Converters list. 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     throw new NotImplementedException(); 
    } 

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     using (new PushValue<bool>(true,() => CannotWrite, val => CannotWrite = val)) 
     using (new PushValue<Formatting>(Formatting.None,() => writer.Formatting, val => writer.Formatting = val)) 
     { 
      serializer.Serialize(writer, value); 
     } 
    } 
} 

public struct PushValue<T> : IDisposable 
{ 
    Action<T> setValue; 
    T oldValue; 

    public PushValue(T value, Func<T> getValue, Action<T> setValue) 
    { 
     if (getValue == null || setValue == null) 
      throw new ArgumentNullException(); 
     this.setValue = setValue; 
     this.oldValue = getValue(); 
     setValue(value); 
    } 

    #region IDisposable Members 

    // By using a disposable struct we avoid the overhead of allocating and freeing an instance of a finalizable class. 
    public void Dispose() 
    { 
     if (setValue != null) 
      setValue(oldValue); 
    } 

    #endregion 
} 

然後把它應用到一個類（或財產），像這樣：

[JsonConverter(typeof(NoFormattingConverter))] 
public class NestedClass 
{ 
    public string[] Values { get; set; } 
} 

public class TestClass 
{ 
    public string AValue { get; set; } 

    public NestedClass NestedClass { get; set; } 

    public string ZValue { get; set; } 

    public static void Test() 
    { 
     var test = new TestClass { AValue = "A Value", NestedClass = new NestedClass { Values = new[] { "one", "two", "three" } }, ZValue = "Z Value" }; 
     Debug.WriteLine(JsonConvert.SerializeObject(test, Formatting.Indented)); 
    } 
} 

輸出以上的Test()方法是：

{ 
    "AValue": "A Value", 
    "NestedClass":{"Values":["one","two","three"]}, 
    "ZValue": "Z Value" 
}