using System;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        Foo foo = new([

            new Bar1(50), 

            new Bar2("Hello")

        ]);

        var json = foo.SerializeOld();

        Console.WriteLine(json);

        var obj = json.Deserialize<Foo>();

        foreach(IBar bar in obj.Bars)

        {

            Console.WriteLine(bar.GetValueAsString());

        }

    }

}

​

public static class SerializationExtensions

{

    public static string SerializeOld<T>(this T source)

    {

        var json = ServiceStack.Text.JsonSerializer.SerializeToString(source, typeof(T));

        return json;

        //"Bars":[{"__type":"Bar1, kj0phhin.exe","Value":50},{"__type":"Bar2, kj0phhin.exe","Value":"Hello"}]}

    }

    public static string Serialize<T>(this T source)

    {

        var json = Newtonsoft.Json.JsonConvert.SerializeObject(source, new Newtonsoft.Json.JsonSerializerSettings {

            NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,

            TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto

        });

        return json;

        //{"Bars":[{"$type":"Bar1, l10qktxb.exe","Value":50},{"$type":"Bar2, l10qktxb.exe","Value":"Hello"}]}

    }

    /* Not working

    public static string Serialize<T>(this T source)

    {

        var json = System.Text.Json.JsonSerializer.Serialize(source, new System.Text.Json.JsonSerializerOptions

        {

            DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull,

            TypeInfoResolver = new PolymorphicTypeResolve()

        });

        return json;

    }

    */

    public static T Deserialize<T>(this string json)

    {

        json = json.AsNewtonsoftJsonCompatibleString();

        T output = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(json, new Newtonsoft.Json.JsonSerializerSettings {

            NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,

            TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto

        });

        /* Not working

        T output = System.Text.Json.JsonSerializer.Deserialize<T>(json, new System.Text.Json.JsonSerializerOptions

        {

            DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull,

            TypeInfoResolver = new PolymorphicTypeResolve()

        });

        */

        return output;

    }

    private static string AsNewtonsoftJsonCompatibleString(this string json)

    {

        if (!IsValidJson(json)) throw new ArgumentException("Not a valid JSON");

        //Adapt ServiceStack type handling attribute to be the same as Newtonsoft.Json

        json = json.Replace("__type", "$type");

        return json;

    }

    private static bool IsValidJson(string strInput)

    {

        if (string.IsNullOrWhiteSpace(strInput)) { return false; }

        strInput = strInput.Trim();

        if ((strInput.StartsWith("{") && strInput.EndsWith("}")) || //For object

            (strInput.StartsWith("[") && strInput.EndsWith("]"))) //For array

        {

            try

            {

                var obj = Newtonsoft.Json.Linq.JToken.Parse(strInput);

                return true;

            }

            catch (Newtonsoft.Json.JsonReaderException)

            {

                return false;

            }

            catch (Exception)

            {

                return false;

            }

        }

        else

        {

            return false;

        }

    }

}

​

public class PolymorphicTypeResolve : System.Text.Json.Serialization.Metadata.DefaultJsonTypeInfoResolver

{

    public override System.Text.Json.Serialization.Metadata.JsonTypeInfo GetTypeInfo(Type type, System.Text.Json.JsonSerializerOptions options)

    {

        System.Text.Json.Serialization.Metadata.JsonTypeInfo jsonTypeInfo = base.GetTypeInfo(type, options);

​

        Type basePointType = typeof(IBar);

        if (jsonTypeInfo.Type == basePointType)

        {

            jsonTypeInfo.PolymorphismOptions = new System.Text.Json.Serialization.Metadata.JsonPolymorphismOptions

            {

                TypeDiscriminatorPropertyName = "$type",

                IgnoreUnrecognizedTypeDiscriminators = true,

                UnknownDerivedTypeHandling = System.Text.Json.Serialization.JsonUnknownDerivedTypeHandling.FailSerialization,

                DerivedTypes =

                {

                    new System.Text.Json.Serialization.Metadata.JsonDerivedType(typeof(Bar1), $"{typeof(Bar1).Name}, {typeof(Bar1).Module}"),

                    new System.Text.Json.Serialization.Metadata.JsonDerivedType(typeof(Bar2), $"{typeof(Bar2).Name}, {typeof(Bar2).Module}")

                }

            };

        }

​

        return jsonTypeInfo;

    }

}

​

public class Foo

{

    public List<IBar> Bars { get; set; } = [];

    public Foo(List<IBar> bars)

    {

        if (bars is null) return;

        Bars = bars;

    }

}

​

public interface IBar

{

    string GetValueAsString();

}

​

public class Bar1 : IBar

{

    public int Value { get; set; }

    public Bar1()

    {

    }

    public Bar1(int val)

    {

        Value = val;

    }

    public string GetValueAsString()

    {

        return Value.ToString();

    }

}

​

public class Bar2 : IBar

{

    public string Value { get; set; }

​

    public Bar2()

    {

    }

​

    public Bar2(string val)

    {

        Value = string.IsNullOrWhiteSpace(val)

            ? "Default"

            : val;

    }

    public string GetValueAsString()

    {

        return Value;

    }

}

​

​