C#解析Json的类

转载 2012年03月24日 12:43:00
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Web;  
  4. using System.Text.RegularExpressions;  
  5. using System.Text;  
  6.   
  7. namespace System.JSON  
  8. {  
  9.   
  10.     static class JSONConvert  
  11.     {  
  12.         #region 全局变量  
  13.   
  14.         private static JSONObject _json = new JSONObject();//寄存器   
  15.         private static readonly string _SEMICOLON = "@semicolon";//分号转义符   
  16.         private static readonly string _COMMA = "@comma"//逗号转义符   
  17.  
  18.         #endregion  
  19.  
  20.         #region 字符串转义  
  21.         /// <summary>   
  22.         /// 字符串转义,将双引号内的:和,分别转成_SEMICOLON和_COMMA   
  23.         /// </summary>   
  24.         /// <param name="text"></param>   
  25.         /// <returns></returns>   
  26.         private static string StrEncode(string text)  
  27.         {  
  28.             MatchCollection matches = Regex.Matches(text, "///"[^///"]+///"");  
  29.             foreach (Match match in matches)  
  30.             {  
  31.                 text = text.Replace(match.Value, match.Value.Replace(":", _SEMICOLON).Replace(",", _COMMA));  
  32.             }  
  33.   
  34.             return text;  
  35.         }  
  36.   
  37.         /// <summary>   
  38.         /// 字符串转义,将_SEMICOLON和_COMMA分别转成:和,   
  39.         /// </summary>   
  40.         /// <param name="text"></param>   
  41.         /// <returns></returns>   
  42.         private static string StrDecode(string text)  
  43.         {  
  44.             return text.Replace(_SEMICOLON, ":").Replace(_COMMA, ",");  
  45.         }  
  46.  
  47.         #endregion  
  48.  
  49.         #region JSON最小单元解析  
  50.   
  51.         /// <summary>   
  52.         /// 最小对象转为JSONObject   
  53.         /// </summary>   
  54.         /// <param name="text"></param>   
  55.         /// <returns></returns>   
  56.         private static JSONObject DeserializeSingletonObject(string text)  
  57.         {  
  58.             JSONObject jsonObject = new JSONObject();  
  59.   
  60.             MatchCollection matches = Regex.Matches(text, "(///"(?<key>[^///"]+)///":///"(?<value>[^,///"]+)///")|(///"(?<key>[^///"]+)///":(?<value>[^,///"//}]+))");  
  61.             foreach (Match match in matches)  
  62.             {  
  63.                 string value = match.Groups["value"].Value;  
  64.                 jsonObject.Add(match.Groups["key"].Value, _json.ContainsKey(value) ? _json[value] : StrDecode(value));  
  65.             }  
  66.   
  67.             return jsonObject;  
  68.         }  
  69.   
  70.         /// <summary>   
  71.         /// 最小数组转为JSONArray   
  72.         /// </summary>   
  73.         /// <param name="text"></param>   
  74.         /// <returns></returns>   
  75.         private static JSONArray DeserializeSingletonArray(string text)  
  76.         {  
  77.             JSONArray jsonArray = new JSONArray();  
  78.   
  79.             MatchCollection matches = Regex.Matches(text, "(///"(?<value>[^,///"]+)/")|(?<value>[^,//[//]]+)");  
  80.             foreach (Match match in matches)  
  81.             {  
  82.                 string value = match.Groups["value"].Value;  
  83.                 jsonArray.Add(_json.ContainsKey(value) ? _json[value] : StrDecode(value));  
  84.             }  
  85.   
  86.             return jsonArray;  
  87.         }  
  88.   
  89.         /// <summary>   
  90.         /// 反序列化   
  91.         /// </summary>   
  92.         /// <param name="text"></param>   
  93.         /// <returns></returns>   
  94.         private static string Deserialize(string text)  
  95.         {  
  96.             text = StrEncode(text);//转义;和,   
  97.   
  98.             int count = 0;  
  99.             string key = string.Empty;  
  100.             string pattern = "(//{[^//[//]//{//}]+//})|(//[[^//[//]//{//}]+//])";  
  101.   
  102.             while (Regex.IsMatch(text, pattern))  
  103.             {  
  104.                 MatchCollection matches = Regex.Matches(text, pattern);  
  105.                 foreach (Match match in matches)  
  106.                 {  
  107.                     key = "___key" + count + "___";  
  108.   
  109.                     if (match.Value.Substring(0, 1) == "{")  
  110.                         _json.Add(key, DeserializeSingletonObject(match.Value));  
  111.                     else  
  112.                         _json.Add(key, DeserializeSingletonArray(match.Value));  
  113.   
  114.                     text = text.Replace(match.Value, key);  
  115.   
  116.                     count++;  
  117.                 }  
  118.             }  
  119.             return text;  
  120.         }  
  121.  
  122.         #endregion  
  123.  
  124.         #region 公共接口  
  125.   
  126.         /// <summary>   
  127.         /// 序列化JSONObject对象   
  128.         /// </summary>   
  129.         /// <param name="text"></param>   
  130.         /// <returns></returns>   
  131.         public static JSONObject DeserializeObject(string text)  
  132.         {  
  133.             _json = new JSONObject();  
  134.             return _json[Deserialize(text)] as JSONObject;  
  135.         }  
  136.   
  137.         /// <summary>   
  138.         /// 序列化JSONArray对象   
  139.         /// </summary>   
  140.         /// <param name="text"></param>   
  141.         /// <returns></returns>   
  142.         public static JSONArray DeserializeArray(string text)  
  143.         {  
  144.             _json = new JSONObject();  
  145.             return _json[Deserialize(text)] as JSONArray;  
  146.         }  
  147.   
  148.         /// <summary>   
  149.         /// 反序列化JSONObject对象   
  150.         /// </summary>   
  151.         /// <param name="jsonObject"></param>   
  152.         /// <returns></returns>   
  153.         public static string SerializeObject(JSONObject jsonObject)  
  154.         {  
  155.             StringBuilder sb = new StringBuilder();  
  156.             sb.Append("{");  
  157.             foreach (KeyValuePair<stringobject> kvp in jsonObject)  
  158.             {  
  159.                 if (kvp.Value is JSONObject)  
  160.                 {  
  161.                     sb.Append(string.Format("/"{0}/":{1},", kvp.Key, SerializeObject((JSONObject)kvp.Value)));  
  162.                 }  
  163.                 else if (kvp.Value is JSONArray)  
  164.                 {  
  165.                     sb.Append(string.Format("/"{0}/":{1},", kvp.Key, SerializeArray((JSONArray)kvp.Value)));  
  166.                 }  
  167.                 else if (kvp.Value is String)  
  168.                 {  
  169.                     sb.Append(string.Format("/"{0}/":/"{1}/",", kvp.Key, kvp.Value));  
  170.                 }  
  171.                 else  
  172.                 {  
  173.                     sb.Append(string.Format("/"{0}/":/"{1}/",", kvp.Key, ""));  
  174.                 }  
  175.             }  
  176.             if (sb.Length > 1)  
  177.                 sb.Remove(sb.Length - 1, 1);  
  178.             sb.Append("}");  
  179.             return sb.ToString();  
  180.         }  
  181.   
  182.         /// <summary>   
  183.         /// 反序列化JSONArray对象   
  184.         /// </summary>   
  185.         /// <param name="jsonArray"></param>   
  186.         /// <returns></returns>   
  187.         public static string SerializeArray(JSONArray jsonArray)  
  188.         {  
  189.             StringBuilder sb = new StringBuilder();  
  190.             sb.Append("[");  
  191.             for (int i = 0; i < jsonArray.Count; i++)  
  192.             {  
  193.                 if (jsonArray[i] is JSONObject)  
  194.                 {  
  195.                     sb.Append(string.Format("{0},", SerializeObject((JSONObject)jsonArray[i])));  
  196.                 }  
  197.                 else if (jsonArray[i] is JSONArray)  
  198.                 {  
  199.                     sb.Append(string.Format("{0},", SerializeArray((JSONArray)jsonArray[i])));  
  200.                 }  
  201.                 else if (jsonArray[i] is String)  
  202.                 {  
  203.                     sb.Append(string.Format("/"{0}/",", jsonArray[i]));  
  204.                 }  
  205.                 else  
  206.                 {  
  207.                     sb.Append(string.Format("/"{0}/","""));  
  208.                 }  
  209.   
  210.             }  
  211.             if (sb.Length > 1)  
  212.                 sb.Remove(sb.Length - 1, 1);  
  213.             sb.Append("]");  
  214.             return sb.ToString();  
  215.         }  
  216.         #endregion  
  217.     }  
  218.   
  219.     /// <summary>   
  220.     /// 取出JSON对象类   
  221.     /// </summary>   
  222.     public class JSONObject : Dictionary<stringobject>  
  223.     {  
  224.         public new void Add(string key, object value)  
  225.         {  
  226.             System.Type t = value.GetType();  
  227.   
  228.             if (t.Name == "String")  
  229.             {  
  230.                 value = JSONEncode.StrEncodeForDeserialize(value.ToString());  
  231.             }  
  232.   
  233.             base.Add(key, value);  
  234.         }  
  235.         public override string ToString()  
  236.         {  
  237.             return JSONConvert.SerializeObject(this);  
  238.         }  
  239.         public static JSONObject FromObject(string json)  
  240.         {  
  241.             return JSONConvert.DeserializeObject(json);  
  242.         }  
  243.     }  
  244.   
  245.     /// <summary>   
  246.     /// 取出JSON数组类   
  247.     /// </summary>   
  248.     public class JSONArray : List<object>  
  249.     {  
  250.         public new void Add(object item)  
  251.         {  
  252.             System.Type t = item.GetType();  
  253.   
  254.             if (t.Name == "String")  
  255.             {  
  256.                 item = JSONEncode.StrEncodeForDeserialize(item.ToString());  
  257.             }  
  258.   
  259.             base.Add(item);  
  260.         }  
  261.         public override string ToString()  
  262.         {  
  263.             return JSONConvert.SerializeArray(this);  
  264.         }  
  265.         public JSONArray FromObject(string json)  
  266.         {  
  267.             return JSONConvert.DeserializeArray(json);  
  268.         }  
  269.     }  
  270.   
  271.     /// <summary>   
  272.     /// 字符串转义,将"{"、"}"、"""   
  273.     /// </summary>   
  274.     public class JSONEncode  
  275.     {  
  276.         public static readonly string _LEFTBRACES = "@leftbraces";//"{"转义符   
  277.         public static readonly string _RIGHTBRACES = "@rightbraces";//"}"转义符   
  278.         public static readonly string _LEFTBRACKETS = "@leftbrackets";//"["转义符   
  279.         public static readonly string _RIGHTBRACKETS = "@rightbrackets";//"]"转义符   
  280.         public static readonly string _DOUBLEQUOTATIONMARKS = "@doubleQuotationMarks";//"""转义符   
  281.  
  282.  
  283.         #region 字符串转义  
  284.         /// <summary>   
  285.         /// 字符串转义,将"{"、"}"、""",分别转换_LEFTBRACES、_RIGHTBRACES、_DOUBLEQUOTATIONMARKS   
  286.         /// </summary>   
  287.         /// <param name="text"></param>   
  288.         /// <returns></returns>   
  289.         public static string StrEncodeForDeserialize(string text)  
  290.         {  
  291.             return text  
  292.             .Replace("{", _LEFTBRACES)  
  293.             .Replace("}", _RIGHTBRACES)  
  294.             .Replace("[", _LEFTBRACKETS)  
  295.             .Replace("]", _RIGHTBRACKETS)  
  296.             .Replace("/"", _DOUBLEQUOTATIONMARKS);  
  297.         }  
  298.   
  299.         /// <summary>   
  300.         /// 字符串转义,将_LEFTBRACES、_RIGHTBRACES、_DOUBLEQUOTATIONMARKS,分别转换"{"、"}"、"""   
  301.         /// </summary>   
  302.         /// <param name="text"></param>   
  303.         /// <returns></returns>   
  304.         public static string StrDecodeForDeserialize(string text)  
  305.         {  
  306.             return text.Replace(_LEFTBRACES, "{")  
  307.             .Replace(_RIGHTBRACES, "}")  
  308.             .Replace(_LEFTBRACKETS, "[")  
  309.             .Replace(_RIGHTBRACKETS, "]")  
  310.             .Replace(_DOUBLEQUOTATIONMARKS, "/"");  
  311.         }  
  312.         #endregion  
  313.     }  
  314. }  

相关文章推荐

JSON解析类(C#)

一个.NET通用JSON解析/构建类的实现(c#)

一个.NET通用JSON解析/构建类的实现(c#) 在.NET Framework 3.5中已经提供了一个JSON对象的序列化工具,但是他是强类型的,必须先按JSON对象的格式定...

一个.NET通用JSON解析/构建类的实现(c#)

在.NET Framework 3.5中已经提供了一个JSON对象的序列化工具,但是他是强类型的,必须先按JSON对象的格式定义一个类型,并将类型加上JSON序列化特性。本文将试图提供一个高度灵活的J...

JSON解析类(C#)

使用本文中的JSONConvert类可将任意JSON字符串转化为JSONObject或JSONArray对象,并获取需要的值,克服了.NET自带JSON类反序列化时需知道并引用序列化时使用的类的缺点。...

C#封装和解析json

  • 2015-08-19 16:17
  • 82KB
  • 下载

c#解析Json数据

JSON(全称为JavaScript Object Notation) 是一种轻量级的数据交换格式。它是基于JavaScript语法标准的一个子集。 JSON采用完全独立于语言的文本格式,可以很容易在...

c#,JSON解析,字典Demo

  • 2015-10-22 13:25
  • 168KB
  • 下载

c#如何解析Json

  • 2014-01-17 11:29
  • 337KB
  • 下载

c# 解析json数据

1 解析需要用到 Newtonsoft.Json.dll ,c#需要引用此dll 2 添加一个类文件JSON.cs类文件,代码如下using Newtonsoft.Json; using Newto...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)