Null-coalescing operator returning null for properties of dynamic objects

by

This is due to obscure behaviors of Json.NET and the ?? operator.

Firstly, when you deserialize JSON to a dynamic object, what is actually returned is a subclass of the Linq-to-JSON type JToken (e.g. JObject or JValue) which has a custom implementation of IDynamicMetaObjectProvider. I.e.

dynamic d1 = JsonConvert.DeserializeObject(json);
var d2 = JsonConvert.DeserializeObject<JObject>(json);

Are actually returning the same thing. So, for your JSON string, if I do

    var s1 = JsonConvert.DeserializeObject<JObject>(json)["phones"]["personal"];
    var s2 = JsonConvert.DeserializeObject<dynamic>(json).phones.personal;

Both these expressions evaluate to exactly the same returned dynamic object. But what object is returned? That gets us to the second obscure behavior of Json.NET: rather than representing null values with null pointers, it represents then with a special JValue with JValue.Type equal to JTokenType.Null. Thus if I do:

    WriteTypeAndValue(s1, "s1");
    WriteTypeAndValue(s2, "s2");

The console output is:

"s1":  Newtonsoft.Json.Linq.JValue: ""
"s2":  Newtonsoft.Json.Linq.JValue: ""

I.e. these objects are not null, they are allocated POCOs, and their ToString() returns an empty string.

But, what happens when we assign that dynamic type to a string? 

    string tmp;
    WriteTypeAndValue(tmp = s2, "tmp = s2");

Prints:

"tmp = s2":  System.String: null value

Why the difference? It is because the DynamicMetaObject returned by JValue to resolve the conversion of the dynamic type to string eventually calls ConvertUtils.Convert(value, CultureInfo.InvariantCulture, binder.Type) which eventually returns null for a JTokenType.Null value, which is the same logic performed by the explicit cast to string avoiding all uses of dynamic:

    WriteTypeAndValue((string)JsonConvert.DeserializeObject<JObject>(json)["phones"]["personal"], "Linq-to-JSON with cast");
    // Prints "Linq-to-JSON with cast":  System.String: null value

    WriteTypeAndValue(JsonConvert.DeserializeObject<JObject>(json)["phones"]["personal"], "Linq-to-JSON without cast");     
    // Prints "Linq-to-JSON without cast":  Newtonsoft.Json.Linq.JValue: ""

Now, to the actual question. As husterk noted the ?? operator returns dynamic when one of the two operands is dynamic, so d.phones.personal ?? "default" does not attempt to perform a type conversion, thus the return is a JValue:

    dynamic d = JsonConvert.DeserializeObject<dynamic>(json);
    WriteTypeAndValue((d.phones.personal ?? "default"), "d.phones.personal ?? \"default\"");
    // Prints "(d.phones.personal ?? "default")":  Newtonsoft.Json.Linq.JValue: ""

But if we invoke Json.NET’s type conversion to string by assigning the dynamic return to a string, then the converter will kick in and return an actual null pointer after the coalescing operator has done its work and returned a non-null JValue:

    string tmp;
    WriteTypeAndValue(tmp = (d.phones.personal ?? "default"), "tmp = (d.phones.personal ?? \"default\")");
    // Prints "tmp = (d.phones.personal ?? "default")":  System.String: null value

This explains the difference you are seeing.

To avoid this behavior, force the conversion from dynamic to string before the coalescing operator is applied:

s += ((string)d.phones.personal ?? "default");

Finally, the helper method to write the type and value to the console:

public static void WriteTypeAndValue<T>(T value, string prefix = null)
{
    prefix = string.IsNullOrEmpty(prefix) ? null : "\""+prefix+"\": ";

    Type type;
    try
    {
        type = value.GetType();
    }
    catch (NullReferenceException)
    {
        Console.WriteLine(string.Format("{0} {1}: null value", prefix, typeof(T).FullName));
        return;
    }
    Console.WriteLine(string.Format("{0} {1}: \"{2}\"", prefix, type.FullName, value));
}

(As an aside, the existence of the null-type JValue explains how the expression (object)(JValue)(string)null == (object)(JValue)null might possibly evaluate to false).

More Related Contents:

  1. Deserialize JSON into C# dynamic object?
  2. How to implement custom JsonConverter in JSON.NET?
  3. Does Json.NET cache types’ serialization information?
  4. Deserialize json with known and unknown fields
  5. Using JsonConvert.DeserializeObject to deserialize Json to a C# POCO class
  6. How to write a JSON file in C#?
  7. Parse Json string in C#
  8. Deserializing JSON to abstract class
  9. Not ableTo Serialize Dictionary with Complex key using Json.net
  10. How to tell Json.Net globally to apply the StringEnumConverter to all enums
  11. How can I serialize/deserialize a dictionary with custom keys using Json.Net?
  12. What is the difference between PreserveReferencesHandling and ReferenceLoopHandling in Json.Net?
  13. How to call JsonConvert.DeserializeObject and disable a JsonConverter applied to a base type via [JsonConverter]?
  14. Newtonsoft JSON dynamic property name
  15. Serialize as NDJSON using Json.NET
  16. JSON serialize properties on class inheriting list [duplicate]
  17. JSON.net (de)serialize untyped property
  18. How to apply a general rule for remapping all property names when serializing with Json.NET?
  19. How can I tell Json.NET to ignore properties in a 3rd-party object?
  20. How can I merge two JObject? [duplicate]
  21. Json.NET adding backslash while returning json serialized string
  22. Json.NET: Deserializing nested dictionaries
  23. Custom Json Serialization of class
  24. How can I force a minimum number of decimal places in Json.net?
  25. Using Custom WCF Body Deserialization without changing URI Template Deserialization
  26. Deserializing JSON into an object with Json.NET
  27. Ignore Base Class Properties in Json.NET Serialization
  28. Streaming large list of data as JSON format using Json.net
  29. Merge two Json.NET arrays by concatenating contained elements
  30. How do I parse a JSON object in C# when I don’t know the key in advance?

Leave a Comment