Newtonsoft Calls Getter on Deserializing a Property

Question

I created a simple class model (AnchorMetaData), shown below, in which there are two items. One is a list field (Vector3) that cannot be serialized due to how it's made so I created a property for class (SerializableVector3) that could serialize and deserialize. I hoped to use this property with Newtonsoft for saving/loading the model.

The class saves just fine however, when I try to deserialize the model from JSON it calls the AttachedTaskLocations property's getter rather than setter. That makes the field to be initialized to be empty.

I only noticed this by using logs message and making some breakpoints. It never calls the setter when deserializing. Which is very odd as it should function.

Another odd behaviour is that it does pause on setter of x, y, z of SerializableVector3 with the correct values from the file. This is super odd.

I'm working with Unity 2019.1.14 but this should work without it too, just change vector list to something you have.

When I load the shown JSON file, which was created by serializing AnchorMetaData it has zero items in attachedTaskLocations. Why is this happening? Why does the setter not get called?

---

Class I created to save/load Vector3 is called SerializableVector3. Class I wish to save/load:

[Serializable]
public class AnchorMetaData
{
    // Cannot serialize this.
    [JsonIgnore]
    public List<Vector3> attachedTaskLocations = new List<Vector3>();

    /// <summary>
    /// This property servers as an interface for JSON de-/serialization.
    /// It uses a class that can be serialized by Newtonsoft.
    /// Should not be used in code except for serialization purposes.
    /// </summary>
    [JsonProperty("AttachedTaskLocations")]
    public List<SerializableVector3> AttachedTaskLocations
    {
        get
        {
            Debug.Log("Writing serialized vector.");
            return attachedTaskLocations
                .Select(vector3 => new SerializableVector3(vector3))
                .ToList();
        }
        set
        {
            Debug.Log("Loading serialized vector.");
            attachedTaskLocations = value
                .Select(sVector3 => new Vector3(sVector3.x, sVector3.y, sVector3.z))
                .ToList();
        }
    }

}

Serialized JSON:

{
  "AttachedTaskLocations": [
      {
        "x": 1.0,
        "y": 1.0,
        "z": 1.0
      },
      {
        "x": 1E+12,
        "y": 2.0,
        "z": 3.0
      },
      {
        "x": 0.0,
        "y": 0.0,
        "z": 0.0
      }
    ]
  }

Stack when breakpoint hits the getter on deserialize.

Answer 1

The reason that your AttachedTaskLocations is empty after deserialization is twofold:

1. By default, Json.Net will reuse existing object values during deserialization rather than create new ones. So, for properties such as your AttachedTaskLocations list, it will call the getter first, and, finding an existing value, it will then proceed to populate it from the JSON.
2. The getter of your AttachedTaskLocations doesn't return the same instance each time; it always creates a new instance from the attachedTaskLocations backing field.

So what appears to be happening is this:

1. The serializer calls the AttachedTaskLocations getter, which returns a new empty list.
2. The serializer populates that list from the JSON.
3. The populated list is thrown away (the serializer assumes that the AnchorMetaData instance already has a reference to the list so it never calls the setter).
4. When you later access the AttachedTaskLocations getter, it returns a new empty list again.

You can change the behavior of the serializer by setting the ObjectCreationHandling setting to Replace. This change alone appears to solve the issue in my testing.

However, I think that you are jumping through a bunch of hoops here to get Vector3 to serialize/deserialize properly when there is a better solution: use a custom JsonConverter. Here is the code you would need for the converter. It is not that much:

public class Vector3Converter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Vector3);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.StartObject)
        {
            JObject obj = JObject.Load(reader);
            return new Vector3((float)obj["x"], (float)obj["y"], (float)obj["z"]);
        }
        if (reader.TokenType == JsonToken.Null)
        {
            return null;
        }
        throw new JsonException("Unexpected token type: " + reader.TokenType);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value != null)
        {
            Vector3 vector = (Vector3)value;
            JObject obj = new JObject(
                new JProperty("x", vector.x),
                new JProperty("y", vector.y),
                new JProperty("z", vector.z)
            );
            obj.WriteTo(writer);
        }
        else
        {
            JValue.CreateNull().WriteTo(writer);
        }
    }
}

With this converter in place you can get rid of the SerializableVector3 class altogether and you can simplify your AnchorMetaData class down to this:

public class AnchorMetaData
{
    [JsonProperty("AttachedTaskLocations")]
    public List<Vector3> AttachedTaskLocations { get; set; } = new List<Vector3>();
}

To use the converter, you can either:

• pass it to the JsonConvert.SerializeObject()/DeserializeObject() methods;
• add it to the Converters collection on JsonSerializerSettings and pass the settings to JsonConvert.SerializeObject()/DeserializeObject(), or
• add it to the Converters collection directly on a JsonSerializer instance.

For example:

var settings = new JsonSerializerSettings();
settings.Converters.Add(new Vector3Converter());
var metaData = JsonConvert.DeserializeObject<AnchorMetaData>(json, settings);

Round-trip demo: https://dotnetfiddle.net/jmYIq9

---

If you don't have access to the serializer (it's hard to tell from your question whether you are doing the serializing/deserializing in your own code, or whether some third-party component is handling that) then another way to use the converter is via attributes. For a list property like AttachedTaskLocations you can specify the ItemConverterType right in the [JsonProperty] attribute like this:

    [JsonProperty("AttachedTaskLocations", ItemConverterType = typeof(Vector3Converter))]
    public List<Vector3> AttachedTaskLocations { get; set; } = new List<Vector3>();

If you had a single instance property, then you would use a [JsonConverter] attribute instead like this:

    [JsonConverter(typeof(Vector3Converter))]
    public Vector3 SingleVector { get; set; }

Fiddle: https://dotnetfiddle.net/yxwqDL