DataContractJsonSerializer set value extension point

Question

using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Text;

namespace ConsoleApplication1 {
  internal class Program {
    private static void Main(string[] args) {
      var pony = new Pony();
      var serializer = new DataContractJsonSerializer(pony.GetType());
      var example = @"{""Foo"":null}";
      var stream = new MemoryStream(Encoding.UTF8.GetBytes(example.ToCharArray()));
      stream.Position = 0;
      pony = (Pony) serializer.ReadObject(stream);
      // The previous line throws an exception.
    }
  }

  [DataContract]
  public class Pony {
    [DataMember]
    private int Foo { get; set; }
  }
}

Sometimes the serialization throws a casting error on Int32s being set to null. Is there any way to hook into the Json-serializer?

Answer 1

IMHO the best thing would be to change the Foo type from Int32 to System.Nullable<Int32> as this would best reflect its semantics (if it can be null) but if you cannot modify this class or if using DataContractJsonSerializer is not an obligation for you, Json.NET has extension points that allow you to do this (it also happens to be better performing).

For example you could write a custom type converter:

internal class NullableIntConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(int);
    }

    public override object ReadJson(JsonReader reader, Type objectType, JsonSerializer serializer)
    {
        if (reader.Value == null)
        {
            return default(int);
        }
        return int.Parse(reader.Value.ToString());
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new System.NotImplementedException();
    }
}

that could be registered and used like this:

internal class Program
{
    private static void Main(string[] args)
    {
        var serializer = new JsonSerializer();
        serializer.Converters.Add(new NullableIntConverter());
        using (var reader = new StringReader(@"{""Foo"":null}"))
        using (var jsonReader = new JsonTextReader(reader))
        {
            var pony = serializer.Deserialize<Pony>(jsonReader);
            Console.WriteLine(pony.Foo);
        }
    }
}

Answer 2

The easiest way of making it work would be to set the int to be a nullable int instead. I've debugged through the example code and that seems to work fine.

[DataContract]
public class Pony
{
    [DataMember]
    private int? Foo { get; set; }
}

Answer 3

DataContractJsonSerializer has a DataContractSurrogate property that you can assign. Your surrogate class, which is an implementation of IDataContractSurrogate, can in its GetDeserializedObject do your custom handling of null values.

Answer 4

If you are using .NET 3.5 or later (and I hope you do), you can use JavaScriptSerializer instead. It's more "dynamic" (doesn't require [DataContract] and [DataMember] attributes) and I've never had any problems with it before. You just pick up any object you want, any type and serialize with it :)

In .net 3.5 it was part of the System.Web.Extensions.dll, but in .NET 4 this assembly is now part of the framework.

You can easily add your own custom Serializer code to it, and handle it manually. This way you'll get the control that you want, and you'll know which property misbehaves!

e.g:

void Main()
{
    var js = new JavaScriptSerializer();
    js.RegisterConverters(new[] { new PonySerializer() });
    var pony = js.Deserialize<Pony>(@"{""Foo"":""null""}");
    pony.Dump();
}

public class PonySerializer : JavaScriptConverter
{
    public override IEnumerable<Type> SupportedTypes
    {
        get { return new [] { typeof(Pony) }; }
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
        if (dictionary == null)
            throw new ArgumentNullException("dictionary");

        if (type == typeof(Pony))
        {
            var pony = new Pony();
            int intValue;

            if (!int.TryParse(dictionary["Foo"] as string, out intValue))
                intValue = -1; // default value. You can throw an exception or log it or do whatever you want here

            pony.Foo = intValue;
            return pony;
        }
        return null;
    }
}

public class Pony
{
    public int Foo { get; set; }
}

P.S. This example was written in LinqPad, hence the missing usings, parameters on Main() etc :P