Not ableTo Serialize Dictionary with Complex key using Json.net

by

You probably don’t want to use the answer that Gordon Bean presented. The solution works, but it provides a serialized string for output. If you are using JSON, this will give you a less than ideal result, since you really want a JSON representation of an object and not a string representation.

for example, let’s suppose that you have a data structure that associates unique grid points with strings:

class Point
{
    public int x { get; set; }
    public int y { get; set; }
}

public Dictionary<Point,string> Locations { get; set; };

Using the TypeConverter override, you will get a string representation of this object when you serialize it.

"Locations": {
  "4,3": "foo",
  "3,4": "bar"
},

But what we really want is:

"Locations": {
  { "x": 4, "y": 3 }: "foo",
  { "x": 3, "y": 4 }: "bar"
},

There are several problems with overriding the TypeConverter to serialize / deserialize the class.

First, this is not JSON, and you might have to write additional custom logic to deal with serialize and deserialize it elsewhere. (perhaps Javascript in your client layer, for example?)

Second, Anywhere else that uses this object will now spew this string, where previously it serialized properly to an object:

"GridCenterPoint": { "x": 0, "y": 0 },

now serializes to:

"GridCenterPoint": "0,0",

You can control the TypeConverter formatting a little, but you cannot get away from the fact it is rendered as a string and not an object.

This problem isn’t a problem with the serializer, since Json.NET chews through complex objects without missing a beat, it is a problem with the way that dictionary keys are processed. If you try taking the example object, and serializing a List or even a Hashset, you notice that there isn’t a problem producing proper JSON. This gives us a much simpler way to solve this problem.

Ideally, we would like to just tell Json.NET to serialize the key as whatever object type it is, and not force it to be a string. Since that doesn’t seem to be an option, the other way is to give Json.NET something that it can work with: a List<KeyValuePair<T,K>>.

If you feed a list of KeyValuePairs into Json.NET’s serializer, you get exactly what you expect. For example, here is a much simpler wrapper that you could implement:

    private Dictionary<Point, string> _Locations;
    public List<KeyValuePair<Point, string>> SerializedLocations
    {
        get { return _Locations.ToList(); }
        set { _Locations= value.ToDictionary(x => x.Key, x => x.Value); }
    }

This trick works, because keys in a kvp aren’t forced into string format. Why a string format, you ask? It beats the hell out of me. the Dictionary object implements the IEnumerable<KeyValuePair<TKey, TValue>> interface, so there shouldn’t be any problem in serializing it in the same fashion as the list of kvps, since that is essentially what a dictionary is. Someone (James Newton?) made a decision when writing the Newtonsoft dictionary serializer that complex keys were too messy to deal with. There are probably some corner cases I have not considered that make this a much more sticky problem.

This is a much better solution because it produces actual JSON objects, is technically simpler, and doesn’t produce any side effects resulting from replacing the serializer.

More Related Contents:

  1. JSON.NET Error Self referencing loop detected for type
  2. Does Json.NET cache types’ serialization information?
  3. Cannot deserialize the JSON array (e.g. [1,2,3]) into type ‘ ‘ because type requires JSON object (e.g. {“name”:”value”}) to deserialize correctly
  4. Detect if deserialized object is missing a field with the JsonConvert class in Json.NET
  5. Json.net serialize/deserialize derived types?
  6. Using JsonConvert.DeserializeObject to deserialize Json to a C# POCO class
  7. How to ignore JsonProperty(PropertyName = “someName”) when serializing json?
  8. Json.Net: Serialize/Deserialize property as a value, not as an object
  9. “Self Referencing Loop Detected” exception with JSON.Net
  10. How to serialize/deserialize a custom collection with additional properties using Json.Net
  11. Deserializing JSON to abstract class
  12. Deserialize json array stream one item at a time
  13. How to deserialize a JSON property that can be two different data types using Json.NET
  14. Custom Deserialization using Json.NET
  15. Force JSON.NET to include milliseconds when serializing DateTime (even if ms component is zero)
  16. How to make JSON.Net serializer to call ToString() when serializing a particular type?
  17. Json.NET custom serialization with JsonConverter – how to get the “default” behavior
  18. How to apply indenting serialization only to some properties?
  19. Ignoring null fields in Json.net
  20. How to apply ObjectCreationHandling.Replace to selected properties when deserializing JSON?
  21. Convert DataTable to JSON with key per row
  22. Deserialize specific enum into system.enum in Json.Net
  23. Serializing an interface/abstract object using NewtonSoft.JSON
  24. Json.NET: Deserializing nested dictionaries
  25. JSonNet boolean serialization
  26. Deserializing JSON into an object with Json.NET
  27. Ignore Base Class Properties in Json.NET Serialization
  28. Configure Json.NET serialization settings on a class level
  29. JSON.NET Serializes Empty JSON
  30. Json.net serialization of custom collection implementing IEnumerable

Leave a Comment