c# 自定義解析JSON字符串數據

時間 2019-11-30

標籤 c# 自定義解析 json 字符串數據欄目 C# 简体版

原文原文鏈接

解析json字符串有不少方式, 1 : 在網上下載json解析的dll類庫並添加引用, 調用相關方法; 2 : 使用自帶類庫JavaScriptSerializer的序列號和反序列化; 對於以上兩個方法我沒有試用過, 應該很方便很簡潔性能很高吧!json

本身根據遍歷字符串找json字符串規律, 本身寫了一個類庫, 只有一個方法只提供解析, 沒有其餘方法. 缺點 : 可能比較死板, 可能性能也不及網上下載解析類庫. 數組

經測試和調試後能夠遍歷大部分json字符串數據, json字符串能夠嵌套, 但要符合json的規律, 數據中不能出現json字符串敏感關鍵字符 " 和 , 和 [ ] 和 { } ,數據中若是須要使用可使用中文字符代替.數據結構

數據返回結果存放在 Dictionary<string, object> 鍵值對中, 若是值爲字符串, 那麼object就爲字符串,爲了嵌套, 若是值爲數組, 那麼object就爲 List<object> , 若是值爲一個對象, 那麼object就存放在 Dictionary<string, object> 如此嵌套下去, 最終數據咱們根據本身的json數據結構遍歷Dictionary<string, object>集合便可. (注 : 每一個Dictionary中鍵必須惟一)ide

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;
        }
    }
}

AnalyzeJSON 類

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行, 每一行數據也很是大, 咱們使用第一行進行測試,每一行使用回車鍵[\n]分割
            //
            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('\n');

            //建立一個解析對象
            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 + ":\r\n");
                        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("\t" + lst[i] + ",");
                            }

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


    }
}