Comparing .NET JSON Frameworks: Performance Insights Revealed
Written on
Chapter 1: Introduction to the Performance Series
Welcome to the latest installment of the .NET Performance Series, where we delve into various benchmarks, research, and comparisons relevant to the .NET landscape. This series emphasizes performance, particularly utilizing .NET 7, and aims to identify the fastest methods for different tasks while providing valuable tips for optimizing code performance with minimal effort. If these topics pique your interest, keep reading!
In this article, we will compare the two leading JSON frameworks for .NET:
Newtonsoft.Json and Microsoft’s System.Text.Json. With over 2.3 billion downloads, Newtonsoft.Json holds the title of the most downloaded package on NuGet, while System.Text.Json has garnered around 600 million downloads. It’s important to note that System.Text.Json is included by default with the .NET SDK starting from .NET Core 3.1. Despite this, Newtonsoft.Json continues to be the preferred choice for many developers. Let’s explore whether it can maintain its reputation or if Microsoft is gradually taking the lead in performance.
Chapter 2: Benchmark Scenarios
To emulate realistic application scenarios, we will evaluate two primary use cases:
- Serialization and deserialization of a large dataset.
- Serialization and deserialization of multiple smaller datasets.
For our test data, we will utilize the NuGet package Bogus, which allows us to swiftly generate diverse user data, including names, emails, and IDs.
For the benchmarks, we will work with the latest versions of each framework as of October 2022:
- Newtonsoft.Json — 13.0.1
- System.Text.Json — 7.0.0-rc.2
Section 2.1: Serialization Benchmarks
Subsection 2.1.1: Large Data Object Serialization
To evaluate the serialization of a single large object, we will utilize a List created during our GlobalSetup() method. Our benchmarking methods will employ the default ContractResolver, which is instantiated only once, ensuring optimal performance for both frameworks. It’s crucial to avoid instantiating the ContractResolver multiple times when using custom JsonSerializerSettings to maintain performance.
Now, let’s review the results:
Despite Newtonsoft’s claims of high performance being superior to .NET's built-in JSON serializers, our findings indicate that they do not significantly outperform the built-in options for this particular use case.
Subsection 2.1.2: Small Data Objects Serialization
This scenario is more reflective of typical real-world applications, such as REST APIs, where each web request requires handling JSON data. For this case, we will iterate through our previously created List to serialize each user individually.
On my machine, this benchmark produced the following results:
We observed a performance increase of nearly 100% for System.Text.Json when dealing with numerous smaller objects. Not only is its performance twice as fast as Newtonsoft, but it also allocates five times less heap memory. As highlighted in previous articles, optimizing heap memory usage is vital since it must eventually be garbage collected, which can impede application execution.
Section 2.2: Deserialization Benchmarks
Subsection 2.2.1: Large Data Object Deserialization
In real-world scenarios, it’s essential not only to serialize but also to deserialize objects from a JSON string. For this benchmark, we again use Bogus to create a set of users, serializing them into one large string for the big data object and into a List for the many small data objects.
Running these benchmarks on my setup yields the following results:
Microsoft continues to outperform Newtonsoft in terms of performance. Although Newtonsoft shows improvement and is now approximately 40% slower, this is a notable enhancement compared to its serialization performance.
Subsection 2.2.2: Small Data Objects Deserialization
The final benchmark examines the deserialization of many small objects. We will utilize the List initialized in the GlobalSetup() method to deserialize each data object in a loop.
The results are even more impressive than those from the corresponding serialization benchmark:
System.Text.Json demonstrates twice the speed and shows seven times better memory efficiency compared to Newtonsoft!
Chapter 3: Conclusion
Despite Newtonsoft’s assertion of high performance exceeding that of .NET's built-in JSON serializers, it is clear that—at least since the advent of .NET 7—Microsoft’s System.Text.Json consistently outperforms Newtonsoft.Json across all tested use cases, including:
- Serialization of one large dataset
- Serialization of many small datasets
- Deserialization of one large dataset
- Deserialization of many small datasets
This is true with the default serializer settings for both frameworks. Not only does System.Text.Json exhibit speed advantages of up to 100%, but it also shows more than five times greater memory efficiency in certain scenarios.
It’s reasonable to conclude that System.Text.Json is currently the faster option compared to Newtonsoft.Json. However, keep in mind that these results apply specifically to .NET 7; earlier versions may yield different outcomes favoring Newtonsoft.
For further insights, explore the other posts in this series. The .NET Performance Series is supported by my GitHub repository, accessible here.
Thank you for engaging with this article. I hope you found it informative and insightful. Your support is invaluable, and if you wish to stay updated on the latest trends, tips, and techniques related to clean architecture, clean coding, and cutting-edge technology stacks—especially in C#, .NET, and Angular—I invite you to follow me.
Have a great day!