Deserialize interfaces using System.Text.Json.JsonSerializer

[douglasg14b]

#30956 seems to have been the original request for this, however it's closed as completed, but there is still no support for JSON Serialization of interfaces as of .Net 7...?

Following through this chain of issues #30956 -> #30083 -> #63747 -> #71346

---

It's suggested in the implementation noted in #63747 that the following would allow for interface de-serialization:

[JsonPolymorphic(UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToNearestAncestor)]
[JsonDerivedType(typeof(Node))]
interface INode 
{
    string Value { get; set; }
}

class Node : INode
{
    public string Value { get; set; }
}

// Should be able to de-serialize to this
class MyClass 
{
    public INode Value { get; set; }
}

Hhowever doing something similar to this results in a pretty clear exception:

System.NotSupportedException: Deserialization of interface types is not supported

All threads I could find related to this feature are closed as completed. So here I am!

Is this a feature already tracked?

[eiriktsarpalis]

Deserialization via JsonDerivedType is only supported if you additionally specify a type discriminator on the attribute like so:

string json = JsonSerializer.Serialize(new Node { Value = "value" }); // { "$type" : "node", "Value" : "value" }
JsonSerializer.Deserialize<INode>(json) is Node; // true

[JsonDerivedType(typeof(Node), "node")]
interface INode 
{
    string Value { get; set; }
}

Please see the relevant article for more details.

If polymorphism is not what you were specifically looking for, and you just want the serializer to always fill in INode values with instances of type Node, you can configure this via the contract customization feature:

var options = new JsonSerializerOptions
{
     TypeInfoResolver = new DefaultJsonTypeInfoResolver
     {
           Modifiers =
           {
                 static typeInfo =>
                 {
                       if (typeInfo.Type == typeof(INode))
                       {
                             typeInfo.CreateObject = () => new Node();
                       }
                 }
           }
     }
};

JsonSerializer.Deserialize<INode>("{}", options) is Node; // true

Hope this helps.

[douglasg14b]

Gotcha, so essentially, if we don't have control over the JSON directly (external API, event stream...etc) to add/pollute it with our type discriminators. There is no direct (Ie. an attribute that directs the serializer to deserialzie as a concrete type which implements that interface) support for de-serializing to an interface?

Is there a [JsonProperty] like attribute that can attach directly to the property to direct it to use a specific concrete class to satisfy the de-serialization of that property?

I'm concerned about hiding details like this inside of JsonSerializerOptions, the complexity that adds for non-simple wants, and new problems with project scoping (Since we don't necessarily want the JSON utility knowing about all our domain concrete types, we would want to augment it dynamically....etc) 🤔

Very awkward, heavy-handed way to de-serialize.

[eiriktsarpalis]

It might be possible that we support this in the future via #87569, however in the meantime it should be easy to author your own custom attribute as a plug-in:

var options = new JsonSerializerOptions
{
    TypeInfoResolver = new DefaultJsonTypeInfoResolver
    {
        Modifiers = { JsonImplementationAttribute.ReadAttributeFromTypeInfo }
    }
};

Console.WriteLine(JsonSerializer.Deserialize<INode>("{}", options) is Node);

[JsonImplementation(typeof(Node))]
public interface INode
{
}

public class Node : INode
{
}


[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface)]
public class JsonImplementationAttribute : Attribute
{
    public JsonImplementationAttribute(Type type)
        => Type = type;
    public Type Type { get; }

    public static void ReadAttributeFromTypeInfo(JsonTypeInfo typeInfo)
    {
        JsonImplementationAttribute? attr = typeInfo.Type.GetCustomAttribute<JsonImplementationAttribute>();
        if (attr != null)
        {
            Type implementationType = attr.Type;
            if (!typeInfo.Type.IsAssignableFrom(implementationType))
            {
                throw new InvalidOperationException("Implementation type is not assignable to annotated type.");
            }

            typeInfo.CreateObject = () => Activator.CreateInstance(implementationType, nonPublic: true)!;
        }
    }
}

[gregsdennis]

FWIW and completeness, I implemented this in Manatee.Json by emitting IL that created an implementation of the interface in an in-memory assembly. It wasn't the best solution, but it worked.

I suppose it could be done better now with source gen.

[IsmailHassani]

I came across this post after getting an exception also, but found the use of attributes a little counterproductive.
The whole reason of using interfaces is that these know nothing about the implementation. By specifying the attribute, the interface becomes strongly coupled to the implementation which defeats its purpose of using it.

Thats why i came up with another solution which works for me without strongly reference it with an attribute.

Model

public class Budget : ModelBase, IBudget
{
    /// <summary>
    /// Gets or sets the BudgetId property value.
    /// </summary>
    [Required]
    [Identity]
    public Guid BudgetId
    {
        get => GetValue<Guid>();
        set => SetValue(value);
    }

    /// <summary>
    /// Gets or sets the Description property value.
    /// </summary>
    [Required]
    [StringLength(255)]
    public string Description
    {
        get => GetValue<string>();
        set => SetValue(value);
    }

    ...
}

Interface

public interface IBudget : IModelBase
{
    /// <summary>
    /// Gets or sets the BudgetId property value.
    /// </summary>
    [Required]
    [Identity]
    Guid BudgetId { get; set; }

    /// <summary>
    /// Gets or sets the Description property value.
    /// </summary>
    [Required]
    [StringLength(255)]
    string Description { get; set; }
   ...
}

TypeResolver

public static class TypeResolvers
{
    public static Action<JsonTypeInfo> GetBudgetsTypeResolvers()
    {
        return typeInfo =>
        {
            if (typeInfo.Type == typeof(IBudget))
                typeInfo.CreateObject = () => new Budget();
        };
    }
}

Dependency injection (inside hostbuilder for example)

services.AddSingleton<JsonSerializerOptions>((s) =>
{
    var options = new JsonSerializerOptions
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        PropertyNameCaseInsensitive = true,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
        ReadCommentHandling = JsonCommentHandling.Skip,
        AllowTrailingCommas = true,
        NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString,
        ReferenceHandler = null,
        TypeInfoResolver = new DefaultJsonTypeInfoResolver
        {
            Modifiers = { TypeResolvers.GetBudgetsTypeResolvers() }
        }
    };

    options.Converters.Add(new JsonStringEnumConverter());
    options.Converters.Add(new IsoDateTimeJsonConverter());
    options.Converters.Add(new IsoDateTimeOffsetJsonConverter());

    return options;
});
services.TryAddSingleton<IRestService, RestService>();

RestService

public partial class RestService : BaseRestService, IRestService
{
    /// <summary>
    /// Default constructor.
    /// </summary>
    /// <param name="context"></param>
    /// <param name="authenticationService"></param>
    /// <param name="languageService"></param>
    /// <param name="exceptionHandlerService"></param>
    /// <param name="configurationOptions"></param>
    public RestService(
        IContext context,
        IAuthenticationService authenticationService,
        ILanguageService languageService,
        IExceptionHandlerService exceptionHandlerService,
        JsonSerializerOptions jsonSerializerOptions,
        IOptions<ConfigurationOptions> configurationOptions)
        : base(context, authenticationService, languageService, exceptionHandlerService, jsonSerializerOptions, configurationOptions)
    {
    }

    /// <summary>
    /// Gets the budget by identifier asynchronous.
    /// </summary>
    /// <param name="id">The identifier.</param>
    /// <param name="cancellationToken">The cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    /// <returns>Task&lt;Budget&gt;.</returns>
    public Task<IBudget> GetBudgetByIdAsync(Guid id, CancellationToken cancellationToken = default) =>
        GetAsync<IBudget>($"{_configurationOptions.ServiceEndpoint}/{ControllerNames.Budgets}/{id}", cancellationToken: cancellationToken);

    /// <summary>
    /// Adds the budget asynchronous.
    /// </summary>
    /// <param name="e">The e.</param>
    /// <param name="cancellationToken">The cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
    /// <returns>Task&lt;System.Int32&gt;.</returns>
    public Task<int> AddBudgetAsync(IBudget e, CancellationToken cancellationToken = default) =>
        PostAsync<int>($"{_configurationOptions.ServiceEndpoint}/{ControllerNames.Budgets}", e, cancellationToken: cancellationToken);

   ...
}