System.Text.Json polymorphism strange behaviour?

[nsoderberg]

I ran into a, what I find, strange behaviour using System.Text.Json to serialize a class hierarchy. I'd like to understand what's going on, so would be grateful if anyone could explain it to me. Running the following code (full repro) fails on the second assert, but not the first. In the second case the object gets serialized without type discriminator, and hence gets deserialized to the base object. However, if I add a JsonDerivedType attribute to the subclass the second assert passes as well.

So why are the results different to begin with? Why does the JsonDerivedType make a difference in the second case, and should it be needed? Am I missing something basic here?

Thanks in advance!

Running .Net 8.

using System.Diagnostics;
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace SerializationLab;

[JsonDerivedType(derivedType: typeof(InventoryPurchase), typeDiscriminator: nameof(InventoryPurchase))]
public class TransactionType
{
    public class Purchase
    {
        public static InventoryPurchase Inventory = new();
    }
}

// Add this and the assertion passes
//[JsonDerivedType(derivedType: typeof(InventoryPurchase), typeDiscriminator: nameof(InventoryPurchase))]
public class InventoryPurchase : TransactionType;

internal class Program
{
    public static void Main(string[] args)
    {
        var t1 = typeof(TransactionType.Purchase).GetField("Inventory", BindingFlags.Public | BindingFlags.Static)?.GetValue(null);
        var s1 = JsonSerializer.Serialize(t1);
        var d1 = JsonSerializer.Deserialize<TransactionType>(s1);
        Debug.Assert(d1?.GetType().FullName == t1.GetType().FullName);

        var t2 = TransactionType.Purchase.Inventory;
        var s2 = JsonSerializer.Serialize(t2);
        var d2 = JsonSerializer.Deserialize<TransactionType>(s2);
        Debug.Assert(d2?.GetType().FullName == t2.GetType().FullName);
    }
}

[elgonzo]

So why are the results different to begin with?

The reason is the different type of the serialized variables t1 (object) and t2 (InventoryPurchase). Per the polymorphic serialization guide at https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/polymorphism:

Important

For polymorphic serialization to work, the type of the serialized value should be that of the polymorphic base type. This includes using the base type as the generic type parameter when serializing root-level values, as the declared type of serialized properties, or as the collection element in serialized collections.

In your second case,

var s2 = JsonSerializer.Serialize(t2);

infers InventoryPurchase to be the type of the value being serialized and not the polymorphic base type TransactionType. Therefore, if you replace it with

var s2 = JsonSerializer.Serialize<TransactionType>(t2);

(which explicitly serializes t2 as the base type TransactionType), then the second assert should pass.

Or use object as the serialized type:

var s2 = JsonSerializer.Serialize<object>(t2);

Alternatively, you could also change

var t2 = TransactionType.Purchase.Inventory;

to either

TransactionType t2 = TransactionType.Purchase.Inventory;

or

object t2 = TransactionType.Purchase.Inventory;

and the second assert should also pass.

And the other way around, you could make the first assert fail by replacing

var s1 = JsonSerializer.Serialize(t1);

with

var s1 = JsonSerializer.Serialize((InventoryPurchase) t1);

Note that serializing a variable of type object is handled in a special way here. I unfortunately don't know if and where this is being documented, sadly :-( Serializing t1 (which is of type object) and the above code using object is working despite object not being a "polymorphic base type" of TransactionType and lacking STJ-related attribute metadata. It works due to the special treatment of the object type by STJ. This can be demonstrated by placing a base class in the inheritance hierarchy between the TransactionType type and the implied object type:

public class Base { }

[JsonDerivedType(derivedType: typeof(InventoryPurchase), typeDiscriminator: nameof(InventoryPurchase))]
public class TransactionType : Base
{
    ...

This makes Base a base type for TransactionType without any serialization-related attribute metadata (like object has been the base type for TransactionType before). Attempting to serialize using the t2 as a Base value like:

var s2 = JsonSerializer.Serialize<Base>(t2);

will (unlike when using object) result in a json without type discriminator and the second assert will fail.

Why does the JsonDerivedType make a difference in the second case

In my opinion, this seems to be STJ checking for the respective attributes on the type of the value passed to the (generic) Serialize method to determine whether polymorphic serialization with type discriminators should be used or not.

[nsoderberg]

Many thanks for the detailed explanations! Made me quite a bit wiser about the ins and outs of serialization. Thank you!