c#判斷字符串是否json

來源：https://www.cnblogs.com/cyq1162/p/3841766.html

下載地址：

　　https://github.com/cyq1162/cyqdata/blob/master/Tool/JsonSplit.cs

　　https://github.com/cyq1162/cyqdata

 

　　

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace CYQ.Data.Tool
{
    /// <summary>
    /// 分隔Json字符串為字典集合。
    /// </summary>
    internal partial class JsonSplit
    {
        internal static bool IsJson(string json)
        {
            int errIndex;
            return IsJson(json, out errIndex);
        }
        internal static bool IsJson(string json, out int errIndex)
        {
            errIndex = 0;

            if (string.IsNullOrEmpty(json) || json.Length < 2 ||
                ((json[0] != '{' && json[json.Length - 1] != '}') && (json[0] != '[' && json[json.Length - 1] != ']')))
            {
                return false;
            }
            CharState cs = new CharState();
            char c;
            for (int i = 0; i < json.Length; i++)
            {
                c = json[i];
                if (SetCharState(c, ref cs) && cs.childrenStart)//設置關鍵符號狀態。
                {
                    string item = json.Substring(i);
                    int err;
                    int length = GetValueLength(item, true, out err);
                    cs.childrenStart = false;
                    if (err > 0)
                    {
                        errIndex = i + err;
                        return false;
                    }
                    i = i + length - 1;
                }
                if (cs.isError)
                {
                    errIndex = i;
                    return false;
                }
            }

            return !cs.arrayStart && !cs.jsonStart; //只要不是正常關閉，則失敗
        }

        /// <summary>
        /// 解析Json
        /// </summary>
        /// <param name="json"></param>
        /// <param name="op">除了NO，其它項都會消掉轉義符，默認是：YES</param>
        /// <returns></returns>
        internal static List<Dictionary<string, string>> Split(string json)
        {
            List<Dictionary<string, string>> result = new List<Dictionary<string, string>>();

            if (!string.IsNullOrEmpty(json))
            {
                Dictionary<string, string> dic = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                string key = string.Empty;
                StringBuilder value = new StringBuilder();
                CharState cs = new CharState();
                try
                {
                    #region 核心邏輯
                    char c;
                    for (int i = 0; i < json.Length; i++)
                    {
                        c = json[i];
                        if (!SetCharState(c, ref cs))//設置關鍵符號狀態。
                        {
                            if (cs.jsonStart)//Json進行中。。。
                            {
                                if (cs.keyStart > 0)
                                {
                                    key += c;
                                }
                                else if (cs.valueStart > 0)
                                {
                                    value.Append(c);
                                    //value += c;
                                }
                            }
                            else if (!cs.arrayStart)//json結束，又不是數組，則退出。
                            {
                                break;
                            }
                        }
                        else if (cs.childrenStart)//正常字符，值狀態下。
                        {
                            string item = json.Substring(i);
                            int temp;
                            int length = GetValueLength(item, false, out temp);
                            //value = item.Substring(0, length);
                            value.Length = 0;
                            value.Append(item.Substring(0, length));
                            cs.childrenStart = false;
                            cs.valueStart = 0;
                            //cs.state = 0;
                            cs.setDicValue = true;
                            i = i + length - 1;
                        }
                        if (cs.setDicValue)//設置鍵值對。
                        {
                            if (!string.IsNullOrEmpty(key) && !dic.ContainsKey(key))
                            {
                                //if (value != string.Empty)
                                //{
                                string val = value.ToString();
                                bool isNull = json[i - 5] == ':' && json[i] != '"' && value.Length == 4 && val == "null";
                                if (isNull)
                                {
                                    val = "";
                                }

                                dic.Add(key, val);

                                //}
                            }
                            cs.setDicValue = false;
                            key = string.Empty;
                            value.Length = 0;
                        }

                        if (!cs.jsonStart && dic.Count > 0)
                        {
                            result.Add(dic);
                            if (cs.arrayStart)//處理數組。
                            {
                                dic = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                            }
                        }
                    }
                    #endregion
                }
                catch (Exception err)
                {
                    Log.Write(err, LogType.Error);
                }
                finally
                {
                    key = null;
                    value.Length = 0;
                    value.Capacity = 16;
                    value = null;
                }
            }
            return result;
        }
        /// <summary>
        /// 獲取值的長度（當Json值嵌套以"{"或"["開頭時）
        /// </summary>
        private static int GetValueLength(string json, bool breakOnErr, out int errIndex)
        {
            errIndex = 0;
            int len = json.Length - 1;
            if (!string.IsNullOrEmpty(json))
            {
                CharState cs = new CharState();
                char c;
                for (int i = 0; i < json.Length; i++)
                {
                    c = json[i];
                    if (!SetCharState(c, ref cs))//設置關鍵符號狀態。
                    {
                        if (!cs.jsonStart && !cs.arrayStart)//json結束，又不是數組，則退出。
                        {
                            break;
                        }
                    }
                    else if (cs.childrenStart)//正常字符，值狀態下。
                    {
                        int length = GetValueLength(json.Substring(i), breakOnErr, out errIndex);//遞歸子值，返回一個長度。。。
                        cs.childrenStart = false;
                        cs.valueStart = 0;
                        //cs.state = 0;
                        i = i + length - 1;
                    }
                    if (breakOnErr && cs.isError)
                    {
                        errIndex = i;
                        return i;
                    }
                    if (!cs.jsonStart && !cs.arrayStart)//記錄當前結束位置。
                    {
                        len = i + 1;//長度比索引+1
                        break;
                    }
                }
            }
            return len;
        }
        /// <summary>
        /// 字符狀態
        /// </summary>
        private class CharState
        {
            internal bool jsonStart = false;//以 "{"開始了...
            internal bool setDicValue = false;// 可以設置字典值了。
            internal bool escapeChar = false;//以"\"轉義符號開始了
            /// <summary>
            /// 數組開始【僅第一開頭才算】，值嵌套的以【childrenStart】來標識。
            /// </summary>
            internal bool arrayStart = false;//以"[" 符號開始了
            internal bool childrenStart = false;//子級嵌套開始了。
            /// <summary>
            /// 【-1 未初始化】【0 取名稱中】；【1 取值中】
            /// </summary>
            internal int state = -1;

            /// <summary>
            /// 【-2 已結束】【-1 未初始化】【0 未開始】【1 無引號開始】【2 單引號開始】【3 雙引號開始】
            /// </summary>
            internal int keyStart = -1;
            /// <summary>
            /// 【-2 已結束】【-1 未初始化】【0 未開始】【1 無引號開始】【2 單引號開始】【3 雙引號開始】
            /// </summary>
            internal int valueStart = -1;

            internal bool isError = false;//是否語法錯誤。

            internal void CheckIsError(char c)//只當成一級處理（因為GetLength會遞歸到每一個子項處理）
            {
                switch (c)
                {
                    case '{'://[{ "[{A}]":[{"[{B}]":3,"m":"C"}]}]
                        isError = jsonStart && state == 0;//重復開始錯誤 同時不是值處理。
                        break;
                    case '}':
                        isError = !jsonStart || (keyStart > 0 && state == 0);//重復結束錯誤 或者 提前結束。
                        break;
                    case '[':
                        isError = arrayStart && state == 0;//重復開始錯誤
                        break;
                    case ']':
                        isError = !arrayStart || (state == 1 && valueStart == 0);//重復開始錯誤[{},]1,0  正常：[111,222] 1,1 [111,"22"] 1,-2 
                        break;
                    case '"':
                        isError = !jsonStart && !arrayStart;//未開始Json，同時也未開始數組。
                        break;
                    case '\'':
                        isError = !jsonStart && !arrayStart;//未開始Json
                        break;
                    case ':':
                        isError = (!jsonStart && !arrayStart) || (jsonStart && keyStart < 2 && valueStart < 2 && state == 1);//未開始Json 同時 只能處理在取值之前。
                        break;
                    case ',':
                        isError = (!jsonStart && !arrayStart)
                            || (!jsonStart && arrayStart && state == -1) //[,111]
                            || (jsonStart && keyStart < 2 && valueStart < 2 && state == 0);//未開始Json 同時 只能處理在取值之后。
                        break;
                    default: //值開頭。。
                        isError = (!jsonStart && !arrayStart) || (keyStart == 0 && valueStart == 0 && state == 0);//
                        if (!isError && keyStart < 2)
                        {
                            if ((jsonStart && !arrayStart) && state != 1)
                            {
                                //不是引號開頭的，只允許字母 {aaa:1}
                                isError = c < 65 || (c > 90 && c < 97) || c > 122;
                            }
                            else if (!jsonStart && arrayStart && valueStart < 2)//
                            {
                                //不是引號開頭的，只允許數字[1]
                                isError = c < 48 || c > 57;

                            }
                        }
                        break;
                }
                //if (isError)
                //{

                //}
            }
        }
        /// <summary>
        /// 設置字符狀態(返回true則為關鍵詞，返回false則當為普通字符處理）
        /// </summary>
        private static bool SetCharState(char c, ref CharState cs)
        {
            switch (c)
            {
                case '{'://[{ "[{A}]":[{"[{B}]":3,"m":"C"}]}]
                    #region 大括號
                    if (cs.keyStart <= 0 && cs.valueStart <= 0)
                    {
                        cs.CheckIsError(c);
                        if (cs.jsonStart && cs.state == 1)
                        {
                            cs.valueStart = 0;
                            cs.childrenStart = true;
                        }
                        else
                        {
                            cs.state = 0;
                        }
                        cs.jsonStart = true;//開始。
                        return true;
                    }
                    #endregion
                    break;
                case '}':
                    #region 大括號結束
                    if (cs.keyStart <= 0 && cs.valueStart < 2)
                    {
                        cs.CheckIsError(c);
                        if (cs.jsonStart)
                        {
                            cs.jsonStart = false;//正常結束。
                            cs.valueStart = -1;
                            cs.state = 0;
                            cs.setDicValue = true;
                        }
                        return true;
                    }
                    // cs.isError = !cs.jsonStart && cs.state == 0;
                    #endregion
                    break;
                case '[':
                    #region 中括號開始
                    if (!cs.jsonStart)
                    {
                        cs.CheckIsError(c);
                        cs.arrayStart = true;
                        return true;
                    }
                    else if (cs.jsonStart && cs.state == 1 && cs.valueStart < 2)
                    {
                        cs.CheckIsError(c);
                        //cs.valueStart = 1;
                        cs.childrenStart = true;
                        return true;
                    }
                    #endregion
                    break;
                case ']':
                    #region 中括號結束
                    if (!cs.jsonStart && (cs.keyStart <= 0 && cs.valueStart <= 0) || (cs.keyStart == -1 && cs.valueStart == 1))
                    {
                        cs.CheckIsError(c);
                        if (cs.arrayStart)// && !cs.childrenStart
                        {
                            cs.arrayStart = false;
                        }
                        return true;
                    }
                    #endregion
                    break;
                case '"':
                case '\'':
                    cs.CheckIsError(c);
                    #region 引號
                    if (cs.jsonStart || cs.arrayStart)
                    {
                        if (!cs.jsonStart && cs.arrayStart)
                        {
                            cs.state = 1;//如果是數組，只有取值，沒有Key，所以直接跳過0
                        }
                        if (cs.state == 0)//key階段
                        {
                            cs.keyStart = (cs.keyStart <= 0 ? (c == '"' ? 3 : 2) : -2);
                            return true;
                        }
                        else if (cs.state == 1)//值階段
                        {
                            if (cs.valueStart <= 0)
                            {
                                cs.valueStart = (c == '"' ? 3 : 2);
                                return true;
                            }
                            else if ((cs.valueStart == 2 && c == '\'') || (cs.valueStart == 3 && c == '"'))
                            {
                                if (!cs.escapeChar)
                                {
                                    cs.valueStart = -2;
                                    return true;
                                }
                                else
                                {
                                    cs.escapeChar = false;
                                }
                            }

                        }
                    }
                    #endregion
                    break;
                case ':':
                    cs.CheckIsError(c);
                    #region 冒號
                    if (cs.jsonStart && cs.keyStart < 2 && cs.valueStart < 2 && cs.state == 0)
                    {
                        cs.keyStart = 0;
                        cs.state = 1;
                        return true;
                    }
                    #endregion
                    break;
                case ',':
                    cs.CheckIsError(c);
                    #region 逗號 {"a": [11,"22", ], "Type": 2}
                    if (cs.jsonStart && cs.keyStart < 2 && cs.valueStart < 2 && cs.state == 1)
                    {
                        cs.state = 0;
                        cs.valueStart = 0;
                        cs.setDicValue = true;
                        return true;
                    }
                    else if (cs.arrayStart && !cs.jsonStart) //[a,b]  [",",33] [{},{}]
                    {
                        if ((cs.state == -1 && cs.valueStart == -1) || (cs.valueStart < 2 && cs.state == 1))
                        {
                            cs.valueStart = 0;
                            return true;
                        }
                    }
                    #endregion
                    break;
                case ' ':
                case '\r':
                case '\n':
                case '\t':
                    if (cs.jsonStart && cs.keyStart <= 0 && cs.valueStart <= 0)
                    {
                        return true;//跳過空格。
                    }
                    break;
                default: //值開頭。。
                    cs.CheckIsError(c);
                    if (c == '\\') //轉義符號
                    {
                        if (cs.escapeChar)
                        {
                            cs.escapeChar = false;
                        }
                        else
                        {
                            cs.escapeChar = true;
                            //return true;
                        }
                    }
                    else
                    {
                        cs.escapeChar = false;
                    }
                    if (cs.jsonStart)
                    {
                        if (cs.keyStart <= 0 && cs.state <= 0)
                        {
                            cs.keyStart = 1;//無引號的
                        }
                        else if (cs.valueStart <= 0 && cs.state == 1)
                        {
                            cs.valueStart = 1;//無引號的
                        }
                    }
                    else if (cs.arrayStart)
                    {
                        cs.state = 1;
                        if (cs.valueStart < 1)
                        {
                            cs.valueStart = 1;//無引號的
                        }
                    }
                    break;
            }
            return false;
        }


    }
    internal partial class JsonSplit
    {
        /// <summary>
        /// 將json數組分成字符串List
        /// </summary>
        /// <param name="jsonArray">["a,","bbb,,"]</param>
        /// <returns></returns>
        internal static List<string> SplitEscapeArray(string jsonArray)
        {
            if (!string.IsNullOrEmpty(jsonArray))
            {
                jsonArray = jsonArray.Trim(' ', '[', ']');//["a,","bbb,,"]
                List<string> list = new List<string>();
                if (jsonArray.Length > 0)
                {
                    string[] items = jsonArray.Split(',');
                    string objStr = string.Empty;
                    foreach (string item in items)
                    {
                        if (objStr == string.Empty) { objStr = item; }
                        else { objStr += "," + item; }
                        char firstChar = objStr[0];
                        if (firstChar == '"' || firstChar == '\'')
                        {
                            //檢測雙引號的數量
                            if (GetCharCount(objStr, firstChar) % 2 == 0)//引號成雙
                            {
                                list.Add(objStr.Trim(firstChar).Replace("\\" + firstChar, firstChar.ToString()));
                                objStr = string.Empty;
                            }
                        }
                        else
                        {
                            list.Add(item);
                            objStr = string.Empty;
                        }
                    }
                }
                return list;

            }
            return null;
        }
        /// <summary>
        /// 獲取字符在字符串出現的次數
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        private static int GetCharCount(string item, char c)
        {
            int num = 0;
            for (int i = 0; i < item.Length; i++)
            {
                if (item[i] == '\\')
                {
                    i++;
                }
                else if (item[i] == c)
                {
                    num++;
                }
            }
            return num;
        }
    }
}