ASP.NET基础教程 控件编程 .NET设计模式高级应用
返回首页
当前位置: 首页 > ASP.NET教程 > 高级应用 >

发布一款轻量级的JSON转换代码

时间:2012-10-11 10:30来源:未知 作者:admin 点击:我要投稿  高质量的ASP.NET空间,完美支持1.0/2.0/3.5/4.0/MVC等

.NET FrameWork 2.0 并没有提供JSON 字符串对象化工具,因此尝试写了这个转换器, 目前已投入使用,分享一下. 实现方式是:正则 + 递归. 对需要转换的Json 字符串复杂度没有要求. 欢迎测试,并提供反馈,谢谢. 第一次运行,有点慢,估计是初使化正则占用了时间,这些正则是静态的,之后的转换会加快.
 

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Text.RegularExpressions;  
  5.  
  6. namespace JsonConver  
  7. {  
  8.  
  9.  
  10.     /// <summary>  
  11.     /// 节点枚举  
  12.     /// </summary>  
  13.     public enum NodeType  
  14.     {  
  15.         /// <summary>  
  16.         /// 标识数组  
  17.         /// </summary>  
  18.         IsArray  
  19.         ,  
  20.         /// <summary>  
  21.         /// 标识对象  
  22.         /// </summary>  
  23.         IsObject  
  24.             ,  
  25.         /// <summary>  
  26.         /// 标识元数据  
  27.         /// </summary>  
  28.         IsOriginal  
  29.  
  30.             ,  
  31.         /// <summary>  
  32.         /// 未知格式  
  33.         /// </summary>  
  34.         Undefined  
  35.     }  
  36.  
  37.     //描述Json节点  
  38.     public class JsonNode  
  39.     {  
  40.         public NodeType NodeType;  
  41.         public List<JsonNode> List;  
  42.         public Dictionary<string, JsonNode> DicObject;  
  43.         public string Value;  
  44.     }  
  45.  
  46.     /// <summary>  
  47.     /// json 字符串对象化  
  48.     /// </summary>  
  49.     public class ConvertJsonObject  
  50.     {  
  51.          static string regTxt = "({0}[^{0}{1}]*(((?'Open'{0})[^{0}{1}]*)+((?'-Open'{1})[^{0}{1}]*)+)*(?(Open)(?!)){1})";  
  52.  
  53.         //匹配字符串(单双引号范围)  
  54.          static string regKeyValue = "({0}.{1}?(?<!\\\\){0})";  //判断是否包含单,双引号  
  55.  
  56.         //匹配元数据(不包含对象,数组)  
  57.          static string regOriginalValue = string.Format("({0}|{1}|{2})"string.Format(regKeyValue, "'""*"), string.Format(regKeyValue, "\"""*"), "\\w+");  
  58.  
  59.         //匹配value  (包含对象数组)  
  60.          static string regValue = string.Format("({0}|{1}|{2})", regOriginalValue  //字符  
  61.                 , string.Format(regTxt, "\\[""\\]"), string.Format(regTxt, "\\{""\\}"));  
  62.  
  63.         //匹配键值对  
  64.          static string regKeyValuePair = string.Format("\\s*(?<key>{0}|{1}|{2})\\s*:\\s*(?<value>{3})\\s*" 
  65.              , string.Format(regKeyValue, "'""+"), string.Format(regKeyValue, "\"""+"), "([^ :,]+)" //匹配key  
  66.              , regValue);     //匹配value    
  67.  
  68.         /// <summary>  
  69.         /// 判断是否是对象  
  70.         /// </summary>  
  71.          static Regex RegJsonStrack1 = new Regex(string.Format("^\\{0}(({2})(,(?=({2})))?)+\\{1}$""{""}", regKeyValuePair), RegexOptions.Compiled);  
  72.  
  73.         /// <summary>  
  74.         /// 判断是否是序列  
  75.         /// </summary>  
  76.          static Regex RegJsonStrack2 = new Regex(string.Format("^\\[(({0})(,(?=({0})))?)+\\]$", regValue), RegexOptions.Compiled);  
  77.  
  78.         /// <summary>  
  79.         /// 判断键值对  
  80.         /// </summary>  
  81.          static Regex RegJsonStrack3 = new Regex(regKeyValuePair, RegexOptions.Compiled);  
  82.  
  83.         //匹配value  
  84.          static Regex RegJsonStrack4 = new Regex(regValue, RegexOptions.Compiled);  
  85.  
  86.         //匹配元数据  
  87.          static Regex RegJsonStrack6 = new Regex(string.Format("^{0}$", regOriginalValue), RegexOptions.Compiled);  
  88.  
  89.         //移除两端[] , {}  
  90.          static Regex RegJsonRemoveBlank = new Regex("(^\\s*[\\[\\{'\"]\\s*)|(\\s*[\\]\\}'\"]\\s*$)", RegexOptions.Compiled);  
  91.  
  92.  
  93.  
  94.  
  95.         string JsonTxt;  
  96.         public ConvertJsonObject(string json)  
  97.         {  
  98.             //去掉换行符  
  99.             json = Regex.Replace(json, "[\r\n]""");  
  100.  
  101.             JsonTxt = json;  
  102.         }  
  103.  
  104.         /// <summary>  
  105.         /// 判断节点内型  
  106.         /// </summary>  
  107.         /// <param name="json"></param>  
  108.         /// <returns></returns>  
  109.         public NodeType MeasureType(string json)  
  110.         {  
  111.             if (RegJsonStrack1.IsMatch(json))  
  112.             {  
  113.                 return NodeType.IsObject;  
  114.             }  
  115.  
  116.             if (RegJsonStrack2.IsMatch(json))  
  117.             {  
  118.                 return NodeType.IsArray;  
  119.             }  
  120.  
  121.             if (RegJsonStrack6.IsMatch(json))  
  122.             {  
  123.                 return NodeType.IsOriginal;  
  124.             }  
  125.  
  126.             return NodeType.Undefined;  
  127.  
  128.         }  
  129.  
  130.         /// <summary>  
  131.         /// json 字符串序列化为对象  
  132.         /// </summary>  
  133.         /// <param name="json"></param>  
  134.         /// <returns></returns>  
  135.         public JsonNode SerializationJsonNodeToObject()  
  136.         {  
  137.             return SerializationJsonNodeToObject(JsonTxt);  
  138.         }  
  139.  
  140.         /// <summary>  
  141.         /// json 字符串序列化为对象  
  142.         /// </summary>  
  143.         /// <param name="json"></param>  
  144.         /// <returns></returns>  
  145.         public JsonNode SerializationJsonNodeToObject(string json)  
  146.         {  
  147.             json = json.Trim();  
  148.             NodeType nodetype = MeasureType(json);  
  149.             if (nodetype == NodeType.Undefined)  
  150.             {  
  151.                 throw new Exception("未知格式Json: " + json);  
  152.             }  
  153.  
  154.             JsonNode newNode = new JsonNode();  
  155.             newNode.NodeType = nodetype;  
  156.  
  157.             if (nodetype == NodeType.IsArray)  
  158.             {  
  159.                 json = RegJsonRemoveBlank.Replace(json, "");  
  160.                 MatchCollection matches = RegJsonStrack4.Matches(json);  
  161.                 newNode.List = new List<JsonNode>();  
  162.                 foreach (Match match in matches)  
  163.                 {  
  164.                     if (match.Success)  
  165.                     {  
  166.                         newNode.List.Add(SerializationJsonNodeToObject(match.Value));  
  167.                     }  
  168.                 }  
  169.             }  
  170.             else if (nodetype == NodeType.IsObject)  
  171.             {  
  172.                 json = RegJsonRemoveBlank.Replace(json, "");  
  173.                 MatchCollection matches = RegJsonStrack3.Matches(json);  
  174.                 newNode.DicObject = new Dictionary<string, JsonNode>();  
  175.                 string key;  
  176.                 foreach (Match match in matches)  
  177.                 {  
  178.                     if (match.Success)  
  179.                     {  
  180.                         key = RegJsonRemoveBlank.Replace(match.Groups["key"].Value, "");  
  181.                         if (newNode.DicObject.ContainsKey(key))  
  182.                         {  
  183.                             throw new Exception("json 数据中包含重复键, json:" + json);  
  184.                         }  
  185.                         newNode.DicObject.Add(key, SerializationJsonNodeToObject(match.Groups["value"].Value));  
  186.                     }  
  187.                 }  
  188.             }  
  189.             else if (nodetype == NodeType.IsOriginal)  
  190.             {  
  191.                  newNode.Value = RegJsonRemoveBlank.Replace(json, "").Replace("\\r\\n""\r\n");  
  192.             }  
  193.  
  194.             return newNode;  
  195.         }  
  196.     }  

其中 JsonNode 是返回解析结果

NodeType 是枚举类型,表示当前节点是什么类型.

IsArray: JsonNode.List

IsObject:JsonNode.DicObject

IsOriginal:JsonNode.Value

Json 字符串换行请用双斜杠,如 "aa\\r\\nbb",表示aa,bb 为相邻两行.

调用代码:

 

  1. JsonConver.ConvertJsonObject jsonObj = new JsonConver.ConvertJsonObject("{'a':11,'b':[1,2,3],'c':{'a':1,'b':[1,2,3]}}");  
  2.             JsonConver.JsonNode node = jsonObj.SerializationJsonNodeToObject();  
  3.             if (node.NodeType == JsonConver.NodeType.IsObject)  
  4.             {  
  5.                 if (node.DicObject["a"].NodeType == JsonConver.NodeType.IsOriginal)  
  6.                 {  
  7.                     Console.Write("key:a , value:");  
  8.                     Console.Write(node.DicObject["a"].Value);  
  9.                     Console.WriteLine();  
  10.                 }  
  11.  
  12.                 if (node.DicObject["b"].NodeType == JsonConver.NodeType.IsArray)  
  13.                 {  
  14.                     Console.Write("key:b,value for first:");  
  15.                     Console.Write(node.DicObject["b"].List[0].Value);  
  16.                     Console.WriteLine();  
  17.                 }  
  18.  
  19.                 if (node.DicObject["c"].NodeType == JsonConver.NodeType.IsObject)  
  20.                 {  
  21.                     if (node.DicObject["c"].DicObject["a"].NodeType == JsonConver.NodeType.IsOriginal)  
  22.                     {  
  23.                         Console.Write("key:c  子对象值: , value:");  
  24.                         Console.Write(node.DicObject["c"].DicObject["a"].Value);  
  25.                         Console.WriteLine();  
  26.                     }  
  27.                 }  
  28.             }  
  29.  
  30.          
  31.  
  32.                 Console.Read(); 

 

本站推荐文章:
本站热点文章:
顶一下
(0)
0%
踩一下
(0)
0%
------分隔线----------------------------
发表评论
请自觉遵守互联网相关的政策法规,严禁发布色 情、暴力、反动的言论。
评价:
表情:
用户名:密码: 验证码:点击我更换图片