经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » JS/JS库/框架 » JSON » 查看文章
使用JsonTextReader提高Json.NET反序列化的性能
来源：cnblogs　　作者：无风听海　　时间：2023/2/24 9:07:38　　对本文有异议

一、碰到的问题
在服务器的文件系统上有一个业务生成的BigTable.json文件，其可能包含的JSON字符串很大，同时里边的集合会包含很多的记录；我们使用以下的代码来反序列化，虽然使用了异步的ReadAllTextAsync来读取文件，但是还是需要将整个的文件内容都读取到内存中，这样会极大的占用服务器内存，同时分配太多对象或分配非常大的对象会导致垃圾收集减慢甚至停止应用程序；

  1. string jsonStr = File.ReadAllTextAsync("json.txt").Result;
  2. BigTable table = JsonConvert.DeserializeObject<BigTable>(jsonStr);

二、JsonTextReader的简单用法

为了尽量减少内存使用和分配对象的数量，Json.NET提供了了解JsonTextReader，支持直接对流进行序列化和反序列化。每次读取或写入JSON片段，而不是将整个JSON字符串加载到内存中，这在处理大于85kb的JSON文档时尤其重要，以避免JSON字符串最终出现在大对象堆中.

  1. string json = @"{
  2.    'CPU': 'Intel',
  3.    'PSU': '500W',
  4.    'Drives': [
  5.      'DVD read/writer'
  6.      /*(broken)*/,
  7.      '500 gigabyte hard drive',
  8.      '200 gigabyte hard drive'
  9.    ]
  10. }";
  12. JsonTextReader reader = new JsonTextReader(new StringReader(json));
  13. while (reader.Read())
  14. {
  15.     if (reader.Value != null)
  16.     {
  17.         Console.WriteLine("Token: {0}, Value: {1}", reader.TokenType, reader.Value);
  18.     }
  19.     else
  20.     {
  21.         Console.WriteLine("Token: {0}", reader.TokenType);
  22.     }
  23. }
  27. Token: StartObject
  28. Token: PropertyName, Value: CPU
  29. Token: String, Value: Intel
  30. Token: PropertyName, Value: PSU
  31. Token: String, Value: 500W
  32. Token: PropertyName, Value: Drives
  33. Token: StartArray
  34. Token: String, Value: DVD read/writer
  35. Token: Comment, Value: (broken)
  36. Token: String, Value: 500 gigabyte hard drive
  37. Token: String, Value: 200 gigabyte hard drive
  38. Token: EndArray
  39. Token: EndObject

三、简单了解JsonTextReader的处理过程

JsonTextReader内部会通过State枚举记录其现在读取JSON字符串所在的位；

  1.         /// <summary>
  2.         /// Specifies the state of the reader.
  3.         /// </summary>
  4.         protected internal enum State
  5.         {
  6.             /// <summary>
  7.             /// A <see cref="JsonReader"/> read method has not been called.
  8.             /// </summary>
  9.             Start,
  11.             /// <summary>
  12.             /// The end of the file has been reached successfully.
  13.             /// </summary>
  14.             Complete,
  16.             /// <summary>
  17.             /// Reader is at a property.
  18.             /// </summary>
  19.             Property,
  21.             /// <summary>
  22.             /// Reader is at the start of an object.
  23.             /// </summary>
  24.             ObjectStart,
  26.             /// <summary>
  27.             /// Reader is in an object.
  28.             /// </summary>
  29.             Object,
  31.             /// <summary>
  32.             /// Reader is at the start of an array.
  33.             /// </summary>
  34.             ArrayStart,
  36.             /// <summary>
  37.             /// Reader is in an array.
  38.             /// </summary>
  39.             Array,
  41.             /// <summary>
  42.             /// The <see cref="JsonReader.Close()"/> method has been called.
  43.             /// </summary>
  44.             Closed,
  46.             /// <summary>
  47.             /// Reader has just read a value.
  48.             /// </summary>
  49.             PostValue,
  51.             /// <summary>
  52.             /// Reader is at the start of a constructor.
  53.             /// </summary>
  54.             ConstructorStart,
  56.             /// <summary>
  57.             /// Reader is in a constructor.
  58.             /// </summary>
  59.             Constructor,
  61.             /// <summary>
  62.             /// An error occurred that prevents the read operation from continuing.
  63.             /// </summary>
  64.             Error,
  66.             /// <summary>
  67.             /// The end of the file has been reached successfully.
  68.             /// </summary>
  69.             Finished
  70.         }

JsonTextReader在Read方法内部会根据当前_currentState来决定下一步处理的逻辑；在开始的时候_currentState=State.Start，所以会调用ParseValue方法；

  1.         public override bool Read()
  2.         {
  3.             EnsureBuffer();
  4.             MiscellaneousUtils.Assert(_chars != null);
  6.             while (true)
  7.             {
  8.                 switch (_currentState)
  9.                 {
  10.                     case State.Start:
  11.                     case State.Property:
  12.                     case State.Array:
  13.                     case State.ArrayStart:
  14.                     case State.Constructor:
  15.                     case State.ConstructorStart:
  16.                         return ParseValue();
  17.                     case State.Object:
  18.                     case State.ObjectStart:
  19.                         return ParseObject();
  20.                     case State.PostValue:
  21.                         // returns true if it hits
  22.                         // end of object or array
  23.                         if (ParsePostValue(false))
  24.                         {
  25.                             return true;
  26.                         }
  27.                         break;
  28.                     case State.Finished:
  29.                         if (EnsureChars(0, false))
  30.                         {
  31.                             EatWhitespace();
  32.                             if (_isEndOfFile)
  33.                             {
  34.                                 SetToken(JsonToken.None);
  35.                                 return false;
  36.                             }
  37.                             if (_chars[_charPos] == '/')
  38.                             {
  39.                                 ParseComment(true);
  40.                                 return true;
  41.                             }
  43.                             throw JsonReaderException.Create(this, "Additional text encountered after finished reading JSON content: {0}.".FormatWith(CultureInfo.InvariantCulture, _chars[_charPos]));
  44.                         }
  45.                         SetToken(JsonToken.None);
  46.                         return false;
  47.                     default:
  48.                         throw JsonReaderException.Create(this, "Unexpected state: {0}.".FormatWith(CultureInfo.InvariantCulture, CurrentState));
  49.                 }
  50.             }
  51.         }

JsonTextReader的ParseValue方法会根据当前读取的字符决定下一步的处理逻辑；由于_chars数组默认初始化的时候第一个字符是\0,并且_charsUsed和_charPos都为0，所以会调用ReadData方法；

  1.         private bool ParseValue()
  2.         {
  3.             MiscellaneousUtils.Assert(_chars != null);
  5.             while (true)
  6.             {
  7.                 char currentChar = _chars[_charPos];
  9.                 switch (currentChar)
  10.                 {
  11.                     case '\0':
  12.                         if (_charsUsed == _charPos)
  13.                         {
  14.                             if (ReadData(false) == 0)
  15.                             {
  16.                                 return false;
  17.                             }
  18.                         }
  19.                         else
  20.                         {
  21.                             _charPos++;
  22.                         }
  23.                         break;
  24.                     case '"':
  25.                     case '\'':
  26.                         ParseString(currentChar, ReadType.Read);
  27.                         return true;
  28.                     case 't':
  29.                         ParseTrue();
  30.                         return true;
  31.                     case 'f':
  32.                         ParseFalse();
  33.                         return true;
  34.                     case 'n':
  35.                         if (EnsureChars(1, true))
  36.                         {
  37.                             char next = _chars[_charPos + 1];
  39.                             if (next == 'u')
  40.                             {
  41.                                 ParseNull();
  42.                             }
  43.                             else if (next == 'e')
  44.                             {
  45.                                 ParseConstructor();
  46.                             }
  47.                             else
  48.                             {
  49.                                 throw CreateUnexpectedCharacterException(_chars[_charPos]);
  50.                             }
  51.                         }
  52.                         else
  53.                         {
  54.                             _charPos++;
  55.                             throw CreateUnexpectedEndException();
  56.                         }
  57.                         return true;
  58.                     case 'N':
  59.                         ParseNumberNaN(ReadType.Read);
  60.                         return true;
  61.                     case 'I':
  62.                         ParseNumberPositiveInfinity(ReadType.Read);
  63.                         return true;
  64.                     case '-':
  65.                         if (EnsureChars(1, true) && _chars[_charPos + 1] == 'I')
  66.                         {
  67.                             ParseNumberNegativeInfinity(ReadType.Read);
  68.                         }
  69.                         else
  70.                         {
  71.                             ParseNumber(ReadType.Read);
  72.                         }
  73.                         return true;
  74.                     case '/':
  75.                         ParseComment(true);
  76.                         return true;
  77.                     case 'u':
  78.                         ParseUndefined();
  79.                         return true;
  80.                     case '{':
  81.                         _charPos++;
  82.                         SetToken(JsonToken.StartObject);
  83.                         return true;
  84.                     case '[':
  85.                         _charPos++;
  86.                         SetToken(JsonToken.StartArray);
  87.                         return true;
  88.                     case ']':
  89.                         _charPos++;
  90.                         SetToken(JsonToken.EndArray);
  91.                         return true;
  92.                     case ',':
  93.                         // don't increment position, the next call to read will handle comma
  94.                         // this is done to handle multiple empty comma values
  95.                         SetToken(JsonToken.Undefined);
  96.                         return true;
  97.                     case ')':
  98.                         _charPos++;
  99.                         SetToken(JsonToken.EndConstructor);
  100.                         return true;
  101.                     case StringUtils.CarriageReturn:
  102.                         ProcessCarriageReturn(false);
  103.                         break;
  104.                     case StringUtils.LineFeed:
  105.                         ProcessLineFeed();
  106.                         break;
  107.                     case ' ':
  108.                     case StringUtils.Tab:
  109.                         // eat
  110.                         _charPos++;
  111.                         break;
  112.                     default:
  113.                         if (char.IsWhiteSpace(currentChar))
  114.                         {
  115.                             // eat
  116.                             _charPos++;
  117.                             break;
  118.                         }
  119.                         if (char.IsNumber(currentChar) || currentChar == '-' || currentChar == '.')
  120.                         {
  121.                             ParseNumber(ReadType.Read);
  122.                             return true;
  123.                         }
  125.                         throw CreateUnexpectedCharacterException(currentChar);
  126.                 }
  127.             }
  128.         }

在JsonTextReader内部会通过_chars来读取少量的字符；

  1.         private int ReadData(bool append)
  2.         {
  3.             return ReadData(append, 0);
  4.         }
  5.         
  6.         
  7.         private int ReadData(bool append, int charsRequired)
  8.         {
  9.             if (_isEndOfFile)
  10.             {
  11.                 return 0;
  12.             }
  14.             PrepareBufferForReadData(append, charsRequired);
  15.             MiscellaneousUtils.Assert(_chars != null);
  17.             int attemptCharReadCount = _chars.Length - _charsUsed - 1;
  19.             int charsRead = _reader.Read(_chars, _charsUsed, attemptCharReadCount);
  21.             _charsUsed += charsRead;
  23.             if (charsRead == 0)
  24.             {
  25.                 _isEndOfFile = true;
  26.             }
  28.             _chars[_charsUsed] = '\0';
  29.             return charsRead;
  30.         }

四、使用JsonTextReader优化反序列化

通过以上分析，我们可以直接使用二进制的文件流来读取文件，并将它传递给JsonTextReader，这样就可以实现小片段的读取并序列化；

  1. using (FileStream s = File.Open("json.txt", FileMode.Open))
  2. using (StreamReader sr = new StreamReader(s))
  3. using (JsonReader reader = new JsonTextReader(sr))
  4. {
  5.     JsonSerializer serializer = new JsonSerializer();
  6.     // read the json from a stream
  7.     // json size doesn't matter because only a small piece is read at a time
  8.     BigTable table = serializer.Deserialize<BigTable>(reader);
  9. }
  1. using (StreamReader sr = File.OpenText("json.txt"))
  2. using (JsonReader reader = new JsonTextReader(sr))
  3. {
  4.     JsonSerializer serializer = new JsonSerializer();
  5.     // read the json from a stream
  6.     // json size doesn't matter because only a small piece is read at a time
  7.     BigTable table = serializer.Deserialize<BigTable>(reader);
  8. }
  9.

原文链接：https://www.cnblogs.com/wufengtinghai/p/17150078.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

JSON热门文章

  • FastJson实现驼峰下划线相互转换方法详解
  • Cesium中的图形技术：Fabric —— 材质JSON规范
  • vue如何加载本地json数据
  • Json常用序列化工具包大比拼
  • fastjson 1.2.80 漏洞浅析及利用payload
  • Golang语言JSON解码函数Unmarshal的使用
  • [Linux] 解决CentOS下Requires: libjson-c.so错误
  • 解决layui的table插件无法多层级获取json数据的问题
  • C#使用Json.Net进行序列化和反序列化及定制化
  • golang如何修改json文件内容的方法示例

    • JSON推荐文章

  • 在.NET Web API设置响应输出Json数据格式常用的两种方式
  • 简单易懂的JSON框架
  • 安装、学习protobuf
  • 轻松上手Jackjson（珍藏版）
  • C# 中使对象序列化/反序列化 Json 支持使用派生类型以及泛型的方式
  • Asp .Net Core 系列：Asp .Net Core 集成 Newtonsoft.Json
  • 在 JMeter 中使用 JSON 提取器提取特定条件下的值
  • ASP.NET Core Web API设置响应输出的Json数据格式的两种方式
  • 基于jquery+html开发的json格式校验工具
  • 手把手教你写一个JSON在线解析的前端网站1

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号