using System;

using System.Collections.Generic;

using System.Linq;

using Newtonsoft.Json;

using Newtonsoft.Json.Serialization;

public class Program

{

    public static void Main()

    {

        string json = @"

            {

              ""AttachedTaskLocations"": [

                {

                  ""x"": 1.0,

                  ""y"": 1.0,

                  ""z"": 1.0

                },

                {

                  ""x"": 1000000000000.0,

                  ""y"": 2.0,

                  ""z"": 3.0

                },

                {

                  ""x"": 0.0,

                  ""y"": 0.0,

                  ""z"": 0.0

                }

              ]

            }";

​

        var settings = new JsonSerializerSettings();

        settings.ObjectCreationHandling = ObjectCreationHandling.Replace;    // comment out this line to see the original problem

        Console.WriteLine("Deserializing AnchorMetaData from JSON");

        var metaData = JsonConvert.DeserializeObject<AnchorMetaData>(json, settings);

​

        Console.WriteLine("Dumping attachedTaskLocations list");

        if (metaData.attachedTaskLocations.Any())

        {

            foreach (Vector3 vector in metaData.attachedTaskLocations)

            {

                Console.WriteLine(vector);

            }

        }

        else 

        {

            Console.WriteLine("attachedTaskLocations list is empty!");

        }

​

    }

}

​

[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

        {

            Console.WriteLine("AttachedTaskLocations getter was called");

            return attachedTaskLocations

                .Select(vector3 => new SerializableVector3(vector3))

                .ToList();

        }

        set

        {

            Console.WriteLine("AttachedTaskLocations setter was called");

            attachedTaskLocations = value

                .Select(sVector3 => new Vector3(sVector3.x, sVector3.y, sVector3.z))

                .ToList();

        }

    }

}

​

/// <summary>

/// Unity's Vector 3 isn't serializable, due to various reasons like vector  contains other vectors e.g. normalized vec which creates a loop.

/// So this class allows serialization of vector to JSON in a readable format.

/// </summary>

[Serializable]

public class SerializableVector3

{

    /// <summary>

    /// Unity vector in which everything is loaded.

    /// Default value is -Inf.

    /// </summary>

    [JsonIgnore]

    public Vector3 vector = Vector3.negativeInfinity;

    /// <summary>

    /// x component

    /// </summary>

    public float x

    {

        get => vector.x;

        set => vector.x = value;

    }

​

    /// <summary>

    /// y component

    /// </summary>

    public float y

    {

        get => vector.y;

        set => vector.y = value;

    }

​

    /// <summary>

    /// z component

    /// </summary>

    public float z

    {

        get => vector.z;

        set => vector.z = value;

    }

​

    /// <summary>

    /// Default constructor

    /// </summary>

    public SerializableVector3() { }

​

    /// <summary>

    /// Constructor

    /// </summary>

    /// <param name="x"></param>

    /// <param name="y"></param>

    /// <param name="z"></param>

    public SerializableVector3(float x, float y, float z)

    {

        this.x = x;

        this.y = y;

        this.z = z;

    }

​

    /// <summary>

    /// Convenience constructor.

    /// </summary>

    /// <param name="vector3"></param>

    public SerializableVector3(Vector3 vector3)

    {

        vector = vector3;

    }

​

    /// <summary>

    /// Returns a string representation of the object

    /// </summary>

    /// <returns></returns>

    public override string ToString() => $"SerializableVector3 [{x}, {y}, {z}]";

​

    /// <summary>

    /// Automatic conversion from SerializableVector3 to Vector3

    /// </summary>

    /// <param name="rhs"></param>

    /// <returns></returns>

    public static implicit operator Vector3(SerializableVector3 rhs) => new Vector3(rhs.x, rhs.y, rhs.z);

​

    /// <summary>

    /// Automatic conversion from Vector3 to SerializableVector3

    /// </summary>

    /// <param name="rhs"></param>

    /// <returns></returns>

    public static implicit operator SerializableVector3(Vector3 rhs) => new SerializableVector3(rhs);

}

​

// This is a severly stripped-down version of the Vector3 struct taken from:

// https://github.com/Unity-Technologies/UnityCsReference/blob/master/Runtime/Export/Math/Vector3.cs

public partial struct Vector3 : IEquatable<Vector3>

{

    // *Undocumented*

    public const float kEpsilon = 0.00001F;

​

    // X component of the vector.

    public float x;

    // Y component of the vector.

    public float y;

    // Z component of the vector.

    public float z;

​

    // Creates a new vector with given x, y, z components.

    public Vector3(float x, float y, float z) { this.x = x; this.y = y; this.z = z; }

    // Creates a new vector with given x, y components and sets /z/ to zero.

    public Vector3(float x, float y) { this.x = x; this.y = y; z = 0F; }

​

    // Set x, y and z components of an existing Vector3.

    public void Set(float newX, float newY, float newZ) { x = newX; y = newY; z = newZ; }

​

    // used to allow Vector3s to be used as keys in hash tables

    public override int GetHashCode()

    {

        return x.GetHashCode() ^ (y.GetHashCode() << 2) ^ (z.GetHashCode() >> 2);

    }

​

    // also required for being able to use Vector3s as keys in hash tables

    public override bool Equals(object other)

    {

        if (!(other is Vector3)) return false;

​

        return Equals((Vector3)other);

    }

​

    public bool Equals(Vector3 other)

    {

        return x == other.x && y == other.y && z == other.z;

    }

​

    // Returns this vector with a ::ref::magnitude of 1 (RO).

    public Vector3 normalized

    {

        get

        {

            float mag = magnitude;

            if (mag > kEpsilon)

                return this / mag;

            else

                return zero;

        }

    }

​

    // Returns the length of this vector (RO).

    public float magnitude { get { return (float)Math.Sqrt(x * x + y * y + z * z); } }

​

    // Returns the squared length of this vector (RO).

    public float sqrMagnitude { get { return x * x + y * y + z * z; } }

​

    static readonly Vector3 zeroVector = new Vector3(0F, 0F, 0F);

    static readonly Vector3 oneVector = new Vector3(1F, 1F, 1F);

    static readonly Vector3 positiveInfinityVector = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);

    static readonly Vector3 negativeInfinityVector = new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity);

​

    // Shorthand for writing @@Vector3(0, 0, 0)@@

    public static Vector3 zero { get { return zeroVector; } }

    // Shorthand for writing @@Vector3(1, 1, 1)@@

    public static Vector3 one { get { return oneVector; } }

    // Shorthand for writing @@Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)@@

    public static Vector3 positiveInfinity { get { return positiveInfinityVector; } }

    // Shorthand for writing @@Vector3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)@@

    public static Vector3 negativeInfinity { get { return negativeInfinityVector; } }

​

    // Adds two vectors.

    public static Vector3 operator +(Vector3 a, Vector3 b) { return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z); }

    // Subtracts one vector from another.

    public static Vector3 operator -(Vector3 a, Vector3 b) { return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z); }

    // Negates a vector.

    public static Vector3 operator -(Vector3 a) { return new Vector3(-a.x, -a.y, -a.z); }

    // Multiplies a vector by a number.

    public static Vector3 operator *(Vector3 a, float d) { return new Vector3(a.x * d, a.y * d, a.z * d); }

    // Multiplies a vector by a number.

    public static Vector3 operator *(float d, Vector3 a) { return new Vector3(a.x * d, a.y * d, a.z * d); }

    // Divides a vector by a number.

    public static Vector3 operator /(Vector3 a, float d) { return new Vector3(a.x / d, a.y / d, a.z / d); }

​

    // Returns true if the vectors are equal.

    public static bool operator ==(Vector3 lhs, Vector3 rhs)

    {

        // Returns false in the presence of NaN values.

        float diff_x = lhs.x - rhs.x;

        float diff_y = lhs.y - rhs.y;

        float diff_z = lhs.z - rhs.z;

        float sqrmag = diff_x * diff_x + diff_y * diff_y + diff_z * diff_z;

        return sqrmag < kEpsilon * kEpsilon;

    }

​

    // Returns true if vectors are different.

    public static bool operator !=(Vector3 lhs, Vector3 rhs)

    {

        // Returns true in the presence of NaN values.

        return !(lhs == rhs);

    }

​

    public override string ToString()

    {

        return $"Vector3 ({x}, {y}, {z})";

    }

}

​