c#对json串的处理方法

最新推荐文章于 2021-10-18 09:11:44 发布
最新推荐文章于 2021-10-18 09:11:44 发布
阅读量939 收藏
点赞数
分类专栏： windows phone 文章标签： c# json处理
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进程
 
  
伤花怒放-Xin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#将Json格式的数据进行转义操作
Enetaunt的博客
04-20 2万+
以下的方式是目前能想到的，若有更好的方式欢迎留言； 这里分别介绍两种类型转义 第一种格式： 转义结果为： {\"name\":\"BeJson\",\"url\":\"http://www.bejson.com\",\"page\":\"88\",\"isNonProfit\":\"true\"} 第二种含数组的格式： 转义结
C#实现对Json字符串处理
tide的博客
10-13 768
C#实现对Json字符串处理实例 这篇文章主要介绍了C#实现对Json字符串处理,通过一个json实例分析了C#进行JSON操作的方法,需要的朋友可以参考下 本文实例讲述了C#实现对Json字符串处理方法，分享给大家供大家参考。具体分析如下： 一般对于web应用开发人员来说对Json字符串都会很熟悉，其实在很多请求我们返回的都是Json字符串。那对于C#代码如何处理Json字
C# 产生JSON串
weixin_30407613的博客
11-17 177
由于JSON是现在前后台传输的标准，快速生产JSON串现在很是重要啊， 找了那么久，找到一个还算简单的。 ///<summary> ///查询省市区 /// </summary> public string SearchArea() { ...
JSONObject.fromObject方法报错解决方案
daokuishiw的专栏
09-30 1万+
今天使用JSON来开发微信，但是调用JSONObject.fromObject方法时，一直就报Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/lang/exception/NestableRuntimeException错误，开始不明所以，还以为自己代码有问题，于是新建了一个测试类，如下：
[C#]JSONObject解析json，C# asp.net JSON解析
热门推荐
天下武功唯CODING不破
01-25 3万+
前言：公司最近遇到问题，以往C#的接口通讯都是走xml的形式，因为现在的主流接口都采用json数据格式，但c#中并没有提供特别的方法帮助开发者，解析和生成都非常麻烦，我做为一个移动端开发者，于是想到了将java的解析方法移植到c#中去，漫长的移植工作开始了，经过一段时间的努力，再加上原本就有一些C#基础的我来说，改起来还是很轻松的，在java中的很多api在c#中都没有，于是乎，找类似方法进行替代
C#实现对Json字符串处理实例
09-04
这样，我们就成功地将JSON字符串处理成了易于操作的C#对象。 总的来说，C#通过`JavaScriptSerializer`提供了处理JSON的强大能力。除了`JavaScriptSerializer`，还有其他库如Newtonsoft.Json（Json.NET）更常用且...
C#格式化json字符串的方法分析
08-30
C#格式化json字符串的方法分析 在软件开发中，json字符串是非常常见的一种数据交换格式，然而在实际应用中，我们经常需要将json字符串格式化，以便于阅读和维护。C#作为一个强大的编程语言，提供了多种方法来格式化...
C#中Json的简单处理方法
09-01
在C#编程中，处理JSON数据是一项常见的任务，尤其是在与Web服务交互或数据传输时。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。C#提供了多种方式...
C#处理Json字符串实例分析
01-01
那对于C#代码如何处理Json字符串呢，.Net封装了一个类叫做JavaScriptSerializer[MSDN Library 链接http://msdn.microsoft.com/en-us/library/ee191864(v=vs.110).aspx]；这个类提供了一个方法。  下面这个是我在...
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 5408
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 6658
StringWriter sw = new StringWriter(); JsonWriter writer = new JsonTextWriter(sw); writer.WriteStartObject(); foreach (Control item in flpModule.Contro
[WinForm]dataGridView动态加载以本地图片显示列
德仔
10-30 7141
增加一个图片列： C# private void btnQuery_Click(object sender, EventArgs e) { StringBuilder sb=new StringBuilder (); sb.Append(" SELECT 序号, 品号,品名,客户品号,客户编码,客户名
关于JSONObject调用fromObject方法的出错问题
qq_46687516的博客
08-16 2484
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 1127
namespace ConsoleApplication1 { class ReflectionTest { public static string Tojson(object obj) { StringBuilder builder = new StringBuilder("{"); Type ...
TypeScript学习笔记
chenacxz的博客
11-24 486
TypeScriptTypeScript强类型与弱类型（类型安全）静态类型与动态类型（类型检查）Js自有的类型系统的问题Flow静态类型检查方案TS语言规范与基本应用 TypeScript TS是一门基于Javascript之上的编程语言，重点解决Javascript类型系统的问题。 大大提高代码的可靠程度。 强类型与弱类型（类型安全） 语言层面限制了实参类型必须与形参类型相同 class Main { static void foo(int num) { System.out.printIn(n
C#创建Json对象
Woodenflyers的博客
04-14 1万+
public string GetJsonData() { string a = "[[2010, 1000], [2012, 500], [2013, 900], [2015, 100], [2017, 3000],]"; string b = "[[2010, 1000], [2012, 500], [2013, 900], [2...
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、付费专栏及课程。

余额充值