C#Json字符串处理

最新推荐文章于 2024-08-29 09:14:39 发布
最新推荐文章于 2024-08-29 09:14:39 发布
阅读量379 收藏
点赞数
分类专栏： C# 文章标签： c# json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1376871144/article/details/108845656
版权

using direction.framework.common;
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace direction.framework.util {
    /// <summary>
    /// 分隔Json字符串为字典集合。
    /// </summary>
    internal partial class JsonSplit {
        internal static bool IsJson(string json) {
            return IsJson(json, out _);
        }
        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.E(err.Message);
                } 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;
        }
    }
}

a1376871144
关注
专栏目录
C# Json
zxcvb036的博客
12-02 154
Json Api的参考 https://www.newtonsoft.com/json using System; using System.Xml; using System.Xml.Serialization; using System.IO; using Newtonsoft.Json; using Newtonsoft.Json.Converters; public class Test { public static void Main() { Product p
c#解析json字符串数组_C#解析JSON字符串总结
weixin_39800112的博客
12-21 409
JSON文件读取到内存中就是字符串，.NET操作JSON就是生成与解析JSON字符串。操作JSON通常有以下几种方式：1. 原始方式：按照JSON字符串自己来解析。2. 通用方式【★★★★★】：这种方式是使用开源的类库Newtonsoft.Json(下载地址http://json.codeplex.com/)。下载后添加dll引用就能用。首先添加引用：using Newtonsoft.Json;新...
【c#】JSON操作
最新发布
weixin_44122117的博客
08-29 379
c#中的JSON操作
c#解析json字符串数组_c#解析json字符串处理（最清晰易懂的方法）
weixin_39653320的博客
12-21 605
{"companyID": "15","employees": [{"firstName": "Bill","lastName": "Gates"},{"firstName": "George","lastName": "Bush"}],"manager": [{"salary": "6000","age": "23"},{"salary": "8000","age": "26"}]}请利用C#处...
C#JSON
weixin_43152495的博客
11-12 2718
JSON 序列化发序列化 JSON字符串读取
C# JSON
江川的博客
09-19 255
最近需要使用字符串传递复杂对象，根据需要简单地查了C#中json的使用例子，并自己实测了下： 管理NuGet程序包 添加后引用，命名空间 使用Dictionary作为object，测试 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System...
C#处理Json字符串实例分析
01-01
那对于C#代码如何处理Json字符串呢，.Net封装了一个类叫做JavaScriptSerializer[MSDN Library 链接http://msdn.microsoft.com/en-us/library/ee191864(v=vs.110).aspx]；这个类提供了一个方法。  下面这个是我在...
C#格式化json字符串的方法分析
08-30
C#格式化json字符串的方法分析 在软件开发中，json字符串是非常常见的一种数据交换格式，然而在实际应用中，我们经常需要将json字符串格式化，以便于阅读和维护。C#作为一个强大的编程语言，提供了多种方法来格式化...
C# json格式解析，Json格式字符串与C#对象相互转换，类库+使用案例，注释详细
06-21
/// 将Json字符串解析为C#中的对象 /// Json格式中的字符串值识别 /// 将Json字符串解析为Dictionary, dynamic>对象。 /// 将Json字符串解析为dynamic[]对象。 /// Dictionary类型对象转换为Json格式字符串 /// C#...
C#解析json字符串总是多出双引号的原因分析及解决办法
09-02
在使用Newtonsoft.Json库的`JsonConvert.DeserializeObject`方法反序列化JSON字符串时，如果字符串字段的值已经被正确处理，那么在访问这些字段时，例如`jo["name"].ToString()`，得到的结果应该是不带外层双引号的...
C#实现JSON字符串序列化与反序列化的方法
08-31
本文将详细讲解如何使用C#实现JSON字符串的序列化和反序列化。 首先，我们要了解序列化和反序列化的概念。**序列化**是将对象转换为可存储或可传输的格式，例如JSON字符串；**反序列化**则是将这种格式的数据恢复为...
C#json操作
01-26
#region 将DataTable数据转换成JSON数据（用户绑定datagrid） 作者：许玉堂 /// <summary> /// 将datatable数据转换成JSON数据 /// </summary> /// <param name="dt">数据集</param> /// <param name="displayCount">是否显示计数</param> /// <param name="totalcount">总计数</param> /// <returns></returns> public static string DataTableToJson(System.Data.DataTable dt, bool displayCount, int totalcount) { StringBuilder Json = new StringBuilder(); Json.Append("{"); Json.Append("\"rows\":"); Json.Append("["); if (dt.Rows.Count > 0) { for (int i = 0; i < dt.Rows.Count; i++) { Json.Append("{"); for (int j = 0; j < dt.Columns.Count; j++) { string value = dt.Rows[i][j] != null ? dt.Rows[i][j].ToString() : ""; value = HK.Common.Utils.DropHTML(value); Json.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":\"" + value + "\""); if (j < dt.Columns.Count - 1) { Json.Append(","); } } Json.Append("}"); if (i < dt.Rows.Count - 1) { Json.Append(","); } } } Json.Append("]"); if (displayCount) { Json.Append(","); Json.Append("\"total\":"); Json.Append(totalcount); } Json.Append("}"); return Json.ToString().Replace("\n", "").Replace("\r", ""); } #endregion
c# json
delphi-x2d
03-21 209
[DataContract]   public struct Student    {        [DataMember]       public int ID { get; set; }        [DataMember]       public string Name { get; set; }        [DataMember]       public int Age { ...
c#_Json
qq_48705696的博客
05-08 307
一、Json的自我介绍 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。可读性和XML的可读性可谓不相上下，也有着XML无法比拟的可扩展性。 1、格式：{}为对象、[]为数组 1、对象是一个无序的“‘名称/值’对”集合。 例子：表示人的一个对象： {"姓名" : "大憨","年龄" : 24} 2、数组是值（value）的有序集合。 例子：一组学生 {"学生" :[{"姓名" : "小...
c#解析json字符串数组_C# 解析json数组
weixin_39980347的博客
12-21 638
案例一：string json = "[{"Groupid":"54","groupnum":"66000","groupname":"大唐移动","type":"0","dnsprefix":"","islocal":"1","canshowall":"-1","user":[{"userid":"66001","username":"66001","type":"6","dnsprefix":...
在C＃中使用JSON
寒冰屋的专栏
04-06 5932
目录 介绍 背景 获取新的JSON库 兴趣点 编写和读取JSON文件 通过JsonSerializerOptions进行序列化设置 使用属性自定义序列化 在本文中，我向您展示JSON的基本操作。这是学习C＃的关键主题之一。 介绍 如今，JSON已成为代表复杂结构和数据交换的主要格式之一。因此，所有主要的编程语言都具有使用它的内置支持。C＃也不例外。在本文中，我想向您介绍一种在C＃/.NET中使用JSON文件的简单方法。我想向您展示这种格式的简单示例。 背景 至少有两种主要方法将.NE
C# json 字符串 处理
07-27
你可以使用 C# 中的 Newtonsoft.Json 库来处理 JSON 字符串。下面是一些常见的操作示例： 1. 将 JSON 字符串转换为对象： ```csharp string jsonString = "{\"name\":\"John\",\"age\":30}"; var obj = JsonConvert...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值