C# Json处理相关

最近工作中遇到的Json问题确实很头大，主要是各种转义符的处理，想了一种通用的方式，来处理任意转移方式的Json字符串：

        /// <summary>
        /// 去除返回值中的转义符,返回json字符串
        /// </summary>
        /// <param name="str">待处理的转义符</param>
        /// <returns></returns>
        public static string RemoveALLEscape(string str)
        {
            string Json = "";
            string temp = "";
            //能否直接反序列化成为字典格式，如果不能，再判断是否为全转义的字符串，如果不能，就返回原值
            try
            {
                Dictionary<string, object> data = JsonConvert.DeserializeObject<Dictionary<string, object>>(str);
                Dictionary<string, object> dataNew = new Dictionary<string, object>();
                foreach (var dic in data)//遍历字典，将每个json值转化为json字符串，自动去转义然后放到新的字典中；如果不是json格式的，就直接把原值放到新字典中
                {
                    object Value = null;
                    if (dic.Value != null)
                    {
                        temp = RemoveALLEscape(dic.Value.ToString());//递归遍历每个值，去掉所有的转义符
                        try
                        {
                            var jo = JsonConvert.DeserializeObject(temp);
                            try
                            {
                                Value = JObject.Parse(jo.ToString());
                            }
                            catch
                            {
                                Value = JArray.Parse(jo.ToString());
                            }

                        }
                        catch
                        {
                            Value = dic.Value;
                        }
                        dataNew.Add(dic.Key, Value);
                    }
                    else
                    {
                        dataNew.Add(dic.Key, "");
                    }
                }
                Json = JsonConvert.SerializeObject(dataNew);
            }
            catch (Exception ex)
            {
                string st = ex.Message;
                Json = StringConvertTojson(str);
            }
            return Json;
        }

        /// <summary>
        /// 对json字符串进行去转义处理
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static string StringConvertTojson(string str)
        {
            string json = str;
            try
            {
                var jo = JsonConvert.DeserializeObject(json);
                try
                {

                    JObject jobj = JObject.Parse(jo.ToString());
                    json = JsonConvert.SerializeObject(jobj);
                }
                catch
                {
                    JArray jobj = JArray.Parse(jo.ToString());
                    json = JsonConvert.SerializeObject(jobj);
                }
            }
            catch { }
            return json;

        }

进行去转义处理主要是为了下一步的工作打算：根据维护好指定格式的Json路径，取出到该路径下的Json值，约定的Json格式如下（与Jmeter中使用JSON Extractor解析Json格式一致）：

data.data.data[0].data

解析Json路径如下：

   /// <summary>
        /// 根据Json路径去动态解析json，获取指定路径字段下的值
        /// </summary>
        /// <param name="JsonPath">维护好的Json路径,格式为data.data.data[0].data</param>
        /// <param name="Resp">需要解析的Json，先做去转义和格式化处理</param>
        /// <returns></returns>
        private static dynamic GetJsonPath(string JsonPath, string Resp)
        {

            JObject jobj = JObject.Parse(Resp);
            dynamic Value = null;
            dynamic temp = null;
            int Idex = ;
            string[] Path = JsonPath.Split('.');
            try
            {
                for (int i = ; i < Path.Length; i++)
                {
                    string path = Path[i];
                    if (!path.Contains("[") && !path.Contains("]"))
                    {
                        if (i == )
                        {
                            temp = jobj[path];
                        }
                        else
                        {
                            temp = temp[path];
                        }
                    }
                    else if (Path[i].Contains("[") && Path[i].Contains("]"))
                    {
                        int idex = Path[i].IndexOf('[');
                        Path[i] = Path[i].Remove(, idex);
                        Path[i] = Path[i].Replace("]", "").Replace("[", "");
                        Idex = Convert.ToInt32(Path[i]);
                        path = path.Replace("[" + Idex + "]", "");
                        if (i == )
                        {
                            temp = jobj[path][Idex];
                        }
                        else
                        {
                            temp = temp[path][Idex];
                        }
                    }
                    if (i == (Path.Length - )) { Value = temp; }
                }
            }
            catch (Exception ex)
            {
                Value = Path + "处理有误";
            }
            return Value;
        }

最后是Json格式化：

/// <summary>
        /// 格式化json字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string ConvertJsonString(string str)
        {

            JsonSerializer serializer = new JsonSerializer();
            TextReader tr = new StringReader(str);
            JsonTextReader jtr = new JsonTextReader(tr);
            object obj = serializer.Deserialize(jtr);
            if (obj != null)
            {
                StringWriter textWriter = new StringWriter();
                JsonTextWriter jsonWriter = new JsonTextWriter(textWriter)
                {
                    Formatting = Formatting.Indented,
                    Indentation = ,
                    IndentChar = ' '
                };
                serializer.Serialize(jsonWriter, obj);
                return textWriter.ToString();
            }
            else
            {
                return str;
            }
        }
    }