Deserialize to ExpandoObject with Json.NET

I absolutely love Json.NET!

What I don't like is calling the non-generic DeserializeObject method and then having to deal with JToken wrappers. While these objects can be useful, I almost always want to just work directly with the data.

Good news, everyone! Newtonsoft natively supports deserializing to an ExpandoObject!

For anyone who does not know, ExpandoObjects are what .NET uses to let you create your own dynamic objects whose members can be dynamically added and removed at run time. The following two lines of code are ALL that you need to deserialize straight to an ExpandObjects:

var converter = new ExpandoObjectConverter();

dynamic obj = JsonConvert.DeserializeObject<ExpandoObject>(json, converter);

So why is this useful? To find out, let's take a look at some unit tests!

Unit Tests

// This is the sample class that we will use in our  unit tests. It is

// simple, but shows examples of working with different data types.

public class Sample

{

    public int[] A { get; set; }

    public bool B { get; set; }

    public Sample C { get; set; }

    public static Sample Create()

    {

        return new Sample

        {

            A = new[] { 1, 2, 3 },

            C = new Sample

            {

                A = new[] { 6, 5, 4 },

                B = true

            }

        };

    }

}

// This code is SO UGLY! Realistically you would never have to do this;

// you should cast to dynamic(like the test below). However I wanted to 

// show what the JObjects are actually abstracting under the hood.

[Fact]

public void JObject()

{

    var sample = Sample.Create();

    var json = JsonConvert.SerializeObject(sample);

    var obj = JsonConvert.DeserializeObject(json);

    var jObj = obj as JObject;

    Assert.NotNull(jObj);

    var jTokenA = jObj["A"];

    var jArray = jTokenA as JArray;

    Assert.NotNull(jArray);

    var jToken0 = jArray[0];

    Assert.NotNull(jToken0);

    var valueOf0 = jToken0.Value<long>();

    Assert.Equal(sample.A[0], valueOf0);

    var jTokenB = jObj["B"];

    Assert.NotNull(jTokenB);

    var valueOfB = jTokenB.Value<bool>();

    Assert.Equal(sample.B, valueOfB);

    var jTokenC = jObj["C"];

    var jObjC = jTokenC as JObject;

    Assert.NotNull(jObjC);

}

// Here is the correct way to write the test above. Note that we still

// have to call VALUE against the the tokens themselves. In our third

// test we will see how to avoid this by deserializing directly to

// ExpandoObject and skilling the JToken wrappers.

[Fact]

public void JObjectDynamic()

{

    var sample = Sample.Create();

    var json = JsonConvert.SerializeObject(sample);

    dynamic obj = JsonConvert.DeserializeObject(json);

    Assert.IsType<JObject>(obj);

    var a = obj.A;

    Assert.IsType<JArray>(a);

    var a0 = a[0];

    Assert.IsType<JValue>(a0);

    Assert.Equal(sample.A[0], a0.Value); // Ewww!

    var b = obj.B;

    Assert.IsType<JValue>(b);

    Assert.Equal(sample.B, b.Value); // Yuck!

    var c = obj.C;

    Assert.IsType<JObject>(c);

}

// Finally we arrive at the best way to write this. If you do not need

// the JToken wrappers around all of your values, then you can very

// easily deserialize stright into an ExpandoObject. This is the native

// type that .NET uses to handle dynamic objects. This means that we

// can now call our object exactly as we would if it were the real

// type; no need to check Value or any other wrapper properties. :)

[Fact]

public void ExpandoObject()

{

    var sample = Sample.Create();

    var json = JsonConvert.SerializeObject(sample);

    var converter = new ExpandoObjectConverter();

    dynamic obj = JsonConvert.DeserializeObject<ExpandoObject>(json, converter);

    Assert.IsType<ExpandoObject>(obj);

    var a = obj.A;

    Assert.IsType<List<object>>(a);

    var a0 = a[0];

    Assert.IsType<long>(a0);

    Assert.Equal(sample.A[0], a0); // No call to a0.Value!

    var b = obj.B;

    Assert.IsType<bool>(b);

    Assert.Equal(sample.B, b); // Woo hoo!

    var c = obj.C;

    Assert.IsType<ExpandoObject>(c);

}

Enjoy,
Tom