JSON.net should not use default values ​​for constructor parameters, should use default value for properties

Question

Is there a way to tell JSON.net that when trying to deserialize using a constructor (if there is no default constructor), it should NOT assign a default value to the constructor parameters and that it should only call the constructor if each constructor parameter is represented in a JSON string? The same serializer SHOULD use default values ​​when invoking property / field settings, the rule is limited only to constructors. None of the enum values ​​apply here: http://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_DefaultValueHandling.htm

The solution should not rely on applying any attributes to deserialized types.

for example, the json string "{}" will deserialize to an object of type Dog , setting Dog age to 0 (the default value for int). I would like to get a generic solution not based on attributes so that this does not happen. In this case, {"age":4} will work because age is specified in the JSON string and matches the constructor parameter.

 public class Dog { public Dog(int age) { this.Age = age; } public int Age { get; } } 

However, if Dog specified as such, then "{}" must be deserialized to Dog with Age == 0, because Dog is not created using the constructor.

 public class Dog { public int Age { get; set; } } 

And to eliminate any questions about "why do you want to do this" ... Objects with constructors are usually qualitatively different from POCOs, since this applies to their properties. Using constuctor to store property values ​​instead of settable properties in POCO usually means that you want to check / limit property values. Therefore, it is reasonable not to allow deserialization with default values ​​in the presence of constuctor (s).

Answer 1

When Json.NET encounters an object without a constructor without parameters, but with a parameterized constructor, it calls this constructor to create an object that matches the JSON property names with the constructor arguments by name, using reflection using a case-sensitive best match algorithm. That is, a property whose name also appears in the constructor will be set through a call to the constructor, and not the specified method (even if it exists).

That way, you can mark the constructor argument as required by marking the equivalent property as required :

 public class Dog { public Dog(int age) { this.Age = age; } [JsonProperty(Required = Required.Always)] public int Age { get; } } 

Now JsonConvert.DeserializeObject<Dog>(jsonString) will JsonConvert.DeserializeObject<Dog>(jsonString) when the "age" property is missing.

Since this is what you always want, you can create a custom contract converter that inherits from DefaultContractResolver or CamelCasePropertyNamesContractResolver , which automatically marks the properties passed to the constructor, without the need for attributes

 public class ConstructorParametersRequiredContractResolver : DefaultContractResolver { // As of 7.0.1, Json.NET suggests using a static instance for "stateless" contract resolvers, for performance reasons. // http://www.newtonsoft.com/json/help/html/ContractResolver.htm // http://www.newtonsoft.com/json/help/html/M_Newtonsoft_Json_Serialization_DefaultContractResolver__ctor_1.htm // "Use the parameterless constructor and cache instances of the contract resolver within your application for optimal performance." // See also https://stackoverflow.com/questions/33557737/does-json-net-cache-types-serialization-information static ConstructorParametersRequiredContractResolver instance; static ConstructorParametersRequiredContractResolver() { instance = new ConstructorParametersRequiredContractResolver(); } public static ConstructorParametersRequiredContractResolver Instance { get { return instance; } } protected override JsonProperty CreatePropertyFromConstructorParameter(JsonProperty matchingMemberProperty, ParameterInfo parameterInfo) { var property = base.CreatePropertyFromConstructorParameter(matchingMemberProperty, parameterInfo); if (property != null && matchingMemberProperty != null) { var required = matchingMemberProperty.Required; if (required == Required.Default) { if (matchingMemberProperty.PropertyType != null && (matchingMemberProperty.PropertyType.IsValueType && Nullable.GetUnderlyingType(matchingMemberProperty.PropertyType) == null)) { required = Required.Always; } else { required = Required.AllowNull; } // It turns out to be necessary to mark the original matchingMemberProperty as required. property.Required = matchingMemberProperty.Required = required; } } return property; } } 

Then

 var settings = new JsonSerializerSettings { ContractResolver = ConstructorParametersRequiredContractResolver.Instance }; JsonConvert.DeserializeObject<T>(jsonString, settings) 

Give it up again.

(Note that this only works if there is a corresponding property. There is no direct way to mark a constructor parameter without the corresponding property, if required.)