using System;

using Newtonsoft.Json;

using Newtonsoft.Json.Serialization;

using ValueOf;

using ConsoleDump;

using System.Collections.Generic;

using System.Reflection;    

using System.Linq;

using System.Runtime.CompilerServices;

public class Program

{

    public class UserInfo : ValueOf<(string name, (int age, string eyes, DOB dob) features), UserInfo> { }

    public class DOB : ValueOf<(int day, int month, int year), DOB> { }

​

        public static void Main()

    {

        var ur = UserInfo.From(("harry", (36, "blue", DOB.From((22, 12, 81)))));

        var ccr = new ValueTupleContractResolver();

​

        JsonConvert.SerializeObject(ur).Dump(); //outputs {"Value":{"Item1":"harry","Item2":{"Item1":36,"Item2":"blue","Item3":{"Value":{"Item1":22,"Item2":12,"Item3":81}}}}}

​

        var json = JsonConvert.SerializeObject(ur, new JsonSerializerSettings {  ContractResolver = ccr, Converters = { new ValueOfConverter()} });

​

        json.Dump(); //outputs {"name":"harry","features":{"age":36,"eyes":"blue","dob":{"day":22,"month":12,"year":81}}}

​

        var deserialized = JsonConvert.DeserializeObject<UserInfo>(json, new JsonSerializerSettings { ContractResolver = ccr, Converters = { new ValueOfConverter()} });

        deserialized.Dump(); //outputs a hydrated UserInfo 

    }

​

​

​

    public class ValueTupleContractResolver : DefaultContractResolver

    {

        Stack<Queue<string>> names = new Stack<Queue<String>>();

​

        protected override JsonContract CreateContract(Type objectType)

        {

            var jc = base.CreateContract(objectType);

            var tena = objectType.GetCustomAttributes().OfType<TupleElementNamesAttribute>().SingleOrDefault();

            if (tena != null){

                names.Push(new Queue<string>(tena.TransformNames));

            }

            return jc;

        }

        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)

        {

            var property = base.CreateProperty(member, memberSerialization);

​

            if (member.Name == "Value" && member.DeclaringType.IsConstructedGenericType && member.DeclaringType.GetGenericTypeDefinition() == typeof(ValueOf<,>))

            {

                property.Writable = true;

            }

            if (names.Count > 0){

                var q = names.Peek();

                var name = q.Dequeue();

                if (name != null)

                {

                    property.PropertyName = name;

​

                }

                if (q.Count == 0)

                    names.Pop();

            }

            return property;

        }

    }

​

​

    //This isn't strictly necessary, it's used to remove the Value property when serializing the ValueOf

    class ValueOfConverter : JsonConverter

    {

        public override bool CanConvert(Type objectType)

        {

            if (objectType.BaseType.IsGenericType)

                if (objectType.BaseType.GetGenericTypeDefinition() == typeof(ValueOf<,>))

                    return true;

            return false;

        }

​

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

        {

            var jt = Newtonsoft.Json.Linq.JToken.ReadFrom(reader);

            var valueType = objectType.BaseType.GetGenericArguments()[0];

            var value = jt.ToObject(valueType, serializer);

            var from = objectType.GetMethod("From", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);

            return from.Invoke(null, new[] { value});

        }

​

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

        {

            var innerValue = ((dynamic) value).Value;

            serializer.Serialize(writer, innerValue);

​

        }

    }

}