// @nuget: Newtonsoft.Json

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;

​

// based on https://dotnetfiddle.net/smioqg

​

// answer for https://stackoverflow.com/questions/50985291/json-net-serialize-derived-as-generic-base

​

public abstract class LikeType<T>

{

    public T Value { get { return _value; } }

    protected readonly Type Type;

    private readonly T _value;

    private readonly bool _isValueNull;

    protected LikeType(T value, bool isNullAllowed = false)

    {

        _isValueNull = ReferenceEquals(value, null);

        if (_isValueNull && !isNullAllowed)

            throw new ArgumentNullException("value");

        _value = value;

        Type = GetType();

    }

}

​

class LikeTypeConverter : JsonConverter

{

    static Type GetValueType(Type objectType)

    {

        return objectType

            .BaseTypesAndSelf()

            .Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(LikeType<>))

            .Select(t => t.GetGenericArguments()[0])

            .FirstOrDefault();

    }

​

    public override bool CanConvert(Type objectType)

    {

        return GetValueType(objectType) != null;

    }

​

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

    {

        // You need to decide whether a null JSON token results in a null LikeType<T> or 

        // an allocated LikeType<T> with a null Value.

        if (reader.SkipComments().TokenType == JsonToken.Null)

            return null;

        var valueType = GetValueType(objectType);

        var value = serializer.Deserialize(reader, valueType);

​

        // Here we assume that every subclass of LikeType<T> has a constructor with a single argument, of type T.

        return Activator.CreateInstance(objectType, value);

    }

​

    const string ValuePropertyName = "Value";// nameof(LikeType<object>.Value); // in C#6+

​

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

    {

        var contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(value.GetType());

        var valueProperty = contract.Properties.Single(p => p.UnderlyingName == ValuePropertyName);

        serializer.Serialize(writer, valueProperty.ValueProvider.GetValue(value));

    }

}

​

public static partial class JsonExtensions

{

    public static JsonReader SkipComments(this JsonReader reader)

    {

        while (reader.TokenType == JsonToken.Comment && reader.Read())

        {

        }

​

        return reader;

    }

}

​

public static class TypeExtensions

{

    public static IEnumerable<Type> BaseTypesAndSelf(this Type type)

    {

        while (type != null)

        {

            yield return type;

            type = type.BaseType;

        }

    }

}

​

public class CustomerId : LikeType<Guid>

{

    public CustomerId(Guid value) : base(value) { }

}

​

public class EmailAddress : LikeType<string>

{

    public EmailAddress(string value) : base(value) { }

}

​

public class Customer

{

    public CustomerId Id { get; private set; }

    public EmailAddress Email { get; private set; }

​

    public Customer(CustomerId id, EmailAddress email)

    {

        Id = id;

        Email = email;

    }

}

​

class TestClass

{

    public static void Test()

    {

        var desiredJson = @"{""id"": ""f5ce21a5-a0d1-4888-8d22-6f484794ac7c"",""email"": ""some@email.com""}";

​

        var customer = new Customer(new CustomerId(new Guid("f5ce21a5-a0d1-4888-8d22-6f484794ac7c")), new EmailAddress("some@email.com"));

​

        var settings = new JsonSerializerSettings

        {

            Converters = { new LikeTypeConverter() },

            ContractResolver = new CamelCasePropertyNamesContractResolver()

        };

        var customerAsJson = JsonConvert.SerializeObject(customer, Formatting.Indented, settings);

​

        Console.WriteLine("Serialized {0}:", customer);

        Console.WriteLine(customerAsJson);

​

        Assert.IsTrue(JToken.DeepEquals(JToken.Parse(customerAsJson), JToken.Parse(desiredJson)));

​

        var customer2 = JsonConvert.DeserializeObject<Customer>(customerAsJson, settings);

​

        Assert.IsTrue(customer.Email.Value == customer2.Email.Value && customer.Id.Value == customer2.Id.Value);

    }

}

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Environment version: " + Environment.Version);

        Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

        Console.WriteLine();

​

        try

        {

            TestClass.Test();

        }

        catch (Exception ex)

        {

            Console.WriteLine("Failed with unhandled exception: ");

            Console.WriteLine(ex);

            throw;

        }

    }

}

​

public class AssertionFailedException : System.Exception

{

    public AssertionFailedException(string s) : base(s) { }

}

​

public static class Assert

{

    public static void IsTrue(bool value)

    {

        IsTrue(value, "failed");

    }

​

    public static void IsTrue(bool value, string message)

    {

        if (value == false)

            throw new AssertionFailedException(message ?? "failed");

    }

}

​