使用JSON.NET的序列化字段的顺序

Question

有没有一种方法可以使用JSON.NET来指定序列化JSON对象中字段的顺序？

指定单个字段总是首先出现就足够了。

Answer 1

我随后经由反射JsonConvert.SerializeObject(key)方法调用（其中键是一个IList），发现JsonSerializerInternalWriter.SerializeList被调用。它需要一个列表，并通过

for (int i = 0; i < values.Count; i++) { ...

其中值是IList的参数带来的遍历。

简短的回答是......不，没有内置的方法来设置字段的顺序列在JSON字符串中。

Answer 2

JSON格式的字段没有顺序，所以定义一个顺序是没有意义的。

{ id: 1, name: 'John' }相当于{ name: 'John', id: 1 }（两者都表示严格相等对象实例）

Answer 3

您可以通过执行IContractResolver或覆盖DefaultContractResolver的CreateProperties方法实际控制订单。

这里是我的简单实现IContractResolver的例子字母定购属性：

public class OrderedContractResolver : DefaultContractResolver 
{ 
    protected override System.Collections.Generic.IList<JsonProperty> CreateProperties(System.Type type, MemberSerialization memberSerialization) 
    { 
     return base.CreateProperties(type, memberSerialization).OrderBy(p => p.PropertyName).ToList(); 
    } 
} 

，然后设置设置和序列化对象，而JSON字段将是按字母顺序排列：

var settings = new JsonSerializerSettings() 
{ 
    ContractResolver = new OrderedContractResolver() 
}; 

var json = JsonConvert.SerializeObject(obj, Formatting.Indented, settings); 

Answer 4

以下递归方法使用反射来对现有的JObject实例上的内部令牌列表进行排序，而不是创建一个br和新的排序对象图。此代码依赖于内部的Json.NET实现细节，不应在生产中使用。

void SortProperties(JToken token) 
{ 
    var obj = token as JObject; 
    if (obj != null) 
    { 
     var props = typeof (JObject) 
      .GetField("_properties", 
         BindingFlags.NonPublic | BindingFlags.Instance) 
      .GetValue(obj); 
     var items = typeof (Collection<JToken>) 
      .GetField("items", BindingFlags.NonPublic | BindingFlags.Instance) 
      .GetValue(props); 
     ArrayList.Adapter((IList) items) 
      .Sort(new ComparisonComparer(
       (x, y) => 
       { 
        var xProp = x as JProperty; 
        var yProp = y as JProperty; 
        return xProp != null && yProp != null 
         ? string.Compare(xProp.Name, yProp.Name) 
         : 0; 
       })); 
    } 
    foreach (var child in token.Children()) 
    { 
     SortProperties(child); 
    } 
} 

Answer 5

支持的方法是使用上要设置订单的类属性的属性JsonProperty。 Read the JsonPropertyAttribute order documentation for more information。

通过JsonProperty和Order值，序列化程序将处理其余的。

[JsonProperty(Order = 1)] 

这是非常相似的

DataMember(Order = 1) 

的 System.Runtime.Serialization天

。

Answer 6

在我的情况下，Mattias的答案没有奏效。 CreateProperties方法从未被调用过。

在对Newtonsoft.Json内部进行了一些调试之后，我想出了另一种解决方案。

public class JsonUtility 
{ 
    public static string NormalizeJsonString(string json) 
    { 
     // Parse json string into JObject. 
     var parsedObject = JObject.Parse(json); 

     // Sort properties of JObject. 
     var normalizedObject = SortPropertiesAlphabetically(parsedObject); 

     // Serialize JObject . 
     return JsonConvert.SerializeObject(normalizedObject); 
    } 

    private static JObject SortPropertiesAlphabetically(JObject original) 
    { 
     var result = new JObject(); 

     foreach (var property in original.Properties().ToList().OrderBy(p => p.Name)) 
     { 
      var value = property.Value as JObject; 

      if (value != null) 
      { 
       value = SortPropertiesAlphabetically(value); 
       result.Add(property.Name, value); 
      } 
      else 
      { 
       result.Add(property.Name, property.Value); 
      } 
     } 

     return result; 
    } 
} 

Answer 7

实际上，因为我的目标已经是一个JObject，我用以下解决方案：

public class SortedJObject : JObject 
{ 
    public SortedJObject(JObject other) 
    { 
     var pairs = new List<KeyValuePair<string, JToken>>(); 
     foreach (var pair in other) 
     { 
      pairs.Add(pair); 
     } 
     pairs.OrderBy(p => p.Key).ForEach(pair => this[pair.Key] = pair.Value); 
    } 
} 

，然后用它是这样的：

string serializedObj = JsonConvert.SerializeObject(new SortedJObject(dataObject)); 

Answer 8

在我的情况niaher的解决方案做了不工作，因为它没有处理数组中的对象。

基于他的解决办法，这是我想出了

public static class JsonUtility 
{ 
    public static string NormalizeJsonString(string json) 
    { 
     JToken parsed = JToken.Parse(json); 

     JToken normalized = NormalizeToken(parsed); 

     return JsonConvert.SerializeObject(normalized); 
    } 

    private static JToken NormalizeToken(JToken token) 
    { 
     JObject o; 
     JArray array; 
     if ((o = token as JObject) != null) 
     { 
      List<JProperty> orderedProperties = new List<JProperty>(o.Properties()); 
      orderedProperties.Sort(delegate(JProperty x, JProperty y) { return x.Name.CompareTo(y.Name); }); 
      JObject normalized = new JObject(); 
      foreach (JProperty property in orderedProperties) 
      { 
       normalized.Add(property.Name, NormalizeToken(property.Value)); 
      } 
      return normalized; 
     } 
     else if ((array = token as JArray) != null) 
     { 
      for (int i = 0; i < array.Count; i++) 
      { 
       array[i] = NormalizeToken(array[i]); 
      } 
      return array; 
     } 
     else 
     { 
      return token; 
     } 
    } 
} 

Answer 9

如果你控制（即写入）类，把属性按字母顺序排列，他们将按照字母顺序序列化时JsonConvert.SerializeObject()被调用。

Answer 10

查理指出，可以一定程度上受到的类本身订货属性控制JSON属性的排序。不幸的是，这种方法不适用于从基类继承的属性。基类属性将按照它们在代码中的布局进行排序，但会显示在基类属性之前。

而且任何人都知道为什么，你可能想按字母顺序排列JSON性能，它是一个整体更容易与原始JSON文件的工作，特别是对类有很多的属性，如果他们是有序的。