c# - Benchmarking Newtonsoft.Json反序列化: from stream and from string

Question

我对如何使用 Newtonsoft.Json 反序列化 HTTP 响应 JSON 负载的两种方法的性能(速度、内存使用)比较感兴趣.

我知道 Newtonsoft.Json's Performance Tips使用流，但我想了解更多并获得硬数据。我使用 BenchmarkDotNet 编写了简单的基准测试，但我对结果有点困惑(见下面的数字)。

我得到的:

• 从流中解析总是更快，但不是真的很多
• 在使用字符串作为输入时，解析小型和“中型”JSON 具有更好或相等的内存使用
• 大型 JSON(其中字符串本身以 LOH 结尾)开始出现内存使用的显着差异

我还没有时间进行适当的分析，我对流方法的内存开销感到有点惊讶(如果没有错误的话)。整个代码是here .

?

• 我的方法正确吗？ (使用 MemoryStream；模拟 HttpResponseMessage 及其内容；...)
• 基准测试代码有什么问题吗？
• 为什么我会看到这样的结果？

基准设置

我正在准备 MemoryStream 以便在基准测试运行中反复使用:

[GlobalSetup]
public void GlobalSetup()
{
    var resourceName = _resourceMapping[typeof(T)];
    using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
    {
        _memory = new MemoryStream();
        resourceStream.CopyTo(_memory);
    }

    _iterationRepeats = _repeatMapping[typeof(T)];
}

流反序列化

[Benchmark(Description = "Stream d13n")]
public async Task DeserializeStream()
{
    for (var i = 0; i < _iterationRepeats; i++)
    {
        var response = BuildResponse(_memory);

        using (var streamReader = BuildNonClosingStreamReader(await response.Content.ReadAsStreamAsync()))
        using (var jsonReader = new JsonTextReader(streamReader))
        {
            _serializer.Deserialize<T>(jsonReader);
        }
    }
}

字符串反序列化

我们首先从流中读取 JSON 到字符串，然后运行反序列化 - 正在分配另一个字符串，然后用于反序列化。

[Benchmark(Description = "String d13n")]
public async Task DeserializeString()
{
    for (var i = 0; i < _iterationRepeats; i++)
    {
        var response = BuildResponse(_memory);

        var content = await response.Content.ReadAsStringAsync();
        JsonConvert.DeserializeObject<T>(content);
    }
}

常用方法

private static HttpResponseMessage BuildResponse(Stream stream)
{
    stream.Seek(0, SeekOrigin.Begin);

    var content = new StreamContent(stream);
    content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

    return new HttpResponseMessage(HttpStatusCode.OK)
    {
        Content = content
    };
}

[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static StreamReader BuildNonClosingStreamReader(Stream inputStream) =>
    new StreamReader(
        stream: inputStream,
        encoding: Encoding.UTF8,
        detectEncodingFromByteOrderMarks: true,
        bufferSize: 1024,
        leaveOpen: true);

结果

小型 JSON

重复10000次

• 流:平均 25.69 毫秒，分配 61.34 MB
• 字符串:平均 31.22 毫秒，分配 36.01 MB

中等 JSON

重复1000次

• 流:平均 24.07 毫秒，分配 12 MB
• 字符串:平均 25.09 毫秒，分配 12.85 MB

大型 JSON

重复100次

• 流:平均 229.6 毫秒，分配 47.54 MB，对象到达第 1 代
• 字符串:平均 240.8 毫秒，分配 92.42 MB，对象到达第 2 代!

---

更新

我查看了 JsonConvert 的源代码，发现它在从 string 反序列化时在内部使用 JsonTextReader 和 StringReader >:JsonConvert:816 . Stream 也参与其中(当然!)。

然后我决定深入研究 StreamReader 本身，第一眼看到时我惊呆了——它总是分配数组缓冲区 (byte[]):StreamReader:244 ，这解释了它的内存使用。

这给了我“为什么”的答案。解决方案很简单 - 在实例化 StreamReader 时使用较小的缓冲区大小 - 最小缓冲区大小默认为 128(请参阅 StreamReader.MinBufferSize)，但您可以提供任何值 > 0 (检查 ctor 重载之一)。

当然缓冲区大小对处理数据有影响。回答我应该使用什么缓冲区大小:这取决于。当期望较小的 JSON 响应时，我认为坚持使用小缓冲区是安全的。

Answer 1

经过一些调整后，我发现了使用 StreamReader 时内存分配背后的原因。原始帖子已更新，但在此回顾一下:

StreamReader 使用默认的 bufferSize 设置为 1024。StreamReader 的每个实例然后分配该大小的字节数组。这就是我在基准测试中看到这些数字的原因。

当我将 bufferSize 设置为可能的最低值 128 时，结果似乎好多了。

• StreamReader:244, initialization
• StreamReader.MinBufferSize