JSON.net: how to deserialize without using the default constructor?

Json.Net prefers to use the default (parameterless) constructor on an object if there is one. If there are multiple constructors and you want Json.Net to use a non-default one, then you can add the [JsonConstructor] attribute to the constructor that you want Json.Net to call.

[JsonConstructor]public Result(int? code, string format, Dictionary<string, string> details = null){    ...}

It is important that the constructor parameter names match the corresponding property names of the JSON object (ignoring case) for this to work correctly. You do not necessarily have to have a constructor parameter for every property of the object, however. For those JSON object properties that are not covered by the constructor parameters, Json.Net will try to use the public property accessors (or properties/fields marked with [JsonProperty]) to populate the object after constructing it.

If you do not want to add attributes to your class or don't otherwise control the source code for the class you are trying to deserialize, then another alternative is to create a custom JsonConverter to instantiate and populate your object. For example:

class ResultConverter : JsonConverter{    public override bool CanConvert(Type objectType)    {        return (objectType == typeof(Result));    }    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)    {        // Load the JSON for the Result into a JObject        JObject jo = JObject.Load(reader);        // Read the properties which will be used as constructor parameters        int? code = (int?)jo["Code"];        string format = (string)jo["Format"];        // Construct the Result object using the non-default constructor        Result result = new Result(code, format);        // (If anything else needs to be populated on the result object, do that here)        // Return the result        return result;    }    public override bool CanWrite    {        get { return false; }    }    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)    {        throw new NotImplementedException();    }}

Then, add the converter to your serializer settings, and use the settings when you deserialize:

JsonSerializerSettings settings = new JsonSerializerSettings();settings.Converters.Add(new ResultConverter());Result result = JsonConvert.DeserializeObject<Result>(jsontext, settings);

A bit late and not exactly suited here, but I'm gonna add my solution here, because my question had been closed as a duplicate of this one, and because this solution is completely different.

I needed a general way to instruct Json.NET to prefer the most specific constructor for a user defined struct type, so I can omit the JsonConstructor attributes which would add a dependency to the project where each such struct is defined.

I've reverse engineered a bit and implemented a custom contract resolver where I've overridden the CreateObjectContract method to add my custom creation logic.

public class CustomContractResolver : DefaultContractResolver {    protected override JsonObjectContract CreateObjectContract(Type objectType)    {        var c = base.CreateObjectContract(objectType);        if (!IsCustomStruct(objectType)) return c;        IList<ConstructorInfo> list = objectType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).OrderBy(e => e.GetParameters().Length).ToList();        var mostSpecific = list.LastOrDefault();        if (mostSpecific != null)        {            c.OverrideCreator = CreateParameterizedConstructor(mostSpecific);            c.CreatorParameters.AddRange(CreateConstructorParameters(mostSpecific, c.Properties));        }        return c;    }    protected virtual bool IsCustomStruct(Type objectType)    {        return objectType.IsValueType && !objectType.IsPrimitive && !objectType.IsEnum && !objectType.Namespace.IsNullOrEmpty() && !objectType.Namespace.StartsWith("System.");    }    private ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)    {        method.ThrowIfNull("method");        var c = method as ConstructorInfo;        if (c != null)            return a => c.Invoke(a);        return a => method.Invoke(null, a);    }}

I'm using it like this.

public struct Test {  public readonly int A;  public readonly string B;  public Test(int a, string b) {    A = a;    B = b;  }}var json = JsonConvert.SerializeObject(new Test(1, "Test"), new JsonSerializerSettings {  ContractResolver = new CustomContractResolver()});var t = JsonConvert.DeserializeObject<Test>(json);t.A.ShouldEqual(1);t.B.ShouldEqual("Test");

Based on some of the answers here, I have written a CustomConstructorResolver for use in a current project, and I thought it might help somebody else.

It supports the following resolution mechanisms, all configurable:

• Select a single private constructor so you can define one private constructor without having to mark it with an attribute.
• Select the most specific private constructor so you can have multiple overloads, still without having to use attributes.
• Select the constructor marked with an attribute of a specific name - like the default resolver, but without a dependency on the Json.Net package because you need to reference Newtonsoft.Json.JsonConstructorAttribute.

public class CustomConstructorResolver : DefaultContractResolver{    public string ConstructorAttributeName { get; set; } = "JsonConstructorAttribute";    public bool IgnoreAttributeConstructor { get; set; } = false;    public bool IgnoreSinglePrivateConstructor { get; set; } = false;    public bool IgnoreMostSpecificConstructor { get; set; } = false;    protected override JsonObjectContract CreateObjectContract(Type objectType)    {        var contract = base.CreateObjectContract(objectType);        // Use default contract for non-object types.        if (objectType.IsPrimitive || objectType.IsEnum) return contract;        // Look for constructor with attribute first, then single private, then most specific.        var overrideConstructor =                (this.IgnoreAttributeConstructor ? null : GetAttributeConstructor(objectType))             ?? (this.IgnoreSinglePrivateConstructor ? null : GetSinglePrivateConstructor(objectType))             ?? (this.IgnoreMostSpecificConstructor ? null : GetMostSpecificConstructor(objectType));        // Set override constructor if found, otherwise use default contract.        if (overrideConstructor != null)        {            SetOverrideCreator(contract, overrideConstructor);        }        return contract;    }    private void SetOverrideCreator(JsonObjectContract contract, ConstructorInfo attributeConstructor)    {        contract.OverrideCreator = CreateParameterizedConstructor(attributeConstructor);        contract.CreatorParameters.Clear();        foreach (var constructorParameter in base.CreateConstructorParameters(attributeConstructor, contract.Properties))        {            contract.CreatorParameters.Add(constructorParameter);        }    }    private ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)    {        var c = method as ConstructorInfo;        if (c != null)            return a => c.Invoke(a);        return a => method.Invoke(null, a);    }    protected virtual ConstructorInfo GetAttributeConstructor(Type objectType)    {        var constructors = objectType            .GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)            .Where(c => c.GetCustomAttributes().Any(a => a.GetType().Name == this.ConstructorAttributeName)).ToList();        if (constructors.Count == 1) return constructors[0];        if (constructors.Count > 1)            throw new JsonException($"Multiple constructors with a {this.ConstructorAttributeName}.");        return null;    }    protected virtual ConstructorInfo GetSinglePrivateConstructor(Type objectType)    {        var constructors = objectType            .GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic);        return constructors.Length == 1 ? constructors[0] : null;    }    protected virtual ConstructorInfo GetMostSpecificConstructor(Type objectType)    {        var constructors = objectType            .GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)            .OrderBy(e => e.GetParameters().Length);        var mostSpecific = constructors.LastOrDefault();        return mostSpecific;    }}

Here is the complete version with XML documentation as a gist: https://gist.github.com/maverickelementalch/80f77f4b6bdce3b434b0f7a1d06baa95

Feedback appreciated.