c# 自定义解析JSON字符串数据

解析json字符串有很多方式, 1 : 在网上下载json解析的dll类库并添加引用, 调用相关方法; 2 : 使用自带类库JavaScriptSerializer的序列号和反序列化; 对于以上两个方法我没有试用过, 应该很方便很简洁性能很高吧!

自己根据遍历字符串找json字符串规律, 自己写了一个类库, 只有一个方法只提供解析, 没有其他方法. 缺点 : 可能比较死板, 可能性能也不及网上下载解析类库.

经测试和调试后可以遍历大部分json字符串数据, json字符串可以嵌套, 但要符合json的规律, 数据中不能出现json字符串敏感关键字符 " 和 , 和 [ ] 和 { } ,数据中如果需要使用可以使用中文字符代替.

数据返回结果存放在 Dictionary<string, object> 键 值对中, 如果 值为字符串, 那么object就为字符串,为了嵌套, 如果 值为数组, 那么object就为 List<object> , 如果值为一个对象, 那么object就存放在 Dictionary<string, object> 如此嵌套下去, 最终数据我们根据自己的json数据结构遍历Dictionary<string, object>集合即可. (注 : 每个Dictionary中键必须唯一)

1. 解析类 : AnalyzeJSON 全部代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace System.AnalyzeJSON
{
    /// <summary>
    /// 对于 JSON数据进行解析
    /// Date:2019/6/25
    /// Author:weloglog  
    /// </summary>
    public class AnalyzeJSON
    {
        /// <summary>
        /// 最大嵌套深度
        /// </summary>
        public int MaxNum = 50;

        /// <summary>
        /// 解析JSON字符串
        /// </summary>
        /// <param name="strJSON">JSON字符串</param>
        /// <returns>返回Dictionary数据</returns>
        public Dictionary<string, object> AnalyzeString(string strJSON)
        {
            if (strJSON == null || strJSON.Trim() == "" || strJSON.Trim().Length < 0)
            {
                return null;
            }

            #region 筛选判断并赋值  [此步骤可以省略]
            int idF = -1;//第一个 { 下标索引
            int idL = -1;//最后一个 } 下标索引
            int mD = 0;//记录 { } 的个数对
            int mZ = 0;//记录 [ ] 的个数对
            for (int i = 0; i < strJSON.Length; i++)
            {
                if (mD > MaxNum || mZ > MaxNum)
                {
                    break;//不满足条件退出循环
                }
                if (idF == -1 && strJSON[i] == '{')
                {
                    idF = i;//取第一个 { 下标
                }
                if (strJSON[i] == '{')
                {
                    mD++;
                    if (idL > 0)
                    {
                        break;
                    }
                }
                if (strJSON[i] == '}')
                {
                    mD--;
                    if (mD == 0)
                    {
                        idL = i;
                    }
                }
                if (strJSON[i] == '[')
                {
                    mZ++;
                }
                if (strJSON[i] == ']')
                {
                    mZ--;
                }
            }
            if (mD == 0 && mZ == 0 && idL > 0 && idL - idF > 1)
            {
                strJSON = strJSON.Substring(idF, idL - idF + 1);//重新赋值json字符串数据, 去掉{ }前后多余部分
            }
            else
            {
                return null;//条件不满足, JSON字符串不规范
            }
            #endregion

            //遍历 并返回
            return obj(strJSON);
        }

        //遇到 { } 的处理函数
        private Dictionary<string, object> obj(string str)
        {
            Dictionary<string, object> ro = new Dictionary<string, object>();

            int dc = 0;//{ } 的对数
            int len = str.Length;
            for (int i = 0; i < len; i++)
            {
                if (str[i] == '{')
                {
                    dc++;
                }
                if (str[i] == '}')
                {
                    dc--;
                }
                if (str[i] != '{' && dc > 0)
                {
                    StringBuilder tem = new StringBuilder();
                    StringBuilder ojtem = new StringBuilder();
                    bool isstr = false;
                    object oj = "";
                    int c = 0;//次数
                    bool iskey = true;//是否为键赋值
                    bool isString = true;//值是否为字符串类型
                    while (i < len && str[i] != ',')
                    {
                        if (iskey) //给键 赋值
                        {
                            if (str[i] != '"')
                            {
                                if (str[i] == ':')
                                {
                                    iskey = false;
                                    c = -1;//重置
                                }
                                else
                                {
                                    //tem += str[i];
                                    tem.Append(str[i]);
                                }
                            }
                        }
                        else //给值 赋值
                        {
                            //特殊情况, 遇到 { } 和 [ ] 的情况
                            if (isString && str[i] == '[')//只允许第一次进入
                            {
                                isString = false;
                                int idxs = 0;//记录 [ ] 出现的次数
                                StringBuilder tm = new StringBuilder();
                                while (i < len)
                                {
                                    if (str[i] == '[')
                                    {
                                        idxs++;
                                    }
                                    if (str[i] == ']')
                                    {
                                        idxs--;
                                    }
                                    tm.Append(str[i]);
                                    i++;
                                    if (idxs == 0)//变成一个完整的组合
                                    {
                                        break;
                                    }
                                }
                                oj = arr(tm.ToString());
                                break;
                            }
                            else if (isString && str[i] == '{')//只允许第一次进入
                            {
                                isString = false;
                                int idxs = 0;//记录 { } 出现的次数
                                StringBuilder tm = new StringBuilder();
                                while (i < len)
                                {
                                    if (str[i] == '{')
                                    {
                                        idxs++;
                                    }
                                    if (str[i] == '}')
                                    {
                                        idxs--;
                                    }
                                    tm.Append(str[i]);
                                    i++;
                                    if (idxs == 0)//变成一个完整的组合
                                    {
                                        break;
                                    }
                                }
                                oj = obj(tm.ToString());
                                break;
                            }
                            else
                            {
                                if (str[i] != '"')
                                {
                                    if (str[i] == ',' || str[i] == '}' || str[i] == ']')//跳出循环
                                    {
                                        break;
                                    }
                                    else
                                    {
                                        isstr = true;
                                        ojtem.Append(str[i]);
                                    }
                                }
                            }
                        }
                        c++;
                        i++;
                    }
                    c = 0;
                    try//键 唯一
                    {
                        if (tem != null && tem.ToString().Length > 0)
                        {
                            if (isstr)
                            {
                                ro.Add(tem.ToString(), ojtem);//添加
                                isstr = false;
                            }
                            else
                            {
                                ro.Add(tem.ToString(), oj);//添加
                            }
                        }
                    }
                    catch { }
                }
            }
            return ro;
        }

        //遇到 [ ] 的处理函数
        private object arr(string str)
        {
            object ojj = new object();
            //去掉首位 [ ] 符号
            str = str.Substring(1, str.Length - 2);
            int len = str.Length;
            int c = 0;//双引号索引
            List<object> lst = new List<object>();
            bool ists = false;//是否为特殊

            for (int i = 0; i < len; i++)
            {
                object tem = "";
                StringBuilder sb = new StringBuilder();
                bool isstr = false;
                while (i < len)
                {
                    if (str[i] == '[')//特殊处理
                    {
                        int idxs = 0;//记录 [ ] 出现的次数
                        StringBuilder tm = new StringBuilder();
                        while (i < len)
                        {
                            if (str[i] == '[')
                            {
                                idxs++;
                            }
                            if (str[i] == ']')
                            {
                                idxs--;
                            }
                            tm.Append(str[i]);
                            i++;
                            if (idxs == 0)//变成一个完整的组合
                            {
                                break;
                            }
                        }
                        lst.Add(arr(tm.ToString()));
                        ists = true;
                        i++;
                        continue;
                    }
                    else if (str[i] == '{')//特殊处理
                    {
                        int idxs = 0;//记录 [ ] 出现的次数
                        StringBuilder tm = new StringBuilder();
                        while (i < len)
                        {
                            if (str[i] == '{')
                            {
                                idxs++;
                            }
                            if (str[i] == '}')
                            {
                                idxs--;
                            }
                            tm.Append(str[i]);
                            i++;
                            if (idxs == 0)//变成一个完整的组合
                            {
                                break;
                            }
                        }
                        lst.Add(obj(tm.ToString()));
                        ists = true;
                        i++;
                        continue;
                    }
                    else
                    {
                        ists = false;
                        if (c == 0 && str[i] == '"')
                        {
                            i++;
                            c++;
                            continue;
                        }
                        if (str[i] == '"' && i + 1 < len && str[i + 1] == ',' || i + 1 == len)
                        {
                            i++;
                            c++;
                            break;
                        }
                        if (str[i] == '"' && i + 1 < len && str[i + 1] == ']' || i + 1 == len)
                        {
                            i++;
                            c++;
                            continue;
                        }
                        if (i + 1 < len && str[i + 1] == ']')
                        {
                            i++;
                            c++;
                            continue;
                        }
                        isstr = true;
                        sb.Append(str[i]);
                        i++;
                        c++;
                    }
                }
                if (!ists)
                {
                    if (isstr)
                    {
                        lst.Add(sb);// [ ] 的值存入List<string> 中
                        isstr = false;
                    }
                    else
                    {
                        lst.Add(tem);// [ ] 的值存入List<string> 中
                    }
                }
                c = 0;//归零
            }
            ojj = lst;
            return ojj;
        }
    }
}

2. 方法的调用和数据的使用

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.AnalyzeJSON;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Text.RegularExpressions;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        //按钮点击事件
        private void button1_Click(object sender, EventArgs e)
        {
            //
            //窗体中一个 TextBox 文本框[多行] 和 一个 Button 测试按钮
            //

            //
            //在网上随便找了一个json数据字符串的js
            //[在这里感谢'4399游戏资讯'平台提供的这些数据供测试,该js只供学习不可用作商业用途]
            //
            //该js是一个游戏类英雄相关属性的数据
            //js共4行, 每一行数据也非常大, 我们使用第一行进行测试,每一行使用回车键[
]分割
            //
            string src = "//newsimg.5054399.com/dtzzq/static/zrmnq/wap/js/data.js";
            StreamReader reader = new StreamReader(System.Net.WebRequest.Create("http:" + src).GetResponse().GetResponseStream());
            //Regex.Unescape("") 方法是将字符串含有 uxxxx 的16进制转化为我们识别的字符
            string[] zongstrs = Regex.Unescape(reader.ReadToEnd()).Split('
');

            //创建一个解析对象
            AnalyzeJSON aj = new AnalyzeJSON();

            //调用方法 AnalyzeString("JSON数据字符串") 进行解析 并返回 解析后的数据集合Dictionary<string, object>
            Dictionary<string, object> obj = aj.AnalyzeString(zongstrs[0]);

            //定义一个字符串进行拼接显示得到的数据
            StringBuilder sb = new StringBuilder();
            //调用拼接处理方法
            zx(obj, sb);

            //把得到的数据以字符串的形式展示出来
            textBox1.Text = sb.ToString();
        }

        //
        //数据遍历解析方法
        //根据需要可以为自己定义数据处理赋值方法,此处只作为显示使用
        //
        private void zx(Dictionary<string, object> obj, StringBuilder sb)
        {
            foreach (var item in obj)
            {
                if ((item.Value as Dictionary<string, object>) != null)
                {
                    zx((item.Value as Dictionary<string, object>), sb);
                }
                else
                {
                    if ((item.Value as List<object>) != null && (item.Value as List<object>).Count > 0)
                    {
                        List<object> lst = item.Value as List<object>;
                        sb.Append(item.Key + ":
");
                        for (int i = 0; i < lst.Count; i++)
                        {
                            if ((lst[i] as Dictionary<string, object>) != null)
                            {
                                zx((lst[i] as Dictionary<string, object>), sb);
                            }
                            else
                            {
                                sb.Append("	" + lst[i] + ",");
                            }

                        }
                        sb.Append("
");
                    }
                    else
                    {
                        sb.Append(item.Key + ":" + item.Value.ToString() + "
");
                    }
                }
            }
        }


    }
}

代码可能还有很多需要改进的地方, 希望各位大神指出来, 共同学习进步!^_^