Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How does JSON deserialization in C# work

Tags:

c#

json.net

I am trying to understand how JsonConvert.DeserializeObject<X>(someJsonString) is able to set the values by using the constructor.

using Newtonsoft.json

public class X {

    [JsonProperty("some_Property")]
    public string SomeProperty {get;}

    [JsonProperty("some_Property_2")]
    public string SomeProperty2 {get;}

    public X(string someProperty, string someProperty2) {
        SomeProperty = someProperty;
        SomeProperty2 = someProperty2;
    }

    public static X parseObject(string parseThisJson) {
      JsonConvert.DeserializeObject<X>(someJsonString);
    }
}

In above code I want to understand how is JsonConvert.DeserializeObject is able to deserialize it correctly. Does the json serialize uses this public X(string someProperty, string someProperty2) constructor? If so how is this constructor called and used?

What will happen is parseThisJson have more key value pairs in addition to some_Property and some_Property_2?

like image 936
user2358262 Avatar asked Jan 26 '17 09:01

user2358262


People also ask

How does JSON deserialization work?

In Deserialization, it does the opposite of Serialization which means it converts JSON string to custom . Net object. In the following code, it calls the static method DeserializeObject() of the JsonConvert class by passing JSON data. It returns a custom object (BlogSites) from JSON data.

What is JSON deserialization?

The process whereby a lower-level format (e.g. that has been transferred over a network, or stored in a data store) is translated into a readable object or other data structure. In JavaScript, for example, you can deserialize a JSON string to an object by calling the function JSON.

How does deserialization work in C#?

December 17, 2021. Serialization in C# is the process of bringing an object into a structure that is composed in memory. Deserialization is the opposite of serialization. It involves retrieving the serialized object so that it can be stored in memory.

How do I deserialize a JSON string to an object in C#?

A common way to deserialize JSON is to first create a class with properties and fields that represent one or more of the JSON properties. Then, to deserialize from a string or a file, call the JsonSerializer. Deserialize method.


1 Answers

After digging into Newtonsoft.Json sources I can tell you algorithm of object instantiation which is used there. And yes, constructor is almost always called (*). The question is only "which one?". Here is colorful version of answer:

picking constructor

TL;DR First of all, Newtonsoft.Json creates JsonContract of the type which you are going to deserialize. Its abstract class. And it has different implementations for dictionaries, arrays, objects etc. In your case JsonObjectContract will be created. Contract contains various metadata about deserialized type. Most interesting for us are:

  • IsInstantiable - defines whether deserialized type is instantiable (see below)
  • Properties - its collection of object properties
  • DefaultCreator - default creation method used to create object Func<object>
  • DefaultCreatorNonPublic - defines whether default constructor is non public
  • OverrideCreator - non-default creator, used if JsonConstructorAttribute is applied to object's constructor
  • ParametrizedCreator - creator which calls paramterized constructor, it is used if we don't have neither default nor override creators
  • CreatorParameters - collection of properties which are used for override creator or parametrized creator
  • MemberSerialization - this value defines the way how properties and fields are serialized. By default it is set to OptOut - i.e. all public members are serialized. If you want to exclude some, you should use JsonIgnore attribute. But there is also Fields option, which says that all public and private fields should be serialized. There is several to turn-on this option. But by default its disabled.

Some of this metadata can be retrieved by reflecting type metdata. E.g. IsInstantiable is calculated by checking whether deserialized type is not abstract and not interface. Some metadata are added by DefaultContractResolver. In particular, it defines the way how object should be constructed. In pseudo-code:

if (contract.IsInstantiable)
{
   if (type has default constructor or its a value type)
   {
       contract.DefaultCreator = get default (parameterless) constructor;
       contract.DefaultCreatorNonPublic = check if default constructor public
   }

   if (we have constructor marked with JsonConstructorAttribute)
   {
       contract.OverrideCreator = constructor marked with attribute
       contract.CreatorParameters = get properties which match constructor parameters
   }
   else if (contract.MemberSerialization == MemberSerialization.Fields)
   {
       // only if the upplication if fully trusted
       contract.DefaultCreator = FormatterServices.GetUninitializedObject 
   }
   else if (contract.DefaultCreator == null || contract.DefaultCreatorNonPublic)
   {
         if (we have one public constructor with parameters)
         {
              contract.ParametrizedCreator = constructor with parameters;
              contract.CreatorParameters = get properties which match ctor parameters
         }
   }
}

So, as you can see priority goes to constructor marked with JsonConstructorAttribute attribute. You will also get error if there is more than one such constructor.

(*) Next goes the only case when object can be created without calling constructor. E.g. if you'll mark class with [JsonObject(MemberSerialization = MemberSerialization.Fields)] attribute to serialize private fields.

Then we check if we have default parameterless constructor which is not private. If so, then we go for other constructor - one which has parameters and should be public. If there is more than one such constructor, you will also get error.

And last thing to note - CreatorParameters. Newtonsoft.Json uses reflection to get constructor parameters and then tries to find closest match by name of these constructor parameters to object's properties. It also checks type of property and parameters to match. If there is no match found, then default value will be passed to this parameterized constructor.

like image 108
Sergey Berezovskiy Avatar answered Sep 24 '22 02:09

Sergey Berezovskiy