System.Text.Json Polymorphism Type Discriminator Does Not Support Subtypes Class Polymorphism

[bunnyi116]

Description

System.Text.Json Polymorphism Type Discriminator Does Not Support Subtypes Class Polymorphism

System.Text.Json Version

9.0.0-preview.3.24172.9

Test

var jsonText = """
    {"time":1713524900,"self_id":123456789,"post_type":"meta_event","meta_event_type":"lifecycle","sub_type":"connect"}
    """;


var eventBase = JsonSerializer.Deserialize<EventBase>(jsonText, options: new()
{
     AllowOutOfOrderMetadataProperties = true
});
Console.WriteLine(eventBase);

[JsonPolymorphic(TypeDiscriminatorPropertyName = "post_type")]
[JsonDerivedType(typeof(MetaEvent), "meta_event")]
// ......
public record EventBase
{
    [JsonPropertyName("time")]
    public long Time { get; init; }

    [JsonPropertyName("self_id")]
    public long SelfId { get; init; }

    [JsonPropertyName("post_type")]
    public virtual string PostType { get; init; } = "unknown";
}

[JsonPolymorphic(TypeDiscriminatorPropertyName = "meta_event_type")]
[JsonDerivedType(typeof(MetaLifecycleEvent), "lifecycle")]
// ......
public record MetaEvent : EventBase
{
    [JsonPropertyName("post_type")]
    public override string PostType { get; init; } = "meta_event";

    [JsonPropertyName("meta_event_type")]
    public virtual string MetaEventType { get; init; } = "unknown";
}

public record MetaLifecycleEvent : MetaEvent
{
    [JsonPropertyName("meta_event_type")]
    public override string MetaEventType { get; init; } = "lifecycle";

    [JsonPropertyName("sub_type")]
    public required string SubType { get; init; }
}

[eiriktsarpalis]

I tried running the reproduction and it seems to be working as expected, i.e. the discriminator "post_type" : "meta_event" is being mapped to an instance of type MetaEvent, when deserializing as EventBase. I'm not entirely sure what your expected behavior is in this case, but I have two remarks based on what I'm seeing:

1. The JsonDerivedType/JsonPolymorphic annotations on MetaEvent are not inherited by EventBase. These set up independent sets of configurations depending on whether you are calling Deserialize<EventBase> or Deserialize<MetaEvent>.
2. I see you are creating properties whose names match the type discriminator property name. I should note that this isn't supported, the run-time value of these properties (as set via the overrides) does not have any influence on what a payload deserializes to. This is solely guided by the attribute annotations.

Hope this helps.

[bunnyi116]

How should I deserialize into the MetaLifecycleEvent class?

EventBase is the base class for all events, MetaEvent is a broad category of events, with MetaLifecycleEvent belonging to the MetaEvent class, which in turn belongs to EventBase.

[bunnyi116]

I think that when serializing/deserializing, if a subclass specified, it should check whether the subclass has the JsonPolymorphic or JsonDerivedType attributes. If these attributes exist, the process should continue.

[eiriktsarpalis]

You would need to add a JsonDerivedType annotation for MetaLifecycleEvent in EventBase. If you're feeling fancy (and you're not working with Native AOT or trimmed applications) you can write a contract customizer that looks up the type hierarchy using reflection and automatically appends JsonDerivedAttribute annotations to the base.

I think that when serializing/deserializing, if a subclass specified, it should check whether the subclass has the JsonPolymorphic or JsonDerivedType attributes. If these attributes exist, the process should continue.

That might work when using reflection-based serialization, but it might not be possible using the source generator which needs to know the entire hierarchy at compile time. Therefore, it is not supported (though there are ways to achieve this via contract customization).

[bunnyi116]

I don't need AOT.

Could you help me write a simple example using custom contracts for my sample data? I'm not very familiar with it.

Also, I hope STJ can find a way to support AOT in the future.

[bunnyi116]

I attempted to use DefaultJsonTypeInfoResolver to override the behavior of GetTypeInfo for subtype recognition. However, serialization isn't correct. I suspect this is because the TypeDiscriminatorPropertyName returned by DerivedTypesResolver.GetTypeInfo is unique. During serialization, only one TypeDiscriminatorPropertyName can be obtained, resulting in the serialization of only one TypePropertyName.

Therefore, I believe there is room for improvement here. JsonPolymorphismOptions could be changed to List. This would allow for the presence of multiple JsonPolymorphismOptions during serialization, enabling the addition of multiple type attribute fields.

I think this improvement shouldn't be difficult to implement.

using OneBotNet.Test;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.Json.Serialization.Metadata;

var jsonSerializerOptions = new JsonSerializerOptions
{
    TypeInfoResolver = new DerivedTypesResolver(),
    AllowOutOfOrderMetadataProperties = true
};
var triangle = new Derived2(3);
var output = JsonSerializer.Serialize<BaseClass>(triangle, jsonSerializerOptions);
Console.WriteLine(output);  // {"type2":"Derived2","Data2":3}

var jsonText = """
    {"type1":"Derived1","type2":"Derived2","Data2":123}
    """;
var baseClass = JsonSerializer.Deserialize<BaseClass>(jsonText, jsonSerializerOptions);
Console.WriteLine(baseClass);   // Derived2 { Data2 = 123 }

public sealed class DerivedTypesResolver : DefaultJsonTypeInfoResolver
{
    public override JsonTypeInfo GetTypeInfo(Type type, JsonSerializerOptions options)
    {
        var baseInfo = base.GetTypeInfo(type, options);

        if (baseInfo.PolymorphismOptions is not { DerivedTypes: { } baseInfoTypes })
            return baseInfo;

        foreach (var derived in baseInfoTypes.ToArray())
            HandleType(derived, options, baseInfo.PolymorphismOptions, baseInfoTypes);

        return baseInfo;
    }

    private void HandleType(JsonDerivedType nextType, JsonSerializerOptions options, JsonPolymorphismOptions? polymorphismOptions, IList<JsonDerivedType> baseInfoTypes)
    {
        if (nextType.DerivedType.IsAbstract)
            baseInfoTypes.Remove(nextType);

        else if (!baseInfoTypes.Contains(nextType))
            baseInfoTypes.Add(nextType);

        var baseInfo = GetTypeInfo(nextType.DerivedType, options);

        if (baseInfo is not { PolymorphismOptions: { } derived })
            return;

        if (polymorphismOptions != null && baseInfo.PolymorphismOptions != null && baseInfo.PolymorphismOptions.TypeDiscriminatorPropertyName != null)
        {
            polymorphismOptions.TypeDiscriminatorPropertyName = baseInfo.PolymorphismOptions.TypeDiscriminatorPropertyName;
        }

        foreach (var next in derived.DerivedTypes)
            HandleType(next, options, baseInfo.PolymorphismOptions, baseInfoTypes);
    }
}

[JsonPolymorphic(TypeDiscriminatorPropertyName = "type1")]
[JsonDerivedType(typeof(Derived1), nameof(Derived1))]
abstract record BaseClass;

[JsonPolymorphic(TypeDiscriminatorPropertyName = "type2")]
[JsonDerivedType(typeof(Derived2), nameof(Derived2))]
abstract record Derived1 : BaseClass;
record Derived2(int Data2) : Derived1;

[bunnyi116]

Here's the code I'm referencing：#81236