System.Text.Json polymorphic serialization

[NN---]

Newtonsoft.Json can serialize this successfully while System.Text.Json doesn't do it:

var la = new List<A> { new B() { I = 1, J = 2 } };
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(la));
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(la));

class A
{
    public int I { get; set; }
}

class B : A
{
    public int J { get; set; }
}

[{"J":2,"I":1}]
[{"I":1}]

There is a page describing how to work with polymorphic objects: https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/polymorphism?pivots=dotnet-7-0 .
However, it required writing down all possible types.

Newtonsoft.Json writes an object simply as dictionary thus making possible to write any type regardless the hierarachy.

I suggest adding an option either by options or by attribute allowing serializing polymorphic type the same way Newtonsoft.Json does.

var la = new List<A> { new B() { I = 1, J = 2 } };
// 1. using options
Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(la));
Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(la, 
  new JsonSerializerOptions {
     SerializePolymorphicTypes = true // Serialize polymorphic types
     SerializeAsObject = true // Alternative way by treating types as key-value objects which has the same result
  }));

// 2. using attribute
[JsonSerializePolymorphic] // Serialize derived types
class A
{
    public int I { get; set; }
}

class B : A
{
    public int J { get; set; }
}

[{"J":2,"I":1}]
[{"J":2,"I":1}]

Another option is to use TypeInfoResolver for detecting derived type:

Console.WriteLine(System.Text.Json.JsonSerializer.Serialize(la, 
  new JsonSerializerOptions {
     TypeInfoResolver = new PolymorphicTypeResolver()
  }));

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


        if (type.GetCustomAttribute<JsonPolymorphicAttribute>() is { } disc)
        {
            jsonTypeInfo.PolymorphismOptions = new JsonPolymorphismOptions
            {
                TypeDiscriminatorPropertyName = disc.TypeDiscriminatorPropertyName,
                IgnoreUnrecognizedTypeDiscriminators = true,
                UnknownDerivedTypeHandling = JsonUnknownDerivedTypeHandling.FailSerialization,
            };

            foreach (var d in Assembly.GetExecutingAssembly()
                .GetTypes()
                .Where(t => t.IsSubclassOf(type)))
            {
                jsonTypeInfo.PolymorphismOptions.DerivedTypes.Add(new JsonDerivedType( d));
            }
        }

        return jsonTypeInfo;
    }
}

Alternatively everything can be defined as object which is not so nice making your code dynamically typed.

var la = new List<object> { new B() { I = 1, J = 2 } };

Or serializing every object manually as key-value:

var sla = System.Text.Json.JsonSerializer.Serialize(la, new JsonSerializerOptions
{
    Converters = { new ObjectConverterFactory() },
});
Console.WriteLine(sla);

public class ObjectConverterFactory : JsonConverterFactory
{
    public override bool CanConvert(Type typeToConvert)
    {
        return !typeToConvert.IsPrimitive &&
            !typeToConvert.IsEnum &&
            typeToConvert.Assembly != typeof(object).Assembly;
    }

    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        return new ObjectConverter(options);
    }
}

public class ObjectConverter : JsonConverter<object>
{
    private readonly JsonSerializerOptions _options;

    public ObjectConverter(JsonSerializerOptions options)
    {
        _options = options;
    }

    public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        throw new NotImplementedException();
    }

    public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
    {
        Type type = value.GetType();

        writer.WriteStartObject();

        foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
        {
            if (pi.GetValue(value) is { } nonNullValue)
            {
                writer.WritePropertyName(pi.Name);
                writer.WriteRawValue(STJ.JsonSerializer.Serialize(nonNullValue, _options));
            }
        }

        writer.WriteEndObject();
    }
}

[LeaFrock]

IMO, the current design of STJ is a good balance on functionality and performance. All your examples are only based on easy(but rare, for me) usage and also a lot of reflection.
STJ is not designed to replace NTJ but to provide a more perf-friendly choice, especially for reflection-less scenes (AOT).

var la = new List<A> { new B() { I = 1, J = 2 } };

Well, if you have only one derived class B in this list, the linq OfType<T>() will help a lot.
But if you have several derived classes, for example,

var la = new List<A>
{
    new B() { I = 1, J = 2 },
    new C() { I = 1, J = 2, K = 3 },
    new D() { I = 1, J = 2, N = new F() { I = 1, X = 11, Y = 12 } }
};

do you often meet this requirement that you want a json-array whose elements aren't consistent? It's not common enough.

var la = new List<object> { new B() { I = 1, J = 2 } };

Does it look good? Is it what C# advocates for? It will definitely become an abuse if supported.

serializing every object manually as key-value:

You have already been able to achieve this by JsonExtensionDataAttribute, which enable you to take a json-object as a dictionary.

[NN---]

STJ is not designed to replace NTJ but to provide a more perf-friendly choice, especially for reflection-less scenes (AOT).

Oh, that's really unfortunate.
STJ has performance advantages which NTJ can probably never have without heavily changing the API.

I do not want to change everything to object or Dictionary<string, object.> and lose the whole type-safety.

I wouldn't mind adding an attribute on the member or a converter like mentioned above to allow dictionary-like behavior.