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

Question

有没有办法使用JSON.NET指定序列化JSON对象中的字段顺序？

指定单个字段始终首先出现就足够了.

Answer 1

支持的方法是JsonProperty在要为其设置顺序的类属性上使用该属性.有关更多信息,请阅读JsonPropertyAttribute订单文档.

传递JsonProperty一个Order值,序列化器将处理其余的事情.

 [JsonProperty(Order = 1)]

这非常类似于

 DataMember(Order = 1) 

的System.Runtime.Serialization日子.

这是来自@ kevin-babcock的重要说明

...将订单设置为1只有在所有其他属性上设置大于1的订单时才有效.默认情况下,任何没有Order设置的属性都将被赋予-1的顺序.因此,您必须提供所有序列化属性和订单,或将您的第一个项目设置为-2

Answer 2

实际上,你可以通过实现控制命令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 3

就我而言,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 4

在我的情况下,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 5

这也适用于普通类、字典和 ExpandoObject（动态对象）。

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



class OrderedExpandoPropertiesConverter : ExpandoObjectConverter
    {
        public override bool CanWrite
        {
            get { return true; }
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var expando = (IDictionary<string, object>)value;
            var orderedDictionary = expando.OrderBy(x => x.Key).ToDictionary(t => t.Key, t => t.Value);
            serializer.Serialize(writer, orderedDictionary);
        }
    }



var settings = new JsonSerializerSettings
        {
            ContractResolver = new OrderedPropertiesContractResolver(),
            Converters = { new OrderedExpandoPropertiesConverter() }
        };

var serializedString = JsonConvert.SerializeObject(obj, settings);

Answer 6

如果您只想将单个属性拉到前面而不考虑可能不直观的数字系统，只需使用int.MinValue。

[JsonProperty(Order = int.MinValue)]