Serialize json value types with type data

Question

I've almost solved my problem but missing the last piece...

I Have a list of object and I want to be able to add value types (that normaly will be serialized to strings) and get them back as the original type. For example: Guids or custom value types.

This is a sample custom value type:

public struct ExtString
{
    private String Value
    {
        get;
        set;
    }

    public static implicit operator ExtString(String str)
    {
        return !String.IsNullOrWhiteSpace(str) ? new ExtString(str) : null;
    }

    public static implicit operator String(ExtString exStr)
    {
        return exStr.ToString();
    }

    public ExtString(String str)
    {
        this.Value = str;
    }

    public override String ToString()
    {
        return this.Value;
    }
}

This is the Custom converter:

public class CustomConverter : JsonConverter
{
    public override Boolean CanConvert(Type objectType)
    {
        return objectType.IsValueType;
    }

    public override bool CanRead => false;

    public override void WriteJson(JsonWriter writer, Object value, JsonSerializer serializer)
    {
        writer.WriteStartObject();

        writer.WritePropertyName("$type");
        writer.WriteValue(value.GetType().AssemblyQualifiedName);

        writer.WritePropertyName("$value");
        writer.WriteValue(value.ToString());

        writer.WriteEndObject();
    }

And here is the sample code for serializing / deserilizing:

    var jsonSerializerSettings = new JsonSerializerSettings()
    {
        TypeNameHandling = TypeNameHandling.All,
        Converters = new JsonConverter[]
        {
            new CustomConverter()
        }
    };

    var list = new List<Object>();

    list.Add(Guid.NewGuid());
    list.Add((ExtString)"Hello World");

    var ser = JsonConvert.SerializeObject(list, Formatting.Indented, jsonSerializerSettings);

    var deser = JsonConvert.DeserializeObject(ser, jsonSerializerSettings);

This works almost all the way... Both the Guid and ExtString is serialized correct and the Guid is even deserialized with correct value (without special handling!), and the ExtString is created correct (on deserialize) but with the value null (constructor is called but str is null).

What am I missing? Why does it work for Guid?

Thanks.

Answer 1

All you have to do is to specify the JSON property name for your Value property.

public struct ExtString
{
    [JsonProperty("$value")]
    private String Value
    {
     ...

---

More in depth

The Guid mapping works because it is considered a primitive type and Json.Net knows how to create a new instance and the parameter to pass to (using a JsonPrimitiveContract).

On the contrary, ExtString is resolved using a JsonObjectContract which calls the parameterless constructor of ExtString (it is there even if you don't declare it, because it's a value type) and then assigns the properties values to the corresponding json properties values. But the ExtString struct property name is Value while the JSON property name is $value. So a new istance of ExtString is created but the Value property remains null because there aren't properties with name Value. This is why, in your code, you have a new istance of ExtString with the Value property setted to null.

In the above solution I match the property name of the ExtString struct with the name of the property in the input JSON. After creating an instance of the ExtString struct, a mapping of the $value property will be done with success.

Another solution could be:

public struct ExtString
{
    private String Value
    {
        get;
        set;
    }

    [JsonConstructor]
    public ExtString([JsonProperty("$value")] String str)
    {
        this.Value = str;
    }

In this case, the constructor with the JsonConstructor attribute will be used instead of the parameterless one. Note that the str parameter must be provided with the appropriate JsonProperty attribute which defines the property name (in the input JSON) whose value will be passed to the constructor. If you omit the JsonProperty attribute, str parameter will be null and so your Value property too.

The difference between the two solutions is on the where the Value property is assigned. In the first solution the property is assigned after creating the object, in the second solution the property is assigned by the constructor.

Think it in this way:

//First solution
var myObject = new ExtString();
myObject.Value = "Hello World";

//Second solution
var myObject = new ExtString("Hello World");

I think the first solution give you much more control setting the value because (modifing the setter method) your logic will be always called, no matter how you create the object or when you assign the value.

Source: a pleasant and immersive analysis of the source code.

I know, my English is very bad :)