[Fork] 51703481/serializing-float-with-maximum-precision-without-changing-target-type | C# Online Compiler

[Fork] 51703481/serializing-float-with-maximum-precision-without-changing-target-type by dbc_MinLength

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters;
using System.IO;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.ComponentModel;


using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;	

using  Microsoft.Xna.Framework;

//https://stackoverflow.com/questions/51703481/serializing-float-with-maximum-precision-without-changing-target-type#51703481

    class TestClass
    {
        public static void Test()
        {
            //0xF9FF4FC1

            var bytes = new byte[] { 0xF9, 0xFF, 0x4F, 0xC1 }; // Big endian data

			Console.WriteLine("\nSerializing without JsonConverter: ");
			try
			{
            	Test(bytes, null);
			}
			catch (Exception ex)
			{
				Console.WriteLine("Round trip failed with error: " + ex.Message);
			}
			
			Console.WriteLine("\nSerializing WITH JsonConverter: ");
			Test(bytes, new JsonSerializerSettings { Converters = { new Vector2Converter() } });
        }

        public static void Test(byte[] bytes, JsonSerializerSettings settings)
        {
			Console.WriteLine("Input bytes: {0}.", string.Join(",", bytes.Select(b => "0x" + b.ToString("X"))));
			
            float myFloat = BitConverter.ToSingle(bytes, 0);

			Console.WriteLine("Input float: {0}.", myFloat.ToString("r"));

			var vector = new Vector2(myFloat, myFloat);
			
			var json = JsonConvert.SerializeObject(vector, settings);
			
			Console.WriteLine("Output JSON:");
			Console.WriteLine(json);

			var vector2 = JsonConvert.DeserializeObject<Vector2>(json, settings);

			Assert.IsTrue(myFloat == vector2.X, "myFloat == vector2.X failed!");			
			Assert.IsTrue(bytes.SequenceEqual(BitConverter.GetBytes(vector2.X)), "bytes.SequenceEqual(BitConverter.GetBytes(vector2.X)) failed!");
        }
    }

		public class Vector2Converter : JsonConverter
		{
			class Vector2DTO
			{
				public float X;
				public float Y;
			}
			
			public override bool CanConvert(Type objectType)
			{
				return objectType == typeof(Vector2) || objectType == typeof(Vector2?);
			}
	
			public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
			{
				// A JSON object is an unordered set of name/value pairs so the converter should handle
				// the X and Y properties in any order.
				var dto = serializer.Deserialize<Vector2DTO>(reader);
				if (dto == null)
					return null;
				return new Vector2(dto.X, dto.Y);
			}
	
			public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
			{
				var vec = (Vector2)value;
				serializer.Serialize(writer, new Vector2DTO { X = vec.X, Y = vec.Y });
			}
		}


	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Environment version: " + Environment.Version);
			Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
			Console.WriteLine();

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

    public class AssertionFailedException : System.Exception
    {
        public AssertionFailedException() : base() { }

        public AssertionFailedException(string s) : base(s) { }
    }

    public static class Assert
    {
        public static void IsTrue(bool value)
        {
            IsTrue(value, "failed");
        }

        public static void IsTrue(bool value, string message)
        {
            if (value == false)
                throw new AssertionFailedException(message ?? "failed");
        }
    }

namespace Microsoft.Xna.Framework
{
	/// <summary>
	/// Describes a 2D-vector.
	/// </summary>
	[Serializable]
	[TypeConverter(typeof(Vector2Converter))]
	public struct Vector2 : IEquatable<Vector2>
	{
		#region Public Static Properties

		/// <summary>
		/// Returns a <see cref="Vector2"/> with components 0, 0.
		/// </summary>
		public static Vector2 Zero
		{
			get
			{
				return zeroVector;
			}
		}

		/// <summary>
		/// Returns a <see cref="Vector2"/> with components 1, 1.
		/// </summary>
		public static Vector2 One
		{
			get
			{
				return unitVector;
			}
		}

		/// <summary>
		/// Returns a <see cref="Vector2"/> with components 1, 0.
		/// </summary>
		public static Vector2 UnitX
		{
			get
			{
				return unitXVector;
			}
		}

		/// <summary>
		/// Returns a <see cref="Vector2"/> with components 0, 1.
		/// </summary>
		public static Vector2 UnitY
		{
			get
			{
				return unitYVector;
			}
		}

		#endregion

		#region Internal Properties

		internal string DebugDisplayString
		{
			get
			{
				return string.Concat(
					X.ToString(), " ",
					Y.ToString()
				);
			}
		}

		#endregion

		#region Public Fields

		/// <summary>
		/// The x coordinate of this <see cref="Vector2"/>.
		/// </summary>
		public float X;

		/// <summary>
		/// The y coordinate of this <see cref="Vector2"/>.
		/// </summary>
		public float Y;

		#endregion

		#region Private Static Fields

		private static readonly Vector2 zeroVector = new Vector2(0f, 0f);
		private static readonly Vector2 unitVector = new Vector2(1f, 1f);
		private static readonly Vector2 unitXVector = new Vector2(1f, 0f);
		private static readonly Vector2 unitYVector = new Vector2(0f, 1f);

		#endregion

		#region Public Constructors

		/// <summary>
		/// Constructs a 2d vector with X and Y from two values.
		/// </summary>
		/// <param name="x">The x coordinate in 2d-space.</param>
		/// <param name="y">The y coordinate in 2d-space.</param>
		public Vector2(float x, float y)
		{
			this.X = x;
			this.Y = y;
		}

		/// <summary>
		/// Constructs a 2d vector with X and Y set to the same value.
		/// </summary>
		/// <param name="value">The x and y coordinates in 2d-space.</param>
		public Vector2(float value)
		{
			this.X = value;
			this.Y = value;
		}

		#endregion

		#region Public Methods

		/// <summary>
		/// Compares whether current instance is equal to specified <see cref="Object"/>.
		/// </summary>
		/// <param name="obj">The <see cref="Object"/> to compare.</param>
		/// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
		public override bool Equals(object obj)
		{
			return (obj is Vector2) && Equals((Vector2) obj);
		}

		/// <summary>
		/// Compares whether current instance is equal to specified <see cref="Vector2"/>.
		/// </summary>
		/// <param name="other">The <see cref="Vector2"/> to compare.</param>
		/// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
		public bool Equals(Vector2 other)
		{
			return (	X == other.X &&
					Y == other.Y	);
		}

		/// <summary>
		/// Gets the hash code of this <see cref="Vector2"/>.
		/// </summary>
		/// <returns>Hash code of this <see cref="Vector2"/>.</returns>
		public override int GetHashCode()
		{
			return X.GetHashCode() + Y.GetHashCode();
		}

		/// <summary>
		/// Returns the length of this <see cref="Vector2"/>.
		/// </summary>
		/// <returns>The length of this <see cref="Vector2"/>.</returns>
		public float Length()
		{
			return (float) Math.Sqrt((X * X) + (Y * Y));
		}

		/// <summary>
		/// Returns the squared length of this <see cref="Vector2"/>.
		/// </summary>
		/// <returns>The squared length of this <see cref="Vector2"/>.</returns>
		public float LengthSquared()
		{
			return (X * X) + (Y * Y);
		}

		/// <summary>
		/// Turns this <see cref="Vector2"/> to a unit vector with the same direction.
		/// </summary>
		public void Normalize()
		{
			float val = 1.0f / (float) Math.Sqrt((X * X) + (Y * Y));
			X *= val;
			Y *= val;
		}

		/// <summary>
		/// Returns a <see cref="String"/> representation of this <see cref="Vector2"/> in the format:
		/// {X:[<see cref="X"/>] Y:[<see cref="Y"/>]}
		/// </summary>
		/// <returns>A <see cref="String"/> representation of this <see cref="Vector2"/>.</returns>
		public override string ToString()
		{
			return (
				"{X:" + X.ToString() +
				" Y:" + Y.ToString() +
				"}"
			);
		}

		#endregion

		#region Public Static Methods

		#endregion

		#region Public Static Operators

		/// <summary>
		/// Inverts values in the specified <see cref="Vector2"/>.
		/// </summary>
		/// <param name="value">Source <see cref="Vector2"/> on the right of the sub sign.</param>
		/// <returns>Result of the inversion.</returns>
		public static Vector2 operator -(Vector2 value)
		{
			value.X = -value.X;
			value.Y = -value.Y;
			return value;
		}

		/// <summary>
		/// Compares whether two <see cref="Vector2"/> instances are equal.
		/// </summary>
		/// <param name="value1"><see cref="Vector2"/> instance on the left of the equal sign.</param>
		/// <param name="value2"><see cref="Vector2"/> instance on the right of the equal sign.</param>
		/// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
		public static bool operator ==(Vector2 value1, Vector2 value2)
		{
			return (	value1.X == value2.X &&
					value1.Y == value2.Y	);
		}

		/// <summary>
		/// Compares whether two <see cref="Vector2"/> instances are equal.
		/// </summary>
		/// <param name="value1"><see cref="Vector2"/> instance on the left of the equal sign.</param>
		/// <param name="value2"><see cref="Vector2"/> instance on the right of the equal sign.</param>
		/// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
		public static bool operator !=(Vector2 value1, Vector2 value2)
		{
			return !(value1 == value2);
		}

		/// <summary>
		/// Adds two vectors.
		/// </summary>
		/// <param name="value1">Source <see cref="Vector2"/> on the left of the add sign.</param>
		/// <param name="value2">Source <see cref="Vector2"/> on the right of the add sign.</param>
		/// <returns>Sum of the vectors.</returns>
		public static Vector2 operator +(Vector2 value1, Vector2 value2)
		{
			value1.X += value2.X;
			value1.Y += value2.Y;
			return value1;
		}

		/// <summary>
		/// Subtracts a <see cref="Vector2"/> from a <see cref="Vector2"/>.
		/// </summary>
		/// <param name="value1">Source <see cref="Vector2"/> on the left of the sub sign.</param>
		/// <param name="value2">Source <see cref="Vector2"/> on the right of the sub sign.</param>
		/// <returns>Result of the vector subtraction.</returns>
		public static Vector2 operator -(Vector2 value1, Vector2 value2)
		{
			value1.X -= value2.X;
			value1.Y -= value2.Y;
			return value1;
		}

		/// <summary>
		/// Multiplies the components of two vectors by each other.
		/// </summary>
		/// <param name="value1">Source <see cref="Vector2"/> on the left of the mul sign.</param>
		/// <param name="value2">Source <see cref="Vector2"/> on the right of the mul sign.</param>
		/// <returns>Result of the vector multiplication.</returns>
		public static Vector2 operator *(Vector2 value1, Vector2 value2)
		{
			value1.X *= value2.X;
			value1.Y *= value2.Y;
			return value1;
		}

		/// <summary>
		/// Multiplies the components of vector by a scalar.
		/// </summary>
		/// <param name="value">Source <see cref="Vector2"/> on the left of the mul sign.</param>
		/// <param name="scaleFactor">Scalar value on the right of the mul sign.</param>
		/// <returns>Result of the vector multiplication with a scalar.</returns>
		public static Vector2 operator *(Vector2 value, float scaleFactor)
		{
			value.X *= scaleFactor;
			value.Y *= scaleFactor;
			return value;
		}

		/// <summary>
		/// Multiplies the components of vector by a scalar.
		/// </summary>
		/// <param name="scaleFactor">Scalar value on the left of the mul sign.</param>
		/// <param name="value">Source <see cref="Vector2"/> on the right of the mul sign.</param>
		/// <returns>Result of the vector multiplication with a scalar.</returns>
		public static Vector2 operator *(float scaleFactor, Vector2 value)
		{
			value.X *= scaleFactor;
			value.Y *= scaleFactor;
			return value;
		}

		/// <summary>
		/// Divides the components of a <see cref="Vector2"/> by the components of another <see cref="Vector2"/>.
		/// </summary>
		/// <param name="value1">Source <see cref="Vector2"/> on the left of the div sign.</param>
		/// <param name="value2">Divisor <see cref="Vector2"/> on the right of the div sign.</param>
		/// <returns>The result of dividing the vectors.</returns>
		public static Vector2 operator /(Vector2 value1, Vector2 value2)
		{
			value1.X /= value2.X;
			value1.Y /= value2.Y;
			return value1;
		}

		/// <summary>
		/// Divides the components of a <see cref="Vector2"/> by a scalar.
		/// </summary>
		/// <param name="value1">Source <see cref="Vector2"/> on the left of the div sign.</param>
		/// <param name="divider">Divisor scalar on the right of the div sign.</param>
		/// <returns>The result of dividing a vector by a scalar.</returns>
		public static Vector2 operator /(Vector2 value1, float divider)
		{
			float factor = 1 / divider;
			value1.X *= factor;
			value1.Y *= factor;
			return value1;
		}

		#endregion
	}
	
	
	public class Vector2Converter : MathTypeConverter
	{
		#region Public Constructor

		public Vector2Converter() : base()
		{
			// FIXME: Initialize propertyDescriptions... how? -flibit
		}

		#endregion

		#region Public Methods

		public override object ConvertFrom(
			ITypeDescriptorContext context,
			CultureInfo culture,
			object value
		) {
			string s = value as string;
			if (s != null)
			{
				string[] v = s.Split(
					culture.TextInfo.ListSeparator.ToCharArray()
				);
				return new Vector2(
					float.Parse(v[0], culture),
					float.Parse(v[1], culture)
				);
			}
			return base.ConvertFrom(context, culture, value);
		}

		public override object ConvertTo(
			ITypeDescriptorContext context,
			CultureInfo culture,
			object value,
			Type destinationType
		) {
			if (destinationType == typeof(string))
			{
				Vector2 vec = (Vector2) value;
				return string.Join(
					culture.TextInfo.ListSeparator,
					new string[]
					{
						vec.X.ToString(culture),
						vec.Y.ToString(culture)
					}
				);
			}
			return base.ConvertTo(context, culture, value, destinationType);
		}

		public override object CreateInstance(
			ITypeDescriptorContext context,
			IDictionary propertyValues
		) {
			return (object) new Vector2(
				(float) propertyValues["X"],
				(float) propertyValues["Y"]
			);
		}

		#endregion
	}	

	public class MathTypeConverter : ExpandableObjectConverter
	{
		#region Protected Variables

		protected PropertyDescriptorCollection propertyDescriptions;

		protected bool supportStringConvert;

		#endregion

		#region Public Constructor

		public MathTypeConverter()
		{
			supportStringConvert = true;
		}

		#endregion

		#region Public Methods

		public override bool CanConvertFrom(
			ITypeDescriptorContext context,
			Type sourceType
		) {
			if (supportStringConvert && sourceType == typeof(string))
			{
				return true;
			}
			return base.CanConvertFrom(context, sourceType);
		}

		public override bool CanConvertTo(
			ITypeDescriptorContext context,
			Type destinationType
		) {
			if (supportStringConvert && destinationType == typeof(string))
			{
				return true;
			}
			return base.CanConvertTo(context, destinationType);
		}

		public override bool GetCreateInstanceSupported(
			ITypeDescriptorContext context
		) {
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(
			ITypeDescriptorContext context,
			Object value,
			Attribute[] attributes
		) {
			return propertyDescriptions;
		}

		public override bool GetPropertiesSupported(
			ITypeDescriptorContext context
		) {
			return true;
		}

		#endregion
	}
}

​x
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters;
using System.IO;
using System.Data;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.ComponentModel;
​
​
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;    
​
using  Microsoft.Xna.Framework;
​
//https://stackoverflow.com/questions/51703481/serializing-float-with-maximum-precision-without-changing-target-type#51703481
​
    class TestClass
    {
        public static void Test()
        {
            //0xF9FF4FC1
​
            var bytes = new byte[] { 0xF9, 0xFF, 0x4F, 0xC1 }; // Big endian data
​
            Console.WriteLine("\nSerializing without JsonConverter: ");
            try
            {
                Test(bytes, null);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Round trip failed with error: " + ex.Message);
            }
            
            Console.WriteLine("\nSerializing WITH JsonConverter: ");
            Test(bytes, new JsonSerializerSettings { Converters = { new Vector2Converter() } });
        }
​
        public static void Test(byte[] bytes, JsonSerializerSettings settings)
        {
            Console.WriteLine("Input bytes: {0}.", string.Join(",", bytes.Select(b => "0x" + b.ToString("X"))));
            
            float myFloat = BitConverter.ToSingle(bytes, 0);
​
            Console.WriteLine("Input float: {0}.", myFloat.ToString("r"));
​
            var vector = new Vector2(myFloat, myFloat);
            
            var json = JsonConvert.SerializeObject(vector, settings);
            
            Console.WriteLine("Output JSON:");
            Console.WriteLine(json);
​
            var vector2 = JsonConvert.DeserializeObject<Vector2>(json, settings);
​
            Assert.IsTrue(myFloat == vector2.X, "myFloat == vector2.X failed!");            
            Assert.IsTrue(bytes.SequenceEqual(BitConverter.GetBytes(vector2.X)), "bytes.SequenceEqual(BitConverter.GetBytes(vector2.X)) failed!");
        }
    }
​
        public class Vector2Converter : JsonConverter
        {
            class Vector2DTO
            {
                public float X;
                public float Y;
            }
            
            public override bool CanConvert(Type objectType)
            {
                return objectType == typeof(Vector2) || objectType == typeof(Vector2?);
            }
    
            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                // A JSON object is an unordered set of name/value pairs so the converter should handle
                // the X and Y properties in any order.
                var dto = serializer.Deserialize<Vector2DTO>(reader);
                if (dto == null)
                    return null;
                return new Vector2(dto.X, dto.Y);
            }
    
            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                var vec = (Vector2)value;
                serializer.Serialize(writer, new Vector2DTO { X = vec.X, Y = vec.Y });
            }
        }
​
​
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Environment version: " + Environment.Version);
            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);
            Console.WriteLine();
​
            try
            {
                TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with unhandled exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
    }
​
    public class AssertionFailedException : System.Exception
    {
        public AssertionFailedException() : base() { }
​
        public AssertionFailedException(string s) : base(s) { }
    }
​
    public static class Assert
    {
        public static void IsTrue(bool value)
        {
            IsTrue(value, "failed");
        }
​
        public static void IsTrue(bool value, string message)
        {
            if (value == false)
                throw new AssertionFailedException(message ?? "failed");
        }
    }
​
namespace Microsoft.Xna.Framework
{
    /// <summary>
    /// Describes a 2D-vector.
    /// </summary>
    [Serializable]
    [TypeConverter(typeof(Vector2Converter))]
    public struct Vector2 : IEquatable<Vector2>
    {
        #region Public Static Properties
​
        /// <summary>
        /// Returns a <see cref="Vector2"/> with components 0, 0.
        /// </summary>
        public static Vector2 Zero
        {
            get
            {
                return zeroVector;
            }
        }
​
        /// <summary>
        /// Returns a <see cref="Vector2"/> with components 1, 1.
        /// </summary>
        public static Vector2 One
        {
            get
            {
                return unitVector;
            }
        }
​
        /// <summary>
        /// Returns a <see cref="Vector2"/> with components 1, 0.
        /// </summary>
        public static Vector2 UnitX
        {
            get
            {
                return unitXVector;
            }
        }
​
        /// <summary>
        /// Returns a <see cref="Vector2"/> with components 0, 1.
        /// </summary>
        public static Vector2 UnitY
        {
            get
            {
                return unitYVector;
            }
        }
​
        #endregion
​
        #region Internal Properties
​
        internal string DebugDisplayString
        {
            get
            {
                return string.Concat(
                    X.ToString(), " ",
                    Y.ToString()
                );
            }
        }
​
        #endregion
​
        #region Public Fields
​
        /// <summary>
        /// The x coordinate of this <see cref="Vector2"/>.
        /// </summary>
        public float X;
​
        /// <summary>
        /// The y coordinate of this <see cref="Vector2"/>.
        /// </summary>
        public float Y;
​
        #endregion
​
        #region Private Static Fields
​
        private static readonly Vector2 zeroVector = new Vector2(0f, 0f);
        private static readonly Vector2 unitVector = new Vector2(1f, 1f);
        private static readonly Vector2 unitXVector = new Vector2(1f, 0f);
        private static readonly Vector2 unitYVector = new Vector2(0f, 1f);
​
        #endregion
​
        #region Public Constructors
​
        /// <summary>
        /// Constructs a 2d vector with X and Y from two values.
        /// </summary>
        /// <param name="x">The x coordinate in 2d-space.</param>
        /// <param name="y">The y coordinate in 2d-space.</param>
        public Vector2(float x, float y)
        {
            this.X = x;
            this.Y = y;
        }
​
        /// <summary>
        /// Constructs a 2d vector with X and Y set to the same value.
        /// </summary>
        /// <param name="value">The x and y coordinates in 2d-space.</param>
        public Vector2(float value)
        {
            this.X = value;
            this.Y = value;
        }
​
        #endregion
​
        #region Public Methods
​
        /// <summary>
        /// Compares whether current instance is equal to specified <see cref="Object"/>.
        /// </summary>
        /// <param name="obj">The <see cref="Object"/> to compare.</param>
        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
        public override bool Equals(object obj)
        {
            return (obj is Vector2) && Equals((Vector2) obj);
        }
​
        /// <summary>
        /// Compares whether current instance is equal to specified <see cref="Vector2"/>.
        /// </summary>
        /// <param name="other">The <see cref="Vector2"/> to compare.</param>
        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
        public bool Equals(Vector2 other)
        {
            return (    X == other.X &&
                    Y == other.Y    );
        }
​
        /// <summary>
        /// Gets the hash code of this <see cref="Vector2"/>.
        /// </summary>
        /// <returns>Hash code of this <see cref="Vector2"/>.</returns>
        public override int GetHashCode()
        {
            return X.GetHashCode() + Y.GetHashCode();
        }
​
        /// <summary>
        /// Returns the length of this <see cref="Vector2"/>.
        /// </summary>
        /// <returns>The length of this <see cref="Vector2"/>.</returns>
        public float Length()
        {
            return (float) Math.Sqrt((X * X) + (Y * Y));
        }
​
        /// <summary>
        /// Returns the squared length of this <see cref="Vector2"/>.
        /// </summary>
        /// <returns>The squared length of this <see cref="Vector2"/>.</returns>
        public float LengthSquared()
        {
            return (X * X) + (Y * Y);
        }
​
        /// <summary>
        /// Turns this <see cref="Vector2"/> to a unit vector with the same direction.
        /// </summary>
        public void Normalize()
        {
            float val = 1.0f / (float) Math.Sqrt((X * X) + (Y * Y));
            X *= val;
            Y *= val;
        }
​
        /// <summary>
        /// Returns a <see cref="String"/> representation of this <see cref="Vector2"/> in the format:
        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>]}
        /// </summary>
        /// <returns>A <see cref="String"/> representation of this <see cref="Vector2"/>.</returns>
        public override string ToString()
        {
            return (
                "{X:" + X.ToString() +
                " Y:" + Y.ToString() +
                "}"
            );
        }
​
        #endregion
​
        #region Public Static Methods
​
        #endregion
​
        #region Public Static Operators
​
        /// <summary>
        /// Inverts values in the specified <see cref="Vector2"/>.
        /// </summary>
        /// <param name="value">Source <see cref="Vector2"/> on the right of the sub sign.</param>
        /// <returns>Result of the inversion.</returns>
        public static Vector2 operator -(Vector2 value)
        {
            value.X = -value.X;
            value.Y = -value.Y;
            return value;
        }
​
        /// <summary>
        /// Compares whether two <see cref="Vector2"/> instances are equal.
        /// </summary>
        /// <param name="value1"><see cref="Vector2"/> instance on the left of the equal sign.</param>
        /// <param name="value2"><see cref="Vector2"/> instance on the right of the equal sign.</param>
        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
        public static bool operator ==(Vector2 value1, Vector2 value2)
        {
            return (    value1.X == value2.X &&
                    value1.Y == value2.Y    );
        }
​
        /// <summary>
        /// Compares whether two <see cref="Vector2"/> instances are equal.
        /// </summary>
        /// <param name="value1"><see cref="Vector2"/> instance on the left of the equal sign.</param>
        /// <param name="value2"><see cref="Vector2"/> instance on the right of the equal sign.</param>
        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
        public static bool operator !=(Vector2 value1, Vector2 value2)
        {
            return !(value1 == value2);
        }
​
        /// <summary>
        /// Adds two vectors.
        /// </summary>
        /// <param name="value1">Source <see cref="Vector2"/> on the left of the add sign.</param>
        /// <param name="value2">Source <see cref="Vector2"/> on the right of the add sign.</param>
        /// <returns>Sum of the vectors.</returns>
        public static Vector2 operator +(Vector2 value1, Vector2 value2)
        {
            value1.X += value2.X;
            value1.Y += value2.Y;
            return value1;
        }
​
        /// <summary>
        /// Subtracts a <see cref="Vector2"/> from a <see cref="Vector2"/>.
        /// </summary>
        /// <param name="value1">Source <see cref="Vector2"/> on the left of the sub sign.</param>
        /// <param name="value2">Source <see cref="Vector2"/> on the right of the sub sign.</param>
        /// <returns>Result of the vector subtraction.</returns>
        public static Vector2 operator -(Vector2 value1, Vector2 value2)
        {
            value1.X -= value2.X;
            value1.Y -= value2.Y;
            return value1;
        }
​
        /// <summary>
        /// Multiplies the components of two vectors by each other.
        /// </summary>
        /// <param name="value1">Source <see cref="Vector2"/> on the left of the mul sign.</param>
        /// <param name="value2">Source <see cref="Vector2"/> on the right of the mul sign.</param>
        /// <returns>Result of the vector multiplication.</returns>
        public static Vector2 operator *(Vector2 value1, Vector2 value2)
        {
            value1.X *= value2.X;
            value1.Y *= value2.Y;
            return value1;
        }
​
        /// <summary>
        /// Multiplies the components of vector by a scalar.
        /// </summary>
        /// <param name="value">Source <see cref="Vector2"/> on the left of the mul sign.</param>
        /// <param name="scaleFactor">Scalar value on the right of the mul sign.</param>
        /// <returns>Result of the vector multiplication with a scalar.</returns>
        public static Vector2 operator *(Vector2 value, float scaleFactor)
        {
            value.X *= scaleFactor;
            value.Y *= scaleFactor;
            return value;
        }
​
        /// <summary>
        /// Multiplies the components of vector by a scalar.
        /// </summary>
        /// <param name="scaleFactor">Scalar value on the left of the mul sign.</param>
        /// <param name="value">Source <see cref="Vector2"/> on the right of the mul sign.</param>
        /// <returns>Result of the vector multiplication with a scalar.</returns>
        public static Vector2 operator *(float scaleFactor, Vector2 value)
        {
            value.X *= scaleFactor;
            value.Y *= scaleFactor;
            return value;
        }
​
        /// <summary>
        /// Divides the components of a <see cref="Vector2"/> by the components of another <see cref="Vector2"/>.
        /// </summary>
        /// <param name="value1">Source <see cref="Vector2"/> on the left of the div sign.</param>
        /// <param name="value2">Divisor <see cref="Vector2"/> on the right of the div sign.</param>
        /// <returns>The result of dividing the vectors.</returns>
        public static Vector2 operator /(Vector2 value1, Vector2 value2)
        {
            value1.X /= value2.X;
            value1.Y /= value2.Y;
            return value1;
        }
​
        /// <summary>
        /// Divides the components of a <see cref="Vector2"/> by a scalar.
        /// </summary>
        /// <param name="value1">Source <see cref="Vector2"/> on the left of the div sign.</param>
        /// <param name="divider">Divisor scalar on the right of the div sign.</param>
        /// <returns>The result of dividing a vector by a scalar.</returns>
        public static Vector2 operator /(Vector2 value1, float divider)
        {
            float factor = 1 / divider;
            value1.X *= factor;
            value1.Y *= factor;
            return value1;
        }
​
        #endregion
    }
    
    
    public class Vector2Converter : MathTypeConverter
    {
        #region Public Constructor
​
        public Vector2Converter() : base()
        {
            // FIXME: Initialize propertyDescriptions... how? -flibit
        }
​
        #endregion
​
        #region Public Methods
​
        public override object ConvertFrom(
            ITypeDescriptorContext context,
            CultureInfo culture,
            object value
        ) {
            string s = value as string;
            if (s != null)
            {
                string[] v = s.Split(
                    culture.TextInfo.ListSeparator.ToCharArray()
                );
                return new Vector2(
                    float.Parse(v[0], culture),
                    float.Parse(v[1], culture)
                );
            }
            return base.ConvertFrom(context, culture, value);
        }
​
        public override object ConvertTo(
            ITypeDescriptorContext context,
            CultureInfo culture,
            object value,
            Type destinationType
        ) {
            if (destinationType == typeof(string))
            {
                Vector2 vec = (Vector2) value;
                return string.Join(
                    culture.TextInfo.ListSeparator,
                    new string[]
                    {
                        vec.X.ToString(culture),
                        vec.Y.ToString(culture)
                    }
                );
            }
            return base.ConvertTo(context, culture, value, destinationType);
        }
​
        public override object CreateInstance(
            ITypeDescriptorContext context,
            IDictionary propertyValues
        ) {
            return (object) new Vector2(
                (float) propertyValues["X"],
                (float) propertyValues["Y"]
            );
        }
​
        #endregion
    }   
​
    public class MathTypeConverter : ExpandableObjectConverter
    {
        #region Protected Variables
​
        protected PropertyDescriptorCollection propertyDescriptions;
​
        protected bool supportStringConvert;
​
        #endregion
​
        #region Public Constructor
​
        public MathTypeConverter()
        {
            supportStringConvert = true;
        }
​
        #endregion
​
        #region Public Methods
​
        public override bool CanConvertFrom(
            ITypeDescriptorContext context,
            Type sourceType
        ) {
            if (supportStringConvert && sourceType == typeof(string))
            {
                return true;
            }
            return base.CanConvertFrom(context, sourceType);
        }
​
        public override bool CanConvertTo(
            ITypeDescriptorContext context,
            Type destinationType
        ) {
            if (supportStringConvert && destinationType == typeof(string))
            {
                return true;
            }
            return base.CanConvertTo(context, destinationType);
        }
​
        public override bool GetCreateInstanceSupported(
            ITypeDescriptorContext context
        ) {
            return true;
        }
​
        public override PropertyDescriptorCollection GetProperties(
            ITypeDescriptorContext context,
            Object value,
            Attribute[] attributes
        ) {
            return propertyDescriptions;
        }
​
        public override bool GetPropertiesSupported(
            ITypeDescriptorContext context
        ) {
            return true;
        }
​
        #endregion
    }
}
​

View IL Code