using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Reflection;

using Newtonsoft.Json;

using Newtonsoft.Json.Serialization;

public class Program

{

    public static void Main()

    {

        A a = new A("a", "b");

        B b = new B(a, "c");

        var d = new Dictionary<B, B>()

        {

            {b, b}

        };

        string fileName = "lol.txt";

        JsonSerializerSettings settings = new JsonSerializerSettings

        {

            Formatting = Formatting.Indented,

            ContractResolver = new MyContractResolver()

        };

        JsonSerializer js = JsonSerializer.Create(settings);

        js.Converters.Add(new MyDConverter<B, B, int>(new BKeyGetter(), new BObjGetter()));

        Console.WriteLine("---- serialize ----");

        using(var stream = File.Create(fileName))

        using(var sw = new StreamWriter(stream))

        {

            js.Serialize(sw, d);

        }

        var json = File.ReadAllText(fileName);

        Console.WriteLine(json);

        Dictionary<B, B> d2;

        Console.WriteLine("---- deserialize ----");

        using(var stream = File.OpenRead(fileName))

        using(var sr = new StreamReader(stream))

        {

            d2 = (Dictionary<B, B>)js.Deserialize(sr, typeof(Dictionary<B, B>));

        }

        Console.WriteLine(d2[b].A.a);

        Console.WriteLine(d2[b].A.b);

        Console.WriteLine(d2[b].c);

    }

}

​

public interface KeyGetter<in TKey>

{

    string GetKey(TKey k);

}

public interface ObjGetter<out TKey>

{

    TKey GetObject(string s);

}

​

public class AKeyGetter : KeyGetter<A>

{

    const string Delimiter = "::";

    public string GetKey(A a)

    {

        return string.Join(Delimiter, new string[]{a.a, a.b});

    }

}

​

public class AObjGetter : ObjGetter<A>

{

    const string Delimiter = "::";

    public A GetObject(string s)

    {

        var split = s.Split(new string[]{Delimiter}, StringSplitOptions.None);

        var a = split[0];

        var b = split[1];

        return new A(a, b);

    }

}

​

public class BKeyGetter : KeyGetter<B>

{

    private static readonly AKeyGetter aKeyGetter = new AKeyGetter();

    const string Delimiter = "::";

    public string GetKey(B b)

    {

        return string.Join(Delimiter, new string[]{aKeyGetter.GetKey(b.A), b.c});

    }   

}

​

public class BObjGetter : ObjGetter<B>

{

    private static readonly AObjGetter aObjGetter = new AObjGetter();

    const string Delimiter = "::";

    public B GetObject(string b)

    {

        var split = b.Split(new string[]{Delimiter}, StringSplitOptions.None);

        var c = split[2];

        var a = aObjGetter.GetObject(b);

        return new B(a, c);

    }

}

​

public class A

{

    internal readonly string a;

    internal readonly string b;

    public A(string a, string b)

    {

        this.a = a;

        this.b = b;

    }

}

​

public class B

{

    internal readonly string c;

    internal readonly A A;

    public B(A a, string c)

    {

        this.c = c;

        this.A = a;

    }

}

​

// this is from somewhere else but I lost the reference :-(.

public class MyContractResolver : Newtonsoft.Json.Serialization.DefaultContractResolver

{

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)

    {

        var props = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)

                        .Select(p => base.CreateProperty(p, memberSerialization))

                    .Union(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)

                               .Select(f => base.CreateProperty(f, memberSerialization)))

                    .ToList();

        props.ForEach(p => { p.Writable = true; p.Readable = true; });

        return props;

    }

}

​

public class MyDConverter<TKey, TValue, TOrderingKey> : JsonConverter

    {

        private readonly Func<KeyValuePair<TKey, TValue>, TOrderingKey> orderByFunction;

        private readonly KeyGetter<TKey> keyGetter;

        private readonly ObjGetter<TKey> objGetter;

        public readonly bool OrderByDescending;

        private readonly bool ConvertIntsToInt32;

​

        public MyDConverter(

            KeyGetter<TKey> keyGetter,

            ObjGetter<TKey> objGetter,

            Func<KeyValuePair<TKey, TValue>, TOrderingKey> orderByFunction = null,

            bool orderByDescending = true,

            bool convertIntsToInt32 = false)

            : base()

        {

            var keyType = typeof(TKey);

            if (keyType.IsAbstract)

            {

                throw new NotSupportedException("can't instantiate abstract class");

            }

            if (keyType.IsInterface)

            {

                throw new NotSupportedException("can't instantiate interface");

            }

            this.keyGetter = keyGetter;

            this.objGetter = objGetter;

            this.orderByFunction = orderByFunction;

            this.OrderByDescending = orderByDescending;

            this.ConvertIntsToInt32 = convertIntsToInt32;

        }

​

        public override bool CanConvert(Type objectType)

        {

            if (typeof(IDictionary<TKey, TValue>).IsAssignableFrom(objectType))

            {

                return true;

            }

            return false;

        }

​

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

        {

            Dictionary<TKey, TValue> dict = (Dictionary<TKey, TValue>)existingValue ?? new Dictionary<TKey, TValue>();

​

            string currentKeyAsString;

            TKey key;

​

            while (reader.Read())

            {

                switch (reader.TokenType)

                {

                    case JsonToken.PropertyName:

                        currentKeyAsString = (string)reader.Value;

                        key = this.objGetter.GetObject( currentKeyAsString );

​

                        reader.Read();

                        TValue value;

                        if (reader.TokenType == JsonToken.StartObject)

                        {

                            value = js.Deserialize<TValue>(reader);

                        }

                        else

                        {

                            if (reader.TokenType == JsonToken.Integer)

                            {

                                if (this.ConvertIntsToInt32)

                                {

                                    value = (TValue)Convert.ChangeType(Convert.ToInt32((Int64)reader.Value), typeof(TValue));

                                }

                                else

                                {

                                    value = (TValue)reader.Value;

                                }

                            }

                            else

                            {

                                throw new NotImplementedException();

                            }

                        }

                        dict.Add(key, value);

​

                        break;

                    case JsonToken.Comment:

                        break;

                    case JsonToken.EndObject:

                        return dict;

                    default:

                        throw new InvalidOperationException();

                }

            }

​

            return dict;

        }

​

        public override void WriteJson(JsonWriter jw, object value, JsonSerializer js)

        {

            var dict = (IDictionary<TKey, TValue>)value;

            jw.WriteStartObject();

​

            IEnumerable<KeyValuePair<TKey, TValue>> orderedKvps = null;

            if (orderByFunction == null)

            {

                orderedKvps = dict.AsEnumerable();

            }

            else

            {

                orderedKvps = this.OrderByDescending ? dict.OrderByDescending(this.orderByFunction) : dict.OrderBy(this.orderByFunction);

            }

            foreach (var kvp in orderedKvps)

            {

                var keyAsString = this.keyGetter.GetKey(kvp.Key);

                jw.WritePropertyName(keyAsString);

​

                js.Serialize(jw, kvp.Value);

            }

​

            jw.WriteEndObject();

        }

    }