Does Json.NET cache types’ serialization information?

by

Yes, it does. Json.NET caches type serialization information inside its IContractResolver classes DefaultContractResolver and CamelCasePropertyNamesContractResolver. Unless you specify a custom contract resolver, this information is cached and reused.

For DefaultContractResolver a global static instance is maintained internally that Json.NET uses whenever the application does not specify its own contract resolver. CamelCasePropertyNamesContractResolver, on the other hand, maintains static tables that are shared across all instances. (I believe the inconsistency arises from legacy issues; see here for details.)

Both of these types are designed to be fully thread-safe so sharing between threads should not be a problem.

If you choose to implement and instantiate your own contract resolver, then type information will only be cached and reused if you cache and reuse the contract resolver instance itself. Thus, Newtonsoft recommends:

For performance you should create a contract resolver once and reuse instances when possible. Resolving contracts is slow and implementations of IContractResolver typically cache contracts.

If memory consumption is a problem and for whatever reason you need to minimize the memory permanently taken by cached contracts, you can construct your own local instance of DefaultContractResolver (or some custom subclass), serialize using that, and then immediately remove all references to it, e.g.:

public class JsonExtensions
{
    public static string SerializeObjectNoCache<T>(T obj, JsonSerializerSettings settings = null)
    {
        settings = settings ?? new JsonSerializerSettings();
        bool reset = (settings.ContractResolver == null);
        if (reset)
            // To reduce memory footprint, do not cache contract information in the global contract resolver.
            settings.ContractResolver = new DefaultContractResolver();
        try
        {
            return JsonConvert.SerializeObject(obj, settings);
        }
        finally
        {
            if (reset)
                settings.ContractResolver = null;
        }
    }
}

And if you are using CamelCasePropertyNamesContractResolver, switch to DefaultContractResolver with an appropriate naming strategy such as:

settings.ContractResolver = new DefaultContractResolver { NamingStrategy = new CamelCaseNamingStrategy() };

The majority of cached contract memory (but not all) will eventually get garbage collected. Of course, by doing this, serialization performance may suffer substantially. (Some tables containing reflected information about e.g. enum types and data contract attributes are shared globally and not reclaimed.)

For further information see Newtonsoft’s Performance Tips: Reuse Contract Resolver.

More Related Contents:

  1. JSON.NET Error Self referencing loop detected for type
  2. Cannot deserialize the JSON array (e.g. [1,2,3]) into type ‘ ‘ because type requires JSON object (e.g. {“name”:”value”}) to deserialize correctly
  3. How to deserialize an array of values with a fixed schema to a strongly typed data class?
  4. Using JsonConvert.DeserializeObject to deserialize Json to a C# POCO class
  5. JSON.Net throws StackOverflowException when using [JsonConvert()]
  6. How to ignore JsonProperty(PropertyName = “someName”) when serializing json?
  7. “Self Referencing Loop Detected” exception with JSON.Net
  8. Newtonsoft.JSON cannot convert model with TypeConverter attribute
  9. Deserializing JSON to abstract class
  10. Deserialize json array stream one item at a time
  11. Not ableTo Serialize Dictionary with Complex key using Json.net
  12. How to deserialize a JSON property that can be two different data types using Json.NET
  13. Serialize Property, but Do Not Deserialize Property in Json.Net
  14. How to make JSON.Net serializer to call ToString() when serializing a particular type?
  15. Json.NET custom serialization with JsonConverter – how to get the “default” behavior
  16. Cannot deserialize the current JSON array (e.g. [1,2,3])
  17. Cannot deserialize JSON array into type – Json.NET
  18. How to apply indenting serialization only to some properties?
  19. Ignoring null fields in Json.net
  20. How to apply ObjectCreationHandling.Replace to selected properties when deserializing JSON?
  21. Convert DataTable to JSON with key per row
  22. Deserialize specific enum into system.enum in Json.Net
  23. Json.NET: Deserializing nested dictionaries
  24. Json.net deserialization null guid case
  25. Deserializing JSON into an object with Json.NET
  26. Ignore Base Class Properties in Json.NET Serialization
  27. Configure Json.NET serialization settings on a class level
  28. JSON.NET Serializes Empty JSON
  29. NewtonSoft.Json Serialize and Deserialize class with property of type IEnumerable
  30. Json.net serialization of custom collection implementing IEnumerable

Leave a Comment