Usage-specific serialization for complex type in D

Question

I have a class

public class MyValue 
{
    public String Prop1 { get; set; }
    public String Prop2 { get; set; }
}

which I am both using as a type for a normal Property as well as a Dictionary key.

What I need is a way so that when this class is used as a Property, it is serialized as

{"Prop1":"foo","Prop2":"bar"}

but when it is used as a Dictionary key, it is serialized in a way that JSON.Net is able to deserialize it properly.

When adding a ToString() method to MyValue, I am able to create a text representation (non-JSON) that allows the usage as Dictionary key but unfortunately, I am not able to deserialize it afterwards. Even adding a JsonConverter for MyValue did not help because it seems to be unable to handle non-JSON as source format (and additionally, when serialized as a property, it IS json, so the converter would need to handle both somehow).

Answer 1

What you could do is serialize and deserialize your dictionary in a proxy KeyValuePair<string, string> array, like so:

[DataContract]
public class MyContainer
{
    public MyContainer() {
        this.Dictionary = new Dictionary<MyValue, int>();
    }

    [DataMember]
    public MyValue MyValue { get; set; }

    [IgnoreDataMember]
    public Dictionary<MyValue, int> Dictionary { get; set; }

    [DataMember(Name="Dictionary")]
    private KeyValuePair<MyValue, int> [] SerializedDictionary
    {
        get
        {
            if (Dictionary == null)
                return null;
            return Dictionary.ToArray();
        }
        set
        {
            if (value == null)
            {
                Dictionary = null;
            }
            else
            {
                Dictionary = value.ToDictionary(pair => pair.Key, pair => pair.Value);
            }
        }
    }
}

(Here I'm using the DataContract attributes, but I could just as easily have used [JsonIgnore] and [JsonProperty("Dictionary")])

So, to test this (and assuming that you have properly overridden GetHashCode() and Equals() on MyValue, which you need to do in order to use it as a dictionary key), I did the following:

public static class TestDictionaryJson
{
    public static void Test()
    {
        var dict = new Dictionary<MyValue, int>();
        dict[(new MyValue("A", "A"))] = 1;
        dict[(new MyValue("B", "B"))] = 2;

        var myContainer = new MyContainer() { MyValue = new MyValue("A Property", "At the top level"), Dictionary = dict };

        var json = JsonConvert.SerializeObject(myContainer, Formatting.Indented);

        Debug.WriteLine(json);

        try
        {
            var newContainer = JsonConvert.DeserializeObject<MyContainer>(json);
        }
        catch (Exception ex)
        {
            Debug.Assert(false, ex.ToString()); // No assert - no exception is thrown.
        }

        try
        {
            var dictjson = JsonConvert.SerializeObject(dict, Formatting.Indented);
            Debug.WriteLine(dictjson);
            var newDict = JsonConvert.DeserializeObject<Dictionary<MyValue, int>>(dictjson);
        }
        catch (Exception ex)
        {
            Debug.WriteLine("Caught expected exception deserializing dictionary directly: " + ex.ToString());
        }
    }
}

Sure enough, there was no exception deserializing the container, but there was deserializing the dictionary directly. And the following JSON was created for the container:

{
  "MyValue": {
    "Prop1": "A Property",
    "Prop2": "At the top level"
  },
  "Dictionary": [
    {
      "Key": {
        "Prop1": "A",
        "Prop2": "A"
      },
      "Value": 1
    },
    {
      "Key": {
        "Prop1": "B",
        "Prop2": "B"
      },
      "Value": 2
    }
  ]
}

Is that what you want?

Update

Or, if you don't like the proxy arrays, you could apply the following JsonConverterAttribute to each and every Dictionary property to get the same result:

public class MyContainer
{
    public MyContainer()
    {
        this.Dictionary = new Dictionary<MyValue, int>();
    }

    public MyValue MyValue { get; set; }

    [JsonConverter(typeof(DictionaryToArrayConverter<MyValue, int>))]
    public Dictionary<MyValue, int> Dictionary { get; set; }
}

public class DictionaryToArrayConverter<TKey, TValue> : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Dictionary<TKey, TValue>);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        KeyValuePair<TKey, TValue>[] pairs;

        JToken token = JToken.Load(reader);
        if (token.Type == JTokenType.Array)
        {
            pairs = token.ToObject<KeyValuePair<TKey, TValue>[]>(serializer);
        }
        else
        {
            JArray array = new JArray();
            array.Add(token);
            pairs = token.ToObject<KeyValuePair<TKey, TValue>[]>(serializer);
        }
        if (pairs == null)
            return null;
        return pairs.ToDictionary(pair => pair.Key, pair => pair.Value);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value == null)
            return;
        var pairs = ((IDictionary<TKey, TValue>)value).ToArray();
        serializer.Serialize(writer, pairs);
    }
}

Update

As an alternative, you could seal your MyValue class and attach an appropriate TypeConverterAttribute for converting from & to a string. JSON.Net will pick this up and use it both for dictionary keys and properties. This solution is simpler in that it's a global solution so you don't need to use proxy arrays or converter properties for each and every dictionary, however the JSON created for your MyValue properties isn't quite what you require.

Thus:

public class MyValueConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context,
       Type sourceType)
    {
        if (sourceType == typeof(string))
        {
            return true;
        }
        return base.CanConvertFrom(context, sourceType);
    }

    public override object ConvertFrom(ITypeDescriptorContext context,
       CultureInfo culture, object value)
    {
        if (value is string)
        {
            // Cannot do JsonConvert.DeserializeObject here because it will cause a stackoverflow exception.
            using (var reader = new JsonTextReader(new StringReader((string)value)))
            {
                JObject item = JObject.Load(reader);
                if (item == null)
                    return null;
                MyValue myValue = new MyValue();
                var prop1 = item["Prop1"];
                if (prop1 != null)
                    myValue.Prop1 = prop1.ToString();
                var prop2 = item["Prop2"];
                if (prop2 != null)
                    myValue.Prop2 = prop2.ToString();
                return myValue;
            }
        }
        return base.ConvertFrom(context, culture, value);
    }

    public override object ConvertTo(ITypeDescriptorContext context,
       CultureInfo culture, object value, Type destinationType)
    {
        if (destinationType == typeof(string))
        {
            MyValue myValue = (MyValue)value;

            // Cannot do JsonConvert.SerializeObject here because it will cause a stackoverflow exception.
            StringBuilder sb = new StringBuilder();
            using (StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture))
            using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
            {
                jsonWriter.WriteStartObject();
                jsonWriter.WritePropertyName("Prop1");
                jsonWriter.WriteValue(myValue.Prop1);
                jsonWriter.WritePropertyName("Prop2");
                jsonWriter.WriteValue(myValue.Prop2);
                jsonWriter.WriteEndObject();

                return sw.ToString();
            }
        }
        return base.ConvertTo(context, culture, value, destinationType);
    }
}

[TypeConverter(typeof(MyValueConverter))]
public class MyValue
{
    public MyValue()
    {
    }

    public MyValue(string prop1, string prop2)
    {
        this.Prop1 = prop1;
        this.Prop2 = prop2;
    }

    public String Prop1 { get; set; }
    public String Prop2 { get; set; }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(this, obj))
            return true;
        else if (ReferenceEquals(obj, null))
            return false;
        if (GetType() != obj.GetType())
            return false;
        var other = (MyValue)obj;
        return Prop1 == other.Prop1 && Prop2 == other.Prop2;
    }

    public override int GetHashCode()
    {
        unchecked
        {
            uint code = 0;
            if (Prop1 != null)
                code ^= (uint)Prop1.GetHashCode();
            code = (code << 16) | (code >> 16);
            if (Prop2 != null)
                code ^= (uint)Prop2.GetHashCode();
            return (int)code;
        }
    }

    public override string ToString()
    {
        return TypeDescriptor.GetConverter(GetType()).ConvertToString(this);
    }

    public static bool operator ==(MyValue first, MyValue second)
    {
        if (ReferenceEquals(first, null))
            return ReferenceEquals(second, null);
        return first.Equals(second);
    }

    public static bool operator !=(MyValue first, MyValue second)
    {
        return !(first == second);
    }
}

Properties and dictionaries using this class can now be serialized without the use of any proxy arrays. For instance, serializing and deserializing the following:

public class MyContainer
{
    public MyContainer()
    {
        this.Dictionary = new Dictionary<MyValue, int>();
    }

    public MyValue MyValue { get; set; }

    public Dictionary<MyValue, int> Dictionary { get; set; }
}

Gives the following JSON when serialized:

{
  "MyValue": "{\"Prop1\":\"A Property\",\"Prop2\":\"At the top level\"}",
  "Dictionary": {
    "{\"Prop1\":\"A\",\"Prop2\":\"A\"}": 1,
    "{\"Prop1\":\"B\",\"Prop2\":\"B\"}": 2
  }
}

(the quotes are escaped since they are embedded in the JSON, not part of the JSON.)

Late Update - creating a generic TypeConverter for dictionary keys

It's possible to create a generic TypeConverter that works for any generically specified type by using an appropriate contract resolver:

public class NoTypeConverterContractResolver : DefaultContractResolver
{
    readonly Type type;

    public NoTypeConverterContractResolver(Type type)
        : base()
    {
        if (type == null)
            throw new ArgumentNullException();
        if (type == typeof(string) || type.IsPrimitive)
            throw new ArgumentException("type == typeof(string) || type.IsPrimitive");
        this.type = type;
    }

    protected override JsonContract CreateContract(Type objectType)
    {
        if (type.IsAssignableFrom(objectType))
        {
            // Replaces JsonStringContract for the specified type.
            var contract = this.CreateObjectContract(objectType);
            return contract;
        }
        return base.CreateContract(objectType);
    }
}

public class GenericJsonTypeConverter<T> : TypeConverter
{
    // As of 7.0.1, Json.NET suggests using a static instance for "stateless" contract resolvers, for performance reasons.
    // http://www.newtonsoft.com/json/help/html/ContractResolver.htm
    // http://www.newtonsoft.com/json/help/html/M_Newtonsoft_Json_Serialization_DefaultContractResolver__ctor_1.htm
    // "Use the parameterless constructor and cache instances of the contract resolver within your application for optimal performance."
    static NoTypeConverterContractResolver contractResolver;

    static NoTypeConverterContractResolver ContractResolver
    {
        get
        {
            if (contractResolver == null)
                Interlocked.CompareExchange(ref contractResolver, new NoTypeConverterContractResolver(typeof(T)), null);
            return contractResolver;
        }
    }

    public override bool CanConvertFrom(ITypeDescriptorContext context,
       Type sourceType)
    {
        if (sourceType == typeof(string))
        {
            return true;
        }
        return base.CanConvertFrom(context, sourceType);
    }

    public override object ConvertFrom(ITypeDescriptorContext context,
       CultureInfo culture, object value)
    {
        if (value is string)
        {
            using (var reader = new JsonTextReader(new StringReader((string)value)))
            {
                var obj = JsonSerializer.Create(new JsonSerializerSettings { ContractResolver = ContractResolver }).Deserialize<T>(reader);
                return obj;
            }
        }
        return base.ConvertFrom(context, culture, value);
    }

    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
    {
        if (destinationType == typeof(string))
        {
            StringBuilder sb = new StringBuilder();
            using (StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture))
            using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))
            {
                JsonSerializer.Create(new JsonSerializerSettings { ContractResolver = ContractResolver }).Serialize(jsonWriter, value);
            }
            return sb.ToString();
        }
        return base.ConvertTo(context, culture, value, destinationType);
    }
}

Then apply it to your class as follows:

[TypeConverter(typeof(GenericJsonTypeConverter<MyValue>))]
public class MyValue
{

}