c#对json串的处理方法

最新推荐文章于 2024-11-23 16:23:36 发布
转载 最新推荐文章于 2024-11-23 16:23:36 发布 · 984 阅读 · 0
文章标签：

#c# #json处理

本文介绍了一种用于解析和序列化JSON数据的方法，通过对字符串进行特殊字符转义，并利用正则表达式来识别和处理JSON对象及数组，实现从字符串到JSON对象的有效转换。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
 
namespace tes
{
    public class JSONConvert
    {
        #region 全局变量
 
          private static JSONObject _json = new JSONObject ();//寄存器
          private static readonly string _SEMICOLON = "@semicolon" ;//分号转义符
          private static readonly string _COMMA = "@comma" ; //逗号转义符
 
          #endregion
 
          #region 字符串转义
          /// <summary>
          /// 字符串转义,将双引号内的:和,分别转成_SEMICOLON和_COMMA
          /// </summary>
          /// <param name="text"></param>
          /// <returns></returns>
          private static string StrEncode( string text)
          {
              MatchCollection matches = Regex .Matches(text, "\\\"[^\\\"]+\\\"");
              foreach (Match match in matches)
              {
                  text = text.Replace(match.Value, match.Value.Replace( ":", _SEMICOLON).Replace("," , _COMMA));
              }
 
              return text;
          }
 
          /// <summary>
          /// 字符串转义,将_SEMICOLON和_COMMA分别转成:和,
          /// </summary>
          /// <param name="text"></param>
          /// <returns></returns>
          private static string StrDecode( string text)
          {
              return text.Replace(_SEMICOLON, ":" ).Replace(_COMMA, ",");
          }
 
          #endregion
 
          #region JSON最小单元解析
 
          /// <summary>
          /// 最小对象转为JSONObject
          /// </summary>
          /// <param name="text"></param>
          /// <returns></returns>
          private static JSONObject DeserializeSingletonObject( string text)
          {
              JSONObject jsonObject = new JSONObject();
 
              MatchCollection matches = Regex .Matches(text, "(\\\"(?<key>[^\\\"]+)\\\":\\\"(?<value>[^,\\\"]+)\\\")|(\\\"(?<key>[^\\\"]+)\\\":(?<value>[^,\\\"\\}]+))" );
              foreach (Match match in matches)
              {
                  string value = match.Groups["value" ].Value;
                  jsonObject.Add(match.Groups[ "key"].Value, _json.ContainsKey(value) ? _json[value] : StrDecode(value));
              }
 
             return jsonObject;
          }
 
          /// <summary>
          /// 最小数组转为JSONArray
          /// </summary>
          /// <param name="text"></param>
          /// <returns></returns>
          private static JSONArray DeserializeSingletonArray( string text)
          {
              JSONArray jsonArray = new JSONArray();
 
              MatchCollection matches = Regex .Matches(text, "(\\\"(?<value>[^,\\\"]+)\")|(?<value>[^,\\[\\]]+)" );
              foreach (Match match in matches)
              {
                  string value = match.Groups["value" ].Value;
                  jsonArray.Add(_json.ContainsKey(value) ? _json[value] : StrDecode(value));
              }
 
              return jsonArray;
          }
 
          /// <summary>
         /// 反序列化
         /// </summary>
          /// <param name="text"></param>
          /// <returns></returns>
         private static string Deserialize( string text)
          {
 
              text = StrEncode(text); //转义;和,
 
              int count = 0;
              string key = string .Empty;
              string pattern = "(\\{[^\\[\\]\\{\\}]+\\})|(\\[[^\\[\\]\\{\\}]+\\])" ;
 
             while (Regex .IsMatch(text, pattern))
             {
 
                 MatchCollection matches = Regex .Matches(text, pattern);
                 foreach (Match match in matches)
                 {
                     key = "___key" + count + "___" ;
 
                    if (match.Value.Substring(0, 1) == "{" )
                         _json.Add(key, DeserializeSingletonObject(match.Value));
                     else
                         _json.Add(key, DeserializeSingletonArray(match.Value));
 
                     text = text.Replace(match.Value, key);
 
                     count++;
                 }
             }
             return text;
         }
 
         #endregion
 
         #region 公共接口
 
         /// <summary>
         /// 序列化JSONObject对象
         /// </summary>
         /// <param name="text"></param>
         /// <returns></returns>
         public static JSONObject DeserializeObject( string text)
         {
             _json = new JSONObject ();
             return _json[Deserialize(text)] as JSONObject;
         }
 
         /// <summary>
         /// 序列化JSONArray对象
         /// </summary>
         /// <param name="text"></param>
         /// <returns></returns>
         public static JSONArray DeserializeArray( string text)
         {
             _json = new JSONObject ();
             return _json[Deserialize(text)] as JSONArray;
         }
 
         /// <summary>
         /// 反序列化JSONObject对象
         /// </summary>
         /// <param name="jsonObject"></param>
         /// <returns></returns>
         public static string SerializeObject( JSONObject jsonObject)
         {
             StringBuilder sb = new StringBuilder();
             sb.Append( "{");
             foreach (KeyValuePair <string, object> kvp in jsonObject)
             {
                 if (kvp.Value is JSONObject)
                 {
                     sb.Append( string.Format("\"{0}\":{1}," , kvp.Key, SerializeObject((JSONObject)kvp.Value)));
                 }
                 else if (kvp.Value is JSONArray)
                 {
                    sb.Append( string.Format("\"{0}\":{1}," , kvp.Key, SerializeArray((JSONArray)kvp.Value)));
                 }
                 else if (kvp.Value is String)
                 {
                     sb.Append( string.Format("\"{0}\":\"{1}\"," , kvp.Key, kvp.Value));
                 }
                 else
                 {
                     sb.Append( string.Format("\"{0}\":\"{1}\"," , kvp.Key, ""));
                 }
             }
             if (sb.Length > 1)
                 sb.Remove(sb.Length - 1, 1);
             sb.Append( "}");
             return sb.ToString();
         }
 
         /// <summary>
         /// 反序列化JSONArray对象
         /// </summary>
         /// <param name="jsonArray"></param>
         /// <returns></returns>
         public static string SerializeArray( JSONArray jsonArray)
         {
             StringBuilder sb = new StringBuilder();
             sb.Append( "[");
             for (int i = 0; i < jsonArray.Count; i++)
             {
                 if (jsonArray[i] is JSONObject)
                 {
                     sb.Append( string.Format("{0}," , SerializeObject((JSONObject)jsonArray[i])));
                 }
                 else if (jsonArray[i] is JSONArray)
                 {
                     sb.Append( string.Format("{0}," , SerializeArray((JSONArray)jsonArray[i])));
                 }
                 else if (jsonArray[i] is String)
                 {
                     sb.Append( string.Format("\"{0}\"," , jsonArray[i]));
                 }
                 else
                 {
                     sb.Append( string.Format("\"{0}\"," , ""));
                 }
 
             }
             if (sb.Length > 1)
                 sb.Remove(sb.Length - 1, 1);
             sb.Append( "]");
             return sb.ToString();
         }
         #endregion
     }
 
     /// <summary>
     /// 取出JSON对象类
     /// </summary>
     public class JSONObject : Dictionary<string , object>
     {
         public new void Add( string key, object value)
         {
             System. Type t = value.GetType();
 
             if (t.Name == "String" )
             {
                 value = JSONEncode.StrEncodeForDeserialize(value.ToString());
             }
 
             base.Add(key, value);
         }
         public override string ToString()
         {
             return JSONConvert .SerializeObject(this);
         }
         public static JSONObject FromObject( string json)
         {
             return JSONConvert .DeserializeObject(json);
         }
     }
 
     /// <summary>
     /// 取出JSON数组类
     /// </summary>
     public class JSONArray : List<object >
     {
         public new void Add( object item)
         {
             System. Type t = item.GetType();
 
             if (t.Name == "String" )
             {
                 item = JSONEncode.StrEncodeForDeserialize(item.ToString());
             }
 
             base.Add(item);
         }
         public override string ToString()
         {
             return JSONConvert .SerializeArray(this);
         }
         public JSONArray FromObject(string json)
         {
             return JSONConvert .DeserializeArray(json);
         }
     }
 
    /// <summary>
     /// 字符串转义,将"{"、"}"、"""
     /// </summary>
     public class JSONEncode
     {
         public static readonly string _LEFTBRACES = "@leftbraces" ;//"{"转义符
         public static readonly string _RIGHTBRACES = "@rightbraces" ;//"}"转义符
         public static readonly string _LEFTBRACKETS = "@leftbrackets" ;//"["转义符
         public static readonly string _RIGHTBRACKETS = "@rightbrackets" ;//"]"转义符
         public static readonly string _DOUBLEQUOTATIONMARKS = "@doubleQuotationMarks" ;//"""转义符
 
 
         #region 字符串转义
         /// <summary>
         /// 字符串转义,将"{"、"}"、""",分别转换_LEFTBRACES、_RIGHTBRACES、_DOUBLEQUOTATIONMARKS
         /// </summary>
         /// <param name="text"></param>
         /// <returns></returns>
         public static string StrEncodeForDeserialize( string text)
         {
             return text
             .Replace( "{", _LEFTBRACES)
             .Replace( "}", _RIGHTBRACES)
             .Replace( "[", _LEFTBRACKETS)
             .Replace( "]", _RIGHTBRACKETS)
             .Replace( "\"", _DOUBLEQUOTATIONMARKS);
         }
 
         /// <summary>
         /// 字符串转义,将_LEFTBRACES、_RIGHTBRACES、_DOUBLEQUOTATIONMARKS,分别转换"{"、"}"、"""
         /// </summary>
         /// <param name="text"></param>
         /// <returns></returns>
         public static string StrDecodeForDeserialize( string text)
         {
             return text.Replace(_LEFTBRACES, "{" )
             .Replace(_RIGHTBRACES, "}")
             .Replace(_LEFTBRACKETS, "[")
             .Replace(_RIGHTBRACKETS, "]")
             .Replace(_DOUBLEQUOTATIONMARKS, "\"");
         }
         #endregion
    }
}
 
 
 
 
------------------------------------------------------------------------
读取之后调用相关方法处理
 
string contents = reader.ReadToEnd();
            string str1 = contents;
            str1 = str1.Replace( " ", "" );
            str1 = str1.Replace( "[]", "[ ]" );
            str1 = str1.Replace( "\"\"", "\" \"" );
 
 
JSONObject json = JSONConvert .DeserializeObject(str1);
            string str2 = ((JSONArray )json["jokes"])[0].ToString();
            JSONObject json1 = JSONConvert .DeserializeObject(str2);
            string str3 = json1["content" ].ToString();
            string str4 = unicodetogb(str3); 
            Dispatcher.BeginInvoke(() => { textBox1.Text = str4; }); //特别注意需要通过Dispatcher去更新UI进程
 
  
C#实现对Json字符串处理
tide的博客
10-13 816
C#实现对Json字符串处理实例 这篇文章主要介绍了C#实现对Json字符串处理,通过一个json实例分析了C#进行JSON操作的方法,需要的朋友可以参考下 本文实例讲述了C#实现对Json字符串处理方法，分享给大家供大家参考。具体分析如下： 一般对于web应用开发人员来说对Json字符串都会很熟悉，其实在很多请求我们返回的都是Json字符串。那对于C#代码如何处理Json字
C# 产生JSON串
weixin_30407613的博客
11-17 213
由于JSON是现在前后台传输的标准，快速生产JSON串现在很是重要啊， 找了那么久，找到一个还算简单的。 ///<summary> ///查询省市区 /// </summary> public string SearchArea() { ...
C# Json字符串生成工具的实现与应用
最新发布
weixin_33431149的博客
11-23 921
本文还有配套的精品资源，点击获取 简介：JSON是一种轻量级的数据交换格式，被广泛用于Web服务中，用以替代XML，因其简洁易处理特性。本课程主要介绍如何在C#中使用Json.NET库生成JSON字符串，并提供源码分析，帮助开发者理解并根据需求定制自己的Json字符串生成工具。课程将涵盖数据类型、库的使用、源码解析、工具定制、效率提升、扩展性以及如何将工具集成到项目中，从而...
C# 生成与解析Json字符串
awangdea99的博客
06-15 4445
前言：由于近期在与ERP对接接口中，需要使用Json传递数据，故在网上查询和自己做了实例测试，得出以下生成与解析Json字符串的总结： 一 . 原始方式：按照JSON字符串格式自己来生成与解析。 二 . 通用方式：使用开源的类库 Newtonsoft.Json（使用该方法首先需在“管理NuGet程序包“中下载：“Newtonsoft.Json”：程序包） 1>实现对象的序列化和反序列化 ...
JSONObject.fromObject方法报错解决方案
daokuishiw的专栏
09-30 1万+
今天使用JSON来开发微信，但是调用JSONObject.fromObject方法时，一直就报Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/lang/exception/NestableRuntimeException错误，开始不明所以，还以为自己代码有问题，于是新建了一个测试类，如下：
C#实现对Json字符串处理实例
09-04
这样，我们就成功地将JSON字符串处理成了易于操作的C#对象。 总的来说，C#通过`JavaScriptSerializer`提供了处理JSON的强大能力。除了`JavaScriptSerializer`，还有其他库如Newtonsoft.Json（Json.NET）更常用且...
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-31
本文将详细讲解如何使用C#实现JSON字符串的序列化和反序列化。 首先，我们要了解序列化和反序列化的概念。**序列化**是将对象转换为可存储或可传输的格式，例如JSON字符串；**反序列化**则是将这种格式的数据恢复为...
C# json格式解析，Json格式字符串与C#对象相互转换，类库+使用案例，注释详细
06-21
C# json格式转换，Json格式字符串与C#对象相互转换，类库和测试demo 写了一个json与C#对象相互装换的类库，直接调用就行，有测试案例，代码注释非常详细 部分方法： /// 将Json字符串解析为C#中的对象 /// Json格式...
C#中Json的简单处理方法
09-01
在C#编程中，处理JSON数据是一项常见的任务，尤其是在与Web服务交互或数据传输时。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。C#提供了多种方式...
[C#]JSONObject解析json，C# asp.net JSON解析
热门推荐
天下武功唯CODING不破
01-25 3万+
前言：公司最近遇到问题，以往C#的接口通讯都是走xml的形式，因为现在的主流接口都采用json数据格式，但c#中并没有提供特别的方法帮助开发者，解析和生成都非常麻烦，我做为一个移动端开发者，于是想到了将java的解析方法移植到c#中去，漫长的移植工作开始了，经过一段时间的努力，再加上原本就有一些C#基础的我来说，改起来还是很轻松的，在java中的很多api在c#中都没有，于是乎，找类似方法进行替代
C# 操作JSON的几种方式
qq_27410185的博客
10-18 2万+
关于Json数据在开发中的重要性，自然不言而喻； 本篇通过两种在c#中常用的方式来实现对Json数据的序列化和反序列化，为了实现大多数的需求，我们采用稍微复杂一点的数据模型。 首先我们有以下json数据 { "name": "张三", "age": 20, "idCard": "123456789", "birthday": "2021-01-01 00:00:00", "hobbys": [ { "sort": 1, "desc": "写
C#处理Json字符串、Json对象、多层嵌套
书写人生
11-28 5551
public partial class WebForm2 : System.Web.UI.Page     {         protected void Page_Load(object sender, EventArgs e)         {         }           public Models.Users[] obj { get; set; }         prot...
C# 生成Json数据
小小的花园里面挖呀挖呀～
07-01 6784
StringWriter sw = new StringWriter(); JsonWriter writer = new JsonTextWriter(sw); writer.WriteStartObject(); foreach (Control item in flpModule.Contro
[WinForm]dataGridView动态加载以本地图片显示列
德仔
10-30 7290
增加一个图片列： C# private void btnQuery_Click(object sender, EventArgs e) { StringBuilder sb=new StringBuilder (); sb.Append(" SELECT 序号, 品号,品名,客户品号,客户编码,客户名
关于JSONObject调用fromObject方法的出错问题
qq_46687516的博客
08-16 2683
JSON与对象的数据转换 JSON是一种轻量级的数据交换格式；用于存储和交换文本信息。 1.JSONObject介绍 JSONObject-lib包是一个beans,collections,maps,java arrays和xml和JSON互相转换的包。 当使用这个JSONObject转对象的时候，会遇到这么一个报错。 为什么报错呢？ 因为Maven的依赖包没有引入完整。缺少json的依赖包 例如必备需要的六个 commons-beanutils.jar，ccommons-collectio
C# 反射技术实现：对象转json，json转对象
meng_xiaoxiao的博客
07-12 1240
namespace ConsoleApplication1 { class ReflectionTest { public static string Tojson(object obj) { StringBuilder builder = new StringBuilder("{"); Type ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值