[API Proposal]: Json多态类型处理器，未知类型处理建议

[bunnyi116]

这是官方的例子

https://learn.microsoft.com/zh-cn/dotnet/standard/serialization/system-text-json/polymorphism?pivots=dotnet-7-0

[JsonPolymorphic(
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToNearestAncestor)]
[JsonDerivedType(typeof(BasePoint))]
[JsonDerivedType(typeof(IPointWithTimeSeries))]
public interface IPoint { }

public interface IPointWithTimeSeries : IPoint { }

public class BasePoint : IPoint { }

public class BasePointWithTimeSeries : BasePoint, IPointWithTimeSeries { }

提议

官方例子中，处理未知类型时，UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType返回上一个派生类，我觉得这样处理不太友好，比如我有一个专门处理未知的派生类，那我所有派生类都得继承这个未知处理的类，属实有点麻烦，且命名不方便。

诺能自定义未知处理类，就可以直接指定该类型。

比如在原有的基础上新增一个布尔属性[JsonDerivedType(typeof(UnknownMessage), bool unknownDefaultHandler = true)] 当然这个未知处理类得是抽象或接口实现的派生类。或者添加新的Attribute，如：JsonDefaultDerivedAttribute，至于怎么命名看你们怎么取了。

API Proposal

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

namespace System.Text.Json.Serialization
{
    /// <summary>
    /// When placed on a type declaration, indicates that the specified subtype should be opted into polymorphic serialization.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
    public class JsonDerivedTypeAttribute : JsonAttribute
    {
        /// <summary>
        /// Initializes a new attribute with specified parameters.
        /// </summary>
        /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared based type.</param>
        public JsonDerivedTypeAttribute(Type derivedType)
        {
            DerivedType = derivedType;
        }

        /// <summary>
        /// Initializes a new attribute with specified parameters.
        /// </summary>
        /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
        /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
        public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminator)
        {
            DerivedType = derivedType;
            TypeDiscriminator = typeDiscriminator;
        }

        /// <summary>
        /// Initializes a new attribute with specified parameters.
        /// </summary>
        /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
        /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
        public JsonDerivedTypeAttribute(Type derivedType, int typeDiscriminator)
        {
            DerivedType = derivedType;
            TypeDiscriminator = typeDiscriminator;
        }


        public JsonDerivedTypeAttribute(Type derivedType, bool isDefaultHandler )
        {
            DerivedType = derivedType;
            TypeDiscriminator = typeDiscriminator;
IsDefaultHandler = isDefaultHandler ;
        }

        /// <summary>
        /// A derived type that should be supported in polymorphic serialization of the declared base type.
        /// </summary>
        public Type DerivedType { get; }

        /// <summary>
        /// The type discriminator identifier to be used for the serialization of the subtype.
        /// </summary>
        public object? TypeDiscriminator { get; }

        /// <summary>
        /// 是否默认处理
        /// </summary>
        public  bool  IsDefaultHandler { get; }

    }
}

API Usage

[JsonPolymorphic(TypeDiscriminatorPropertyName = "type"]
[JsonDerivedType(typeof(UnknownMessage) , true)]
public abstract record Message
{    
    [JsonPropertyName("type")]
    public required string RawType { get; init; }
}

public record UnknownMessage : Message
{    
......
}

Alternative Designs

No response

Risks

No response

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[bunnyi116]

希望能直接定义未知类型处理派生类

[huoyaoyuan]

Native translation:

This is the official example:
[pic]
In the official example, when handling unknown type, UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType returns its base type, which looks unfriendly to me. For example I have a base class that handles unknown types, all my classes needs to derive from that class, which is bothersome and hard to name.

If unknown type handler can be customized, I can specify that class directly.

For example, adding a new bool property on the original attribute [JsonDerivedType(typeof(UnknownMessage), bool unknownDefaultHandler = true)]. Of course the unknown handling type needs to be abstract or interface-implementing derived class. The attribute design and naming are up to you.

Tagging subscribers to this area: @dotnet/area-system-text-json, @gregsdennis
See info in area-owners.md if you want to be subscribed.

Issue Details

---

这是官方的例子

https://learn.microsoft.com/zh-cn/dotnet/standard/serialization/system-text-json/polymorphism?pivots=dotnet-7-0

[JsonPolymorphic(
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToNearestAncestor)]
[JsonDerivedType(typeof(BasePoint))]
[JsonDerivedType(typeof(IPointWithTimeSeries))]
public interface IPoint { }

public interface IPointWithTimeSeries : IPoint { }

public class BasePoint : IPoint { }

public class BasePointWithTimeSeries : BasePoint, IPointWithTimeSeries { }

提议

官方例子中，处理未知类型时，UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToBaseType返回上一个派生类，我觉得这样处理不太友好，比如我有一个专门处理未知的派生类，那我所有派生类都得继承这个未知处理的类，属实有点麻烦，且命名不方便。

诺能自定义未知处理类，就可以直接指定该类型。

比如在原有的基础上新增一个布尔属性[JsonDerivedType(typeof(UnknownMessage), bool unknownDefaultHandler = true)] 当然这个未知处理类得是抽象或接口实现的派生类。或者添加新的Attribute，如：JsonDefaultDerivedAttribute，至于怎么命名看你们怎么取了。

API Proposal

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

namespace System.Text.Json.Serialization
{
    /// <summary>
    /// When placed on a type declaration, indicates that the specified subtype should be opted into polymorphic serialization.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
    public class JsonDerivedTypeAttribute : JsonAttribute
    {
        /// <summary>
        /// Initializes a new attribute with specified parameters.
        /// </summary>
        /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared based type.</param>
        public JsonDerivedTypeAttribute(Type derivedType)
        {
            DerivedType = derivedType;
        }

        /// <summary>
        /// Initializes a new attribute with specified parameters.
        /// </summary>
        /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
        /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
        public JsonDerivedTypeAttribute(Type derivedType, string typeDiscriminator)
        {
            DerivedType = derivedType;
            TypeDiscriminator = typeDiscriminator;
        }

        /// <summary>
        /// Initializes a new attribute with specified parameters.
        /// </summary>
        /// <param name="derivedType">A derived type that should be supported in polymorphic serialization of the declared base type.</param>
        /// <param name="typeDiscriminator">The type discriminator identifier to be used for the serialization of the subtype.</param>
        public JsonDerivedTypeAttribute(Type derivedType, int typeDiscriminator)
        {
            DerivedType = derivedType;
            TypeDiscriminator = typeDiscriminator;
        }


        public JsonDerivedTypeAttribute(Type derivedType, bool isDefaultHandler )
        {
            DerivedType = derivedType;
            TypeDiscriminator = typeDiscriminator;
IsDefaultHandler = isDefaultHandler ;
        }

        /// <summary>
        /// A derived type that should be supported in polymorphic serialization of the declared base type.
        /// </summary>
        public Type DerivedType { get; }

        /// <summary>
        /// The type discriminator identifier to be used for the serialization of the subtype.
        /// </summary>
        public object? TypeDiscriminator { get; }

        /// <summary>
        /// 是否默认处理
        /// </summary>
        public  bool  IsDefaultHandler { get; }

    }
}

API Usage

[JsonPolymorphic(TypeDiscriminatorPropertyName = "type"]
[JsonDerivedType(typeof(UnknownMessage) , true)]
public abstract record Message
{    
    [JsonPropertyName("type")]
    public required string RawType { get; init; }
}

public record UnknownMessage : Message
{    
......
}

Alternative Designs

No response

Risks

No response

Author:	Bunnui
Assignees:	-
Labels:	api-suggestion, area-System.Text.Json, untriaged
Milestone:	-

[eiriktsarpalis]

Note that UnknownDerivedTypeHandling only controls serialization behavior. Your screenshot suggests you're trying to deserialize, so you might want turn on the IgnoreUnrecognizedTypeDiscriminators property instead.

[bunnyi116]

Note that UnknownDerivedTypeHandling only controls serialization behavior. Your screenshot suggests you're trying to deserialize, so you might want turn on the IgnoreUnrecognizedTypeDiscriminators property instead.

Approximate structure

No unknown type

Unknown type

Other

Although it can catch exceptions and solve them, I hope it can handle them by default

Code block

/// <summary>
/// 消息
/// </summary>
[JsonPolymorphic(TypeDiscriminatorPropertyName = "type",
    UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FallBackToNearestAncestor,
    IgnoreUnrecognizedTypeDiscriminators = true)]
[JsonDerivedType(typeof(UnknownMessage))]
[JsonDerivedType(typeof(SourceMessage), "Source")]
[JsonDerivedType(typeof(QuoteMessage), "Quote")]
// ......
public abstract record Message
{
    /// <summary>
    /// 消息类型（原始）
    /// </summary>
    [JsonPropertyName("type")]
    public required string TypeString { get; init; }

    /// <summary>
    /// 消息类型
    /// </summary>
    [JsonIgnore]
    public MessageType Type
    {
        get
        {
            if (Enum.TryParse<MessageType>(TypeString, true, out var type))
            {
                return type;
            }
            return MessageType.Unknown;
        }
    }
    
    /// <summary>
    /// 构造函数
    /// </summary>
    [SetsRequiredMembers]
    public Message()
    {
        TypeString = MessageType.Unknown.GetEnumName();
    }
    
    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="typeString">消息类型</param>
    [JsonConstructor]
    [SetsRequiredMembers]
    public Message(string typeString)
    {
        TypeString = typeString;
    }
    
    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="messageType">消息类型</param>
    [SetsRequiredMembers]
    public Message(MessageType messageType) : this(messageType.GetEnumName())
    {
    }
}

public record UnknownMessage : Message
{

    [JsonConstructor]
    [SetsRequiredMembers]
    public UnknownMessage() : base(MessageType.Unknown.GetEnumName())
    {
    }
    
    [SetsRequiredMembers]
    public UnknownMessage(string typeString) : base(typeString)
    {
    }
    
    protected override bool PrintMembers(StringBuilder builder)
    {
        base.PrintMembers(builder);
    
        var sb = new StringBuilder();
        //if (RawData != null)
        //{
        //    sb.Append(", ");
        //    sb.Append($"{nameof(RawData)} = {RawData}");
        //}
    
        var append = sb.ToString();
        if (base.PrintMembers(builder))
        {
            if (append.Length > 0)
            {
                builder.Append(append.TrimStart(',', ' '));
            }
        }
        else
        {
            if (append.Length > 0)
            {
                builder.Append(append);
            }
        }
        return true;
    }
}

Error

Deserialization of types without a parameterless constructor, a singular parameterized constructor, or a parameterized constructor annotated with 'JsonConstructorAttribute' is not supported. Type 'MiraiNet.Models.Datas.Messages.Message'. Path: $[19] | LineNumber: 115 | BytePositionInLine: 11.

[bunnyi116]

[eiriktsarpalis]

The exception message occurs because your Message record is abstract, and therefore does not support deserialization. When enabling IgnoreUnrecognizedTypeDiscriminators I you would generally speaking need a base type that is deserializable. You can do that either by removing the abstract keyword from message, or alternatively use contract customization to manually set the CreateObject delegate so that it initializes an instance of Message that suits your use case.