在C#中创建IntVector2类时，我应该记住什么？

我目前正试图编写一些类来帮助我编写各种主要是2D的应用程序和/或游戏。我真正需要的东西之一（因为C#XNA“Point”类很烂）是一个IntVector2类，它与标准的XNA“Vector2”类非常相似

目前，我有这样的编码（休息后还有更多的东西）：

我应该做些什么来改进这门课？我曾考虑过使用结构而不是类，但我没有足够的经验来做出真正的决定

---

提前感谢。

如果你打算大量更新结构，我建议你使用它，因为这样它就不会有助于垃圾收集，如果你在xbox上开发，这会有点问题

magnize方法返回一个浮点，在Normalize中使用时不需要转换它

当你计算它的时候，你没有存储它的大小

您可以为点积和叉积添加方法，但不确定它们对整数向量是否有用

您可以为

ToString

创建覆盖（非常适合调试/打印到屏幕等），以及

==

等于
和
GetHashCode

我不确定我是否喜欢为
string
使用显式转换运算符。我认为这应该是ToString的用途。
如果你打算大量更新它，我会推荐一个struct，因为这样它就不会有助于垃圾收集，如果你在xbox上开发，这是一个小问题

magnize方法返回一个浮点，在Normalize中使用时不需要转换它

当你计算它的时候，你没有存储它的大小

您可以为点积和叉积添加方法，但不确定它们对整数向量是否有用

您可以为
ToString
创建覆盖（非常适合调试/打印到屏幕等），以及
==
等于
和
GetHashCode

我不确定我是否喜欢为
string
使用显式转换运算符。我认为这应该是
ToString
的目的。
如果你打算大量使用
新的
结构，我建议你使用
struct
，因为这样做不会导致垃圾收集，如果你在xbox上开发，这是一个小问题。您的
magnity
方法返回一个浮点值，在
Normalize
中使用时无需对其进行转换。当你计算它的时候，你没有存储它的大小。不要担心abs，因为正方形是正的。如果你打算大量使用
新的
结构，我建议你使用
结构，因为这样做不会导致垃圾收集，如果你在xbox上开发，这是一个小问题。您的
magnity
方法返回一个浮点值，在
Normalize
中使用时无需对其进行转换。当你计算它的时候，你并没有存储它的大小。因为正方形是正的，所以不用担心abs。当我试图消除代码中另一个早已消失的bug时，代码中出现了很多这样的问题。此外，我会考虑将“量值”作为一种方法，因为它所做的数学运算比简单的属性获取者通常会做的要多。使它成为一个方法意味着调用方它不是一个微不足道的属性getter…正如George所指出的，您还应该确保覆盖Equals和GetHashCode-我不能强调这对结构有多么重要！谢谢当我试图消除代码中另一个早已消失的bug时，代码中出现了很多这样的问题。此外，我会考虑将“量值”作为一种方法，因为它所做的数学运算比简单的属性获取者通常会做的要多。使它成为一个方法意味着调用方它不是一个微不足道的属性getter…正如George所指出的，您还应该确保覆盖Equals和GetHashCode-我不能强调这对结构有多么重要！
using System;
using Microsoft.Xna.Framework;

namespace LPG.Utilities
{
    public class IntVector2
    {
        //Properties
        public readonly int X = 0;
        public readonly int Y = 0;
        private float magnitude = 0;

        //Special properties

        public float Magnitude
        {
            get
            {
                if (this.magnitude == 0)
                {
                    return (float)Math.Sqrt((Math.Abs(this.X ^ 2) + Math.Abs(this.Y ^ 2)));
                }
                else
                {
                    return this.magnitude;
                }
            }
        }

        //Methods

        public Vector2 Normalize()
        {
            return new Vector2(this.X / (float)this.Magnitude, this.Y / (float)this.Magnitude);
        }

        //Constructors

        public IntVector2()
        {
        }

        public IntVector2(int Both)
        {
            this.X = Both;
            this.Y = Both;
        }

        public IntVector2(int X, int Y)
        {
            this.X = X;
            this.Y = Y;
        }

        //Casts

        public static implicit operator Vector2(IntVector2 From)
        {
            return new Vector2(From.X, From.Y);
        }

        public static implicit operator IntVector2(Vector2 From)
        {
            return new IntVector2((int)From.X, (int)From.Y);
        }

        public static implicit operator string(IntVector2 From)
        {
            return "(" + From.X + ", " + From.Y + ")";
        }

        //IntVector2-IntVector2 operators

        public static IntVector2 operator +(IntVector2 First, IntVector2 Second)
        {
            return new IntVector2(First.X + Second.X, First.Y + Second.Y);
        }

        public static IntVector2 operator -(IntVector2 First, IntVector2 Second)
        {
            return new IntVector2(First.X - Second.X, First.Y - Second.Y);
        }

        public static IntVector2 operator *(IntVector2 First, IntVector2 Second)
        {
            return new IntVector2(First.X * Second.X, First.Y * Second.Y);
        }

        public static IntVector2 operator /(IntVector2 First, IntVector2 Second)
        {
            return new IntVector2(First.X / Second.X, First.Y / Second.Y);
        }

        //IntVector2-int operators:

        public static IntVector2 operator +(IntVector2 First, int Second)
        {
            return new IntVector2(First.X + Second, First.Y + Second);
        }

        public static IntVector2 operator -(IntVector2 First, int Second)
        {
            return new IntVector2(First.X - Second, First.Y - Second);
        }

        public static IntVector2 operator *(IntVector2 First, int Second)
        {
            return new IntVector2(First.X * Second, First.Y * Second);
        }

        public static IntVector2 operator /(IntVector2 First, int Second)
        {
            return new IntVector2(First.X / Second, First.Y / Second);
        }
    }
}