[Fork] https://stackoverflow.com/questions/76629491/cannot-write-external-object-inside-of-custom-object-to-csv-using-csvhelper-with | C# Online Compiler

[Fork] https://stackoverflow.com/questions/76629491/cannot-write-external-object-inside-of-custom-object-to-csv-using-csvhelper-with by dbc_MinLength

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Reflection;
using System.Collections.ObjectModel;

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

using UnityEngine;

using CsvHelper;
using CsvHelper.Configuration;
using CsvHelper.Configuration.Attributes;
using CsvHelper.Expressions;
using CsvHelper.TypeConversion;

using Newtonsoft.Json;

#nullable enable

//https://stackoverflow.com/questions/76629491/cannot-write-external-object-inside-of-custom-object-to-csv-using-csvhelper-with

	public static partial class CsvExtensions
	{
		// Update autoampped reference maps to a different map.
		// Note this should only be done within a ClassMap constructor itself.
		public static ClassMap UpdateReferenceMaps<TReferenceMap, TReferenceClass>(this ClassMap classMap, params object[] constructorArgs) where TReferenceMap : ClassMap<TReferenceClass>
		{
			for (int i = classMap.ReferenceMaps.Count - 1; i >= 0; i--)
			{
				var oldRef = classMap.ReferenceMaps[i];
				var memberType = oldRef.Data.Member.MemberType();
				if (memberType == typeof(TReferenceClass))
				{
					classMap.ReferenceMaps.RemoveAt(i);
					Console.WriteLine("Removed at {0} for {1}", i, oldRef.Data.Member);

					var newRef = classMap.References(typeof(TReferenceMap), oldRef.Data.Member, constructorArgs);
					var newIndex = classMap.ReferenceMaps.IndexOfWithHint(newRef, classMap.ReferenceMaps.Count - 1);
					classMap.ReferenceMaps.RemoveAt(newIndex);
					classMap.ReferenceMaps.Insert(i, newRef);
					if (oldRef.Data.Prefix != null)
						newRef.Prefix(oldRef.Data.Prefix);
				}
			}
			return classMap;
		}
		
		static Type? MemberType(this MemberInfo m) =>
			m switch
			{
				PropertyInfo p => p.PropertyType,
				FieldInfo f => f.FieldType,
				_ => null,
			};

		static int IndexOfWithHint<T>(this IList<T> list, T item, int hint) where T : class
		{
			if (hint >= 0 && hint <= list.Count && list[hint] == item)
				return hint;
			return list.IndexOf(item);
		}
	}

	public class BehaviouralData
	{
		public float ActionZ { get; set; }
		public float ActionX { get; set; }
		public int TargetBallAgentHashCode { get; set; }
		public Vector3 TargetBallLocalPosition { get; set; }
		public bool CollectBehaviouralData { get; set; }
		public DateTime ActionTime { get; set; }
		public DateTime Time { get; set; }
	}

	public sealed class Vector3Map : ClassMap<Vector3>
	{
		public Vector3Map()
		{
			Map(m => m.x);
			Map(m => m.y);
			Map(m => m.z);
		}
	}	

	public class DefaultAutoMap<TClass> : ClassMap<TClass>
	{
		public DefaultAutoMap()
		{
			AutoMap(CultureInfo.InvariantCulture);
			this.UpdateReferenceMaps<Vector3Map, Vector3>();
		}
	}
	
	public class BehaviouralDataMapExplicit : ClassMap<BehaviouralData>
	{
		public BehaviouralDataMapExplicit()
		{
			Map(m => m.ActionZ);
			Map(m => m.ActionX);
			Map(m => m.TargetBallAgentHashCode);
			References(typeof(Vector3Map), typeof(BehaviouralData).GetProperty(nameof(BehaviouralData.TargetBallLocalPosition)));
			//References<Vector3Map>(m => m.TargetBallLocalPosition);
			Map(m => m.CollectBehaviouralData);
			Map(m => m.ActionTime);
			Map(m => m.Time);
			this.UpdateReferenceMaps<Vector3Map, Vector3>();
		}
	}

    class TestClass
    {
        public static void Test()
        {
			var data = new List<BehaviouralData>()
			{
				new() { TargetBallAgentHashCode = 1, TargetBallLocalPosition = new() { x = 1.1f, y = 1.1f, z = 1.1f }},
				new() { TargetBallAgentHashCode = 2, TargetBallLocalPosition = new() { x = 2.1f, y = 2.1f, z = 2.1f }},
				new() { TargetBallAgentHashCode = 3, TargetBallLocalPosition = new() { x = 3.1f, y = 3.1f, z = 3.1f }},
			};
			
			var config = new CsvConfiguration(CultureInfo.InvariantCulture);
			using var writer = new StringWriter();
			using (var csv = new CsvWriter(writer, config))
			{
				csv.Context.RegisterClassMap<DefaultAutoMap<BehaviouralData>>();
				//csv.Context.AutoMap<BehaviouralData>().UpdateReferenceMaps<Vector3Map, Vector3>();
				//csv.Context.RegisterClassMap<BehaviouralDataMapExplicit>();
				csv.WriteRecords(data);
			}
			
			Console.WriteLine(writer);
		}	
	}

	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Environment version: {0} ({1}), {2}.", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion);
			Console.WriteLine("OS Version: {0}, NewLine: {1}", System.Environment.OSVersion, JsonConvert.SerializeObject(Environment.NewLine));
			Console.WriteLine("{0} version: {1}", typeof(CsvReader).Assembly.GetName().Name,  typeof(CsvReader).Assembly.FullName);
			Console.WriteLine();

			try
			{
				TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Failed with unhandled exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}

namespace UnityEngine
{
// COPY (and cleanup for fiddle) from the Unity Source Code 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;
	// *Undocumented*
	public const float kEpsilonNormalSqrt = 1e-15F;
	// X component of the vector.
	public float x { get; set; }

	// Y component of the vector.
	public float y { get; set; }
	// Z component of the vector.
	public float z { get; set; }
	
	// Access the x, y, z components using [0], [1], [2] respectively.
#if false	
	public float this[int index]
	{
		get
		{
			switch (index)
			{
				case 0:
					return x;
				case 1:
					return y;
				case 2:
					return z;
				default:
					throw new IndexOutOfRangeException("Invalid Vector3 index!");
			}
		}

		set
		{
			switch (index)
			{
				case 0:
					x = value;
					break;
				case 1:
					y = value;
					break;
				case 2:
					z = value;
					break;
				default:
					throw new IndexOutOfRangeException("Invalid Vector3 index!");
			}
		}
	}
#endif
	// 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;
	}

	// 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;
	}

	// *undoc* --- we have normalized property now
	public static Vector3 Normalize(Vector3 value)
	{
		float mag = Magnitude(value);
		if (mag > kEpsilon)
			return value / mag;
		else
			return zero;
	}

	// Makes this vector have a ::ref::magnitude of 1.
	public void Normalize()
	{
		float mag = Magnitude(this);
		if (mag > kEpsilon)
			this = this / mag;
		else
			this = zero;
	}

	// Returns this vector with a ::ref::magnitude of 1 (RO).
	public Vector3 normalized
	{
		get
		{
			return Vector3.Normalize(this);
		}
	}

	// Dot Product of two vectors.
	public static float Dot(Vector3 lhs, Vector3 rhs)
	{
		return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
	}

	// *undoc* --- there's a property now
	public static float Magnitude(Vector3 vector)
	{
		return (float)Math.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
	}

	// Returns the length of this vector (RO).
	public float magnitude
	{
		get
		{
			return (float)Math.Sqrt(x * x + y * y + z * z);
		}
	}

	// *undoc* --- there's a property now
	public static float SqrMagnitude(Vector3 vector)
	{
		return vector.x * vector.x + vector.y * vector.y + vector.z * vector.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 upVector = new Vector3(0F, 1F, 0F);
	static readonly Vector3 downVector = new Vector3(0F, -1F, 0F);
	static readonly Vector3 leftVector = new Vector3(-1F, 0F, 0F);
	static readonly Vector3 rightVector = new Vector3(1F, 0F, 0F);
	static readonly Vector3 forwardVector = new Vector3(0F, 0F, 1F);
	static readonly Vector3 backVector = new Vector3(0F, 0F, -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(0, 0, 1)@@
	public static Vector3 forward
	{
		get
		{
			return forwardVector;
		}
	}

	public static Vector3 back
	{
		get
		{
			return backVector;
		}
	}

	// Shorthand for writing @@Vector3(0, 1, 0)@@
	public static Vector3 up
	{
		get
		{
			return upVector;
		}
	}

	public static Vector3 down
	{
		get
		{
			return downVector;
		}
	}

	public static Vector3 left
	{
		get
		{
			return leftVector;
		}
	}

	// Shorthand for writing @@Vector3(1, 0, 0)@@
	public static Vector3 right
	{
		get
		{
			return rightVector;
		}
	}

	// 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);
	}
}	
}

​x
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Reflection;
using System.Collections.ObjectModel;
​
using NUnit.Framework; // Throws NUnit.Framework.AssertionException
​
using UnityEngine;
​
using CsvHelper;
using CsvHelper.Configuration;
using CsvHelper.Configuration.Attributes;
using CsvHelper.Expressions;
using CsvHelper.TypeConversion;
​
using Newtonsoft.Json;
​
#nullable enable
​
//https://stackoverflow.com/questions/76629491/cannot-write-external-object-inside-of-custom-object-to-csv-using-csvhelper-with
​
    public static partial class CsvExtensions
    {
        // Update autoampped reference maps to a different map.
        // Note this should only be done within a ClassMap constructor itself.
        public static ClassMap UpdateReferenceMaps<TReferenceMap, TReferenceClass>(this ClassMap classMap, params object[] constructorArgs) where TReferenceMap : ClassMap<TReferenceClass>
        {
            for (int i = classMap.ReferenceMaps.Count - 1; i >= 0; i--)
            {
                var oldRef = classMap.ReferenceMaps[i];
                var memberType = oldRef.Data.Member.MemberType();
                if (memberType == typeof(TReferenceClass))
                {
                    classMap.ReferenceMaps.RemoveAt(i);
                    Console.WriteLine("Removed at {0} for {1}", i, oldRef.Data.Member);
​
                    var newRef = classMap.References(typeof(TReferenceMap), oldRef.Data.Member, constructorArgs);
                    var newIndex = classMap.ReferenceMaps.IndexOfWithHint(newRef, classMap.ReferenceMaps.Count - 1);
                    classMap.ReferenceMaps.RemoveAt(newIndex);
                    classMap.ReferenceMaps.Insert(i, newRef);
                    if (oldRef.Data.Prefix != null)
                        newRef.Prefix(oldRef.Data.Prefix);
                }
            }
            return classMap;
        }
        
        static Type? MemberType(this MemberInfo m) =>
            m switch
            {
                PropertyInfo p => p.PropertyType,
                FieldInfo f => f.FieldType,
                _ => null,
            };
​
        static int IndexOfWithHint<T>(this IList<T> list, T item, int hint) where T : class
        {
            if (hint >= 0 && hint <= list.Count && list[hint] == item)
                return hint;
            return list.IndexOf(item);
        }
    }
​
    public class BehaviouralData
    {
        public float ActionZ { get; set; }
        public float ActionX { get; set; }
        public int TargetBallAgentHashCode { get; set; }
        public Vector3 TargetBallLocalPosition { get; set; }
        public bool CollectBehaviouralData { get; set; }
        public DateTime ActionTime { get; set; }
        public DateTime Time { get; set; }
    }
​
    public sealed class Vector3Map : ClassMap<Vector3>
    {
        public Vector3Map()
        {
            Map(m => m.x);
            Map(m => m.y);
            Map(m => m.z);
        }
    }   
​
    public class DefaultAutoMap<TClass> : ClassMap<TClass>
    {
        public DefaultAutoMap()
        {
            AutoMap(CultureInfo.InvariantCulture);
            this.UpdateReferenceMaps<Vector3Map, Vector3>();
        }
    }
    
    public class BehaviouralDataMapExplicit : ClassMap<BehaviouralData>
    {
        public BehaviouralDataMapExplicit()
        {
            Map(m => m.ActionZ);
            Map(m => m.ActionX);
            Map(m => m.TargetBallAgentHashCode);
            References(typeof(Vector3Map), typeof(BehaviouralData).GetProperty(nameof(BehaviouralData.TargetBallLocalPosition)));
            //References<Vector3Map>(m => m.TargetBallLocalPosition);
            Map(m => m.CollectBehaviouralData);
            Map(m => m.ActionTime);
            Map(m => m.Time);
            this.UpdateReferenceMaps<Vector3Map, Vector3>();
        }
    }
​
    class TestClass
    {
        public static void Test()
        {
            var data = new List<BehaviouralData>()
            {
                new() { TargetBallAgentHashCode = 1, TargetBallLocalPosition = new() { x = 1.1f, y = 1.1f, z = 1.1f }},
                new() { TargetBallAgentHashCode = 2, TargetBallLocalPosition = new() { x = 2.1f, y = 2.1f, z = 2.1f }},
                new() { TargetBallAgentHashCode = 3, TargetBallLocalPosition = new() { x = 3.1f, y = 3.1f, z = 3.1f }},
            };
            
            var config = new CsvConfiguration(CultureInfo.InvariantCulture);
            using var writer = new StringWriter();
            using (var csv = new CsvWriter(writer, config))
            {
                csv.Context.RegisterClassMap<DefaultAutoMap<BehaviouralData>>();
                //csv.Context.AutoMap<BehaviouralData>().UpdateReferenceMaps<Vector3Map, Vector3>();
                //csv.Context.RegisterClassMap<BehaviouralDataMapExplicit>();
                csv.WriteRecords(data);
            }
            
            Console.WriteLine(writer);
        }   
    }
​
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Environment version: {0} ({1}), {2}.", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion);
            Console.WriteLine("OS Version: {0}, NewLine: {1}", System.Environment.OSVersion, JsonConvert.SerializeObject(Environment.NewLine));
            Console.WriteLine("{0} version: {1}", typeof(CsvReader).Assembly.GetName().Name,  typeof(CsvReader).Assembly.FullName);
            Console.WriteLine();
​
            try
            {
                TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with unhandled exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
    }
​
namespace UnityEngine
{
// COPY (and cleanup for fiddle) from the Unity Source Code 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;
    // *Undocumented*
    public const float kEpsilonNormalSqrt = 1e-15F;
    // X component of the vector.
    public float x { get; set; }
​
    // Y component of the vector.
    public float y { get; set; }
    // Z component of the vector.
    public float z { get; set; }
    
    // Access the x, y, z components using [0], [1], [2] respectively.
#if false   
    public float this[int index]
    {
        get
        {
            switch (index)
            {
                case 0:
                    return x;
                case 1:
                    return y;
                case 2:
                    return z;
                default:
                    throw new IndexOutOfRangeException("Invalid Vector3 index!");
            }
        }
​
        set
        {
            switch (index)
            {
                case 0:
                    x = value;
                    break;
                case 1:
                    y = value;
                    break;
                case 2:
                    z = value;
                    break;
                default:
                    throw new IndexOutOfRangeException("Invalid Vector3 index!");
            }
        }
    }
#endif
    // 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;
    }
​
    // 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;
    }
​
    // *undoc* --- we have normalized property now
    public static Vector3 Normalize(Vector3 value)
    {
        float mag = Magnitude(value);
        if (mag > kEpsilon)
            return value / mag;
        else
            return zero;
    }
​
    // Makes this vector have a ::ref::magnitude of 1.
    public void Normalize()
    {
        float mag = Magnitude(this);
        if (mag > kEpsilon)
            this = this / mag;
        else
            this = zero;
    }
​
    // Returns this vector with a ::ref::magnitude of 1 (RO).
    public Vector3 normalized
    {
        get
        {
            return Vector3.Normalize(this);
        }
    }
​
    // Dot Product of two vectors.
    public static float Dot(Vector3 lhs, Vector3 rhs)
    {
        return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
    }
​
    // *undoc* --- there's a property now
    public static float Magnitude(Vector3 vector)
    {
        return (float)Math.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
    }
​
    // Returns the length of this vector (RO).
    public float magnitude
    {
        get
        {
            return (float)Math.Sqrt(x * x + y * y + z * z);
        }
    }
​
    // *undoc* --- there's a property now
    public static float SqrMagnitude(Vector3 vector)
    {
        return vector.x * vector.x + vector.y * vector.y + vector.z * vector.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 upVector = new Vector3(0F, 1F, 0F);
    static readonly Vector3 downVector = new Vector3(0F, -1F, 0F);
    static readonly Vector3 leftVector = new Vector3(-1F, 0F, 0F);
    static readonly Vector3 rightVector = new Vector3(1F, 0F, 0F);
    static readonly Vector3 forwardVector = new Vector3(0F, 0F, 1F);
    static readonly Vector3 backVector = new Vector3(0F, 0F, -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(0, 0, 1)@@
    public static Vector3 forward
    {
        get
        {
            return forwardVector;
        }
    }
​
    public static Vector3 back
    {
        get
        {
            return backVector;
        }
    }
​
    // Shorthand for writing @@Vector3(0, 1, 0)@@
    public static Vector3 up
    {
        get
        {
            return upVector;
        }
    }
​
    public static Vector3 down
    {
        get
        {
            return downVector;
        }
    }
​
    public static Vector3 left
    {
        get
        {
            return leftVector;
        }
    }
​
    // Shorthand for writing @@Vector3(1, 0, 0)@@
    public static Vector3 right
    {
        get
        {
            return rightVector;
        }
    }
​
    // 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);
    }
}   
}
​

View IL Code