How to Optimize Json.NET Serialization Performance

Newtonsoft is a pretty fast JSON serializer, but you can make it even faster!

By default, JsonConvert uses reflection to recursively search through the structure of an object during the serialization process. By implementing a custom JsonConverter that already knows the exact structure of the object, you can significantly increase serialization performance.

How much faster? That depends! The more complicated the data structure, the larger the performance gain. Below is a simple example...

Action	Method	Milliseconds	Performance Increase
Serialize	Standard	1134	115.59%
	Custom	526
Deserialize	Standard	1488	62.98%
	Custom	913

Model and Converter

public class Model

{

    public int Int { get; set; }

    public bool Bool { get; set; }

    public string String { get; set; }

}

public class ModelConverter : JsonConverter

{

    public static readonly ModelConverter Instance = new ModelConverter();

    private static readonly Type ModelType = typeof(ICollection<Model>);

    public override bool CanConvert(Type objectType)

    {

        return ModelType.IsAssignableFrom(objectType);

    }

    public override void WriteJson(

        JsonWriter writer,

        object value,

        JsonSerializer serializer)

    {

        var collection = (ICollection<Model>)value;

        writer.WriteStartArray();

        foreach (var model in collection)

        {

            writer.WriteStartObject();

            writer.WritePropertyName("Int");

            writer.WriteValue(model.Int);

            writer.WritePropertyName("Bool");

            writer.WriteValue(model.Bool);

            writer.WritePropertyName("String");

            writer.WriteValue(model.String);

            writer.WriteEndObject();

        }

        writer.WriteEndArray();

    }

    public override object ReadJson(

        JsonReader reader,

        Type objectType,

        object existingValue,

        JsonSerializer serializer)

    {

        var collection = new List<Model>();

        Model model = null;

        while (reader.Read())

        {

            switch (reader.TokenType)

            {

                case JsonToken.StartObject:

                    model = new Model();

                    collection.Add(model);

                    break;

                case JsonToken.PropertyName:

                    SetProperty(reader, model);

                    break;

                case JsonToken.EndArray:

                    return collection;

            }

        }

        return collection;

    }

    private static void SetProperty(JsonReader reader, Model model)

    {

        var name = (string)reader.Value;

        reader.Read();

        switch (name)

        {

            case "Int":

                model.Int = Convert.ToInt32(reader.Value);

                break;

            case "Bool":

                model.Bool = (bool)reader.Value;

                break;

            case "String":

                model.String = (string)reader.Value;

                break;

        }

    }

}

Unit Tests

public class JsonConverterPerformanceTests

{

    private readonly ITestOutputHelper _output;

    public JsonConverterPerformanceTests(ITestOutputHelper output)

    {

        _output = output;

    }

    [Fact]

    public void ModelConverterPerformance()

    {

        var collection = Enumerable

            .Range(1, 100)

            .Select(i => new Model

            {

                Int = i,

                Bool = i % 2 == 0,

                String = "Hello World"

            })

            .ToList();

        const int iterations = 10000;

        var json = JsonConvert.SerializeObject(collection, ModelConverter.Instance);

        var sw1 = Stopwatch.StartNew();

        for (var i = 0; i < iterations; i++)

            JsonConvert.SerializeObject(collection);

        sw1.Stop();

        _output.WriteLine("Standard Serialize: " + sw1.ElapsedMilliseconds);

        var sw2 = Stopwatch.StartNew();

        for (var i = 0; i < iterations; i++)

            JsonConvert.SerializeObject(collection, ModelConverter.Instance);

        sw2.Stop();

        _output.WriteLine("Custom Serialize: " + sw2.ElapsedMilliseconds);

        var sw3 = Stopwatch.StartNew();

        for (var i = 0; i < iterations; i++)

            JsonConvert.DeserializeObject<Model[]>(json);

        sw3.Stop();

        _output.WriteLine("Standard Deserialize: " + sw3.ElapsedMilliseconds);

        var sw4 = Stopwatch.StartNew();

        for (var i = 0; i < iterations; i++)

            JsonConvert.DeserializeObject<ICollection<Model>>(json, ModelConverter.Instance);

        sw4.Stop();

        _output.WriteLine("Custom Deserialize: " + sw4.ElapsedMilliseconds);

        Assert.True(sw1.ElapsedMilliseconds > sw2.ElapsedMilliseconds);

        Assert.True(sw3.ElapsedMilliseconds > sw4.ElapsedMilliseconds);

    }

}

Enjoy,
Tom