Does polymorphic serde work in System.Text.Json with source generation?

[aries-zhang]

Hi, I'm trying to turn on native AOT for my app which relies on polymorphic serialization/deserialization with System.Text.Json.

Before native AOT, we have a custom polimorphic type info resolver exactly like it mentioned in this doc: https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/polymorphism#configure-polymorphism-with-the-contract-model. Then

var options = new JsonSerializerOptions()
{
    ReferenceHandler = ReferenceHandler.IgnoreCycles,
    TypeInfoResolver = new PolymorphicTypeResolver(),
};
JsonSerializer.Deserialize<T>(msg, options);

With native AOT enabled, the Deserialize<TValue>(string, JsonSerializerOptions) overload is not trim compatible so I switched to using the Deserialize(string json, Type returnType, JsonSerializerContext context) overload, so instead of JsonSerializerOptions, I have a SourceGenerationContext class:

[JsonSerializable(typeof(IMessage))]
[JsonSerializable(typeof(MessageA))]
[JsonSerializable(typeof(MessageB))]
public partial class SourceGenerationContext : JsonSerializerContext
{
    public static readonly SourceGenerationContext Custom = new SourceGenerationContext(new JsonSerializerOptions(Default.Options)
    {
        ReferenceHandler = ReferenceHandler.IgnoreCycles,
        TypeInfoResolver = new PolymorphicTypeResolver(),
    });
}

public class PolymorphicTypeResolver : DefaultJsonTypeInfoResolver
{
    public override JsonTypeInfo GetTypeInfo(Type type, JsonSerializerOptions options)
    {
        JsonTypeInfo jsonTypeInfo = base.GetTypeInfo(type, options);

        Type basePointType = typeof(IMessage);
        if (jsonTypeInfo.Type == basePointType)
        {
            jsonTypeInfo.PolymorphismOptions = new JsonPolymorphismOptions
            {
                TypeDiscriminatorPropertyName = "$type",
                IgnoreUnrecognizedTypeDiscriminators = true,
                UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FailSerialization,
                DerivedTypes =
                {
                    new JsonDerivedType(typeof(MessageA), "A"),
                    new JsonDerivedType(typeof(MessageB), "B")
                }
            };
        }
        
        return jsonTypeInfo;
    }
}

Now, with JsonSerializer.Deserialize<T>(json, typeof(IMessage), SourceGenerationContext.Custom), it throws an exception System.NotSupportedException: 'Deserialization of interface or abstract types is not supported..

Does anyone know if the TypeInfoResolver configured for polymorphic deserialization works with source generation in System.Test.Json? or am I missing something?

[aries-zhang]

Found some discussions in this issue and tested it seems to work: #85884 (comment), as in, it does successfully serialize and deserialize in VS debugging mode with AOT enabled, however, when I attempted to publish the app I get the following errors:

So it looks like for polymorphic serde to work, we need to use the overloads with JsonSerializerOptions, but since all overloads with JsonSerializerOptions require dynamically access class members, they aren't AOT compatible. Does this mean polymorphic serde is not possible with native AOT in System.Text.Json?

[elgonzo]

I have never tried/seen "sneaking" a reflection-based resolver (DefaultJsonTypeInfoResolver is reflection-based) into the source-generated resolver (your JsonSerializerContext-derived class is the source-gen-based resolver). I wouldn't be surprised if the source-gen resolver simply ignores the TypeInfoResolver set in the options provided for its constructor and uses the JsonTypeInfos it itself produces, but i don't know.

However, i would suggest a different approach. I am not 100% sure if what i describe below is sufficient for making it work for AoT, or whether there are further pitfalls i didn't consider. But anyways, on with the show...

Instead of attempting to fall back onto a reflection-based resolver, modify the JsonTypeInfo's that are created by the JsonSerializerContext. This is done with the help of the WithAddedModifier extension method. (The code example in the comment you linked to uses a "precursor" of the WithAddedModifier method.)

You would basically transplant the logic of your PolymorphicTypeResolver.GetTypeInfo method into the modifier delegate provided to WithAddedModifier and apply it to an instance of SourceGenerationContext. The result/return value of ``WithAddedModifier` is the modified resolver.

[JsonSerializable(typeof(IMessage))]
[JsonSerializable(typeof(MessageA))]
[JsonSerializable(typeof(MessageB))]
public partial class SourceGenerationContext : JsonSerializerContext
{
    public static readonly IJsonTypeInfoResolver Custom = new SourceGenerationContext(
        new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.IgnoreCycles }
    ).WithAddedModifier(ModifyTypeInfos);
    
    
    static void ModifyTypeInfos(System.Text.Json.Serialization.Metadata.JsonTypeInfo typeInfo)
    {
        ... the logic from your original PolymorphicTypeResolver.GetTypeInfo method ...
    }
}

You would then acquire the desired JsonTypeInfo from this modified resolver and pass it to the (de)serialization method, e.g.:

JsonSerializer.Deserialize(
    json,
    SourceGenerationContext.Custom.GetTypeInfo(typeof(IMessage), JsonSerializationOptions.Default)
);

(Again, as said in the beginning, i am unsure if this will solve the problem 100%, but i guess it's worth a try...)

[aries-zhang]

Thanks @elgonzo , tested and works perfectly 👍