How to Deserialize JSON with a specific constructor in C#

Here’s an example using a Product class with two constructors. I’ll place the JsonConstructor attribute on one of them:

using System.Text.Json.Serialization;

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; private set; }

    [JsonConstructor]
    public Product(decimal price)
    {
        Price = price;
    }

    public Product() { }
}

Note: The JsonConstructor attribute for System.Text.Json was introduced in .NET 5.

Now, deserialize a JSON string into a Product object:

using System.Text.Json;

var product = JsonSerializer.Deserialize<Product>("{\"Price\":199.99, \"Name\":\"Laptop\"}");
Console.WriteLine($"Product: {product.Name}, Price: {product.Price}");

Output:

Product: Laptop, Price: 199.99

In this example, the deserialization used the Product(decimal price) constructor because it has the JsonConstructor attribute. The Price JSON property was passed to this constructor, and then the Name property was set afterward, as it was not passed in the constructor.

Which Constructor Will System.Text.Json Use?

When deserializing, System.Text.Json will search for a public constructor following this precedence order:

1. Constructor with the [JsonConstructor] attribute:

[JsonConstructor]
public Product(decimal price) // Uses this one
public Product() // If no other constructors with attributes

2. Public parameterless constructor:

public Product() // Uses this one if no other matching constructor

3. Only one public constructor available:

public Product(decimal price) // Uses this one

If there's no constructor that meets these criteria, deserialization will fail with the following exception:

System.NotSupportedException: Deserialization of types without a parameterless constructor, a singular parameterized constructor, or a parameterized constructor annotated with 'JsonConstructorAttribute' is not supported

Common Issues

1. Error – Multiple [JsonConstructor] attributes: You can’t place multiple JsonConstructor attributes on different constructors. This would result in an exception:

System.InvalidOperationException: The type 'JsonConstructors.Product' cannot have more than one member that has the attribute 'System.Text.Json.Serialization.JsonConstructorAttribute'

Example of incorrect usage:

[JsonConstructor]
public Product(decimal price)
[JsonConstructor]
public Product(decimal price, string name)

2. Error – No suitable public constructor: If no suitable public constructor is found, you’ll get an exception. Make sure the constructor is either parameterless, has one parameter marked with JsonConstructor, or is the only constructor available.

For example, a private constructor will cause an error unless handled explicitly:

internal Product() { }
public Product(decimal price) { }

3. Constructor Parameter Names: When deserializing, ensure that the constructor’s parameter names match the JSON properties (case-insensitive by default). Here’s an example where the property names in the JSON match the constructor parameter names:

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; private set; }

    [JsonConstructor]
    public Product(decimal price)
    {
        Price = price;
    }

    public Product() { }
}

Handling Non-Public Constructors

If you are working with non-public constructors, System.Text.Json won’t work out of the box. You’d need to write a custom converter. However, Newtonsoft.Json can deserialize even private constructors.

For example, Newtonsoft.Json can use private constructors like this:

using Newtonsoft.Json;

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; private set; }

    [JsonConstructor]
    private Product(decimal price)
    {
        Price = price;
    }

    public Product() { }
}

Deserialize with Newtonsoft:

using Newtonsoft.Json;

var product = JsonConvert.DeserializeObject<Product>("{\"Price\":199.99}");
Console.WriteLine($"Product: {product.Name}, Price: {product.Price}");

Output:

Product: null, Price: 199.99

When You Can’t Use JsonConstructor:

If you can’t modify the class or use JsonConstructor, there are two options:

1. Subclass and Add a Constructor: If the class is from a third-party library, subclass it and add the constructor with JsonConstructor:

public class CustomProduct : Product
{
    [JsonConstructor]
    public CustomProduct(decimal price) : base(price) { }
}

Deserialize using the subclass:

var product = JsonSerializer.Deserialize<CustomProduct>("{\"Price\":199.99, \"Name\":\"Tablet\"}");
Console.WriteLine($"Product: {product.Name}, Price: {product.Price}");

2. Write a Custom Converter: If subclassing isn't an option, create a custom converter to handle the deserialization:

public class ProductConverter : JsonConverter<Product>
{
    public override Product Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        var jsonDoc = JsonDocument.ParseValue(ref reader);
        var price = jsonDoc.RootElement.GetProperty("Price").GetDecimal();
        return new Product(price) { Name = jsonDoc.RootElement.GetProperty("Name").GetString() };
    }

    public override void Write(Utf8JsonWriter writer, Product value, JsonSerializerOptions options)
    {
        JsonSerializer.Serialize(writer, value, options);
    }
}

Add the converter to JsonSerializerOptions:

var options = new JsonSerializerOptions();
options.Converters.Add(new ProductConverter());

var product = JsonSerializer.Deserialize<Product>("{\"Price\":299.99, \"Name\":\"Smartphone\"}", options);
Console.WriteLine($"Product: {product.Name}, Price: {product.Price}");

This technique works with sealed or third-party classes you cannot modify.

Both System.Text.Json and Newtonsoft.Json handle constructors similarly, but they have slight differences when dealing with non-public constructors or requiring a custom converter. By using the JsonConstructor attribute, you can control which constructor gets used during deserialization, providing a clean and predictable approach to handle complex object creation from JSON.