C# Json排序（支持依靠属性的对象排序）

函数的命名规范有点问题，不过不是很影响使用，如果有bug欢迎评论，需要Newton的json包

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;

namespace YourNamespace.Json
{
    public static class JsonSorter
    {
        /// <summary>
        /// 对Json格式的字符串进行排序
        /// </summary>
        /// <param name="jsonText">需要排序的字符串</param>
        /// <param name="sortProperty">如果其中包含对象数组，将会使用这个数组中的一个属性的值作为排序依据</param>
        /// <returns></returns>
        public static string Sort(string jsonText, string[] sortProperty)
        {
            return GetSortObject(JToken.Parse(jsonText), sortProperty).ToString();
        }

        private static JToken GetSortObject(JToken obj, string[] sortProperty)
        {
            if (obj is JArray)
            {
                var sortedArray = new JArray();
                
                foreach (var item in (obj as JArray).Sort(sortProperty))
                {
                    sortedArray.Add(GetSortObject(item, sortProperty));
                }
                return sortedArray;
            }
            else if(obj is JValue)
            {
                return obj;
            }
            else
            {
                var paramDic = JsonConvert.DeserializeObject<Dictionary<string, dynamic>>(JsonConvert.SerializeObject(obj));
                SortedDictionary<string, dynamic> sortedDic = new SortedDictionary<string, dynamic>(paramDic);
                var sortedJOject = new JObject();
                for (int i = 0; i < sortedDic.Count; i++)
                {
                    if (sortedDic.ElementAt(i).Value is JArray || sortedDic.ElementAt(i).Value is JObject)
                    {
                        sortedJOject.Add(sortedDic.ElementAt(i).Key, GetSortObject(sortedDic.ElementAt(i).Value, sortProperty));
                    }
                    else
                    {
                        sortedJOject.Add(sortedDic.ElementAt(i).Key, sortedDic.ElementAt(i).Value);
                    }
                }
                return sortedJOject;
            }
        }

        private static JArray Sort(this JArray jArray, string[] sortProperty = null)
        {
            if (jArray.IsAllJObect() && sortProperty != null && sortProperty.Length > 0)
            {
                return jArray.SortWithProperties(sortProperty);
            }
            else if (jArray.IsAllInterger())
            {
                var list = new List<int>();
                var sortedJArray = jArray.ToList();
                sortedJArray.Sort(delegate (JToken x, JToken y)
                {
                    var objx = x as JValue;
                    var objy = y as JValue;

                    return objx.Value<int>().CompareTo(objy.Value<int>());
                });
                return sortedJArray.ToJArray();
            }
            else if(jArray.IsAllString())
            {
                var list = new List<int>();
                var sortedJArray = jArray.ToList();
                sortedJArray.Sort(delegate (JToken x, JToken y)
                {
                    var objx = x as JValue;
                    var objy = y as JValue;

                    return objx.Value<string>().CompareTo(objy.Value<string>());
                });
                return sortedJArray.ToJArray();
            }
            return jArray;
        }

        private static JArray SortWithProperties(this JArray jArray, string[] sortProperty)
        {
            foreach(JToken token in jArray)
            {
                if(!(token is JObject))
                {
                    return jArray;
                }
            }
            string propertyName = "";
            foreach(var tempPropertyName in sortProperty)
            {
                if (jArray.AllHasThisProperty(tempPropertyName))
                    propertyName = tempPropertyName;
            }
            if (propertyName == "")
                return jArray;

            var sortedJArray = jArray.ToList();
            sortedJArray.Sort(delegate (JToken x, JToken y)
            {
                var objx = x as JObject;
                var objy = y as JObject;

                return objx.GetValue(propertyName).ToString().CompareTo(objy.GetValue(propertyName).ToString());
            });
            return sortedJArray.ToJArray();
        }

        private static bool AllHasThisProperty(this JArray jArray, string propertyName)
        {
            foreach(var obj in jArray)
            {
                JToken token;
                if(obj is JObject)
                {
                    if (!(obj as JObject).TryGetValue(propertyName, out token))
                        return false;
                }
                else
                    return false;
            }
            return true;
        }

        private static bool IsAllJObect(this JArray jArray)
        {
            foreach(JToken token in jArray)
            {
                if (!(token is JObject))
                    return false;
            }
            return true;
        }

        private static bool IsAllString(this JArray jArray)
        {
            foreach (JToken token in jArray)
            {
                if (!(token is JValue))
                    return false;
                else
                {
                    if ((token as JValue).Type != JTokenType.String)
                        return false;
                }
            }
            return true;
        }

        private static bool IsAllInterger(this JArray jArray)
        {
            foreach (JToken token in jArray)
            {
                if (!(token is JValue))
                    return false;
                else
                {
                    if ((token as JValue).Type != JTokenType.Integer)
                        return false;
                }
            }
            return true;
        }

        private static JArray ToJArray(this List<JToken> list)
        {
            var jArray = new JArray();
            list.ForEach(token => jArray.Add(token));
            return jArray;
        }
    }
}