C#基础之“==”运算符重载

学过C、C++、Java、C#等的人，一定对==有着深刻的认识。==左右两边相等，则返回布尔值true，否则，返回false。1==1返回True，1==2返回false。
然而，事情并非一直是这样子简单的。例如，我们用以下代码定义的了一个Vector类：

    public class Vector
    {
        private double _x;

        public double X
        {
            get { return _x; }
            set { _x = value; }
        }
        private double _y;

        public double Y
        {
            get { return _y; }
            set { _y = value; }
        }
        private double _z;

        public double Z
        {
            get { return _z; }
            set { _z = value; }
        }

        public Vector(double x, double y, double z)
        {
            _x = x;
            _y = y;
            _z = z;
        }

        public Vector(Vector rhs)
        {
            _x = rhs.X;
            _y = rhs.Y;
            _z = rhs.Z;
        }

        public override string ToString()
        {
            return "( " + _x.ToString() + " , " + _y.ToString() + " , " + _z.ToString() + " )";
        }
    }

我们来看以下代码：
Vector a=new Vector(1,2,3);
Vector b=new Vector(1,2,3);
return a==b;
这样的代码返回真还是假？呵呵，如果不作运算符重载，返回的一定是false。因为==会去判断a和b是不是同一个引用，也即他们是不是属于同一个地址。然而，通常这样的比较是没有意义的。相反，我们希望的是当a和b三个对应的值相等时，即认为它们相等。这样的话，我们在定义Vector类的时候，就需要添加对==运算符的重载，代码如下：

        public static bool operator ==(Vector left, Vector right)
        {
            if(left.X!=right.X) return false;
      if(left.Y!=right.Y) return false;
             if(left.Z!=right.Z) reutrn false;
             return true;
        }

编译运行。有趣的事情发生了，编译不能通过。原来==必须和!=成对出现。于是可以添加!=重载代码如下：

        public static bool operator !=(Vector left, Vector right)
        {
            if(left.X!=right.X) return true;
             if(left.Y!=right.Y) return true;
             if(left.Z!=right.Z) reutrn true;
             return false;
        }

但是，其实个这个重载不需要这样子写，可以简化如下：

        public static bool operator !=(Vector left, Vector right)
        {
                return !(left == right);
        }

因为在此类中已经做了对==的重载，对于不等的情况，只要取返就可以得到结果。好，编译，可以通过并且运行。但是，却得到了两张“黄牌”：有两个警告，分别是因为没有重写Equals方法和GetHashCode方法。于是，开始重写Equals方法如下：

        public override bool Equals(object obj)
        {
            return (this == obj as Vector);
        }

        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }

呵呵，这样的代码变得不好理解。换一种思路，这样子就好理解多了：

        public static bool operator ==(Vector left, Vector right)
        {
            return left.Equals(right);
        }
        public static bool operator !=(Vector left, Vector right)
        {
            return !left.Equals(right);
        }
        public override bool Equals(object obj)
        {
            if (this.X == ((Vector)obj).X && this.Y == ((Vector)obj).Y && this.Z == ((Vector)obj).Z) return true;
            return false;
        }

重写Equals方法来实现两个对象的比较，如果X、Y、Z分别相等，则返回true，否则返回false。对于==和!=重载，分别返回left.Equals(right)和!left.Equals(right)。
顺便附上完整的源代码：

    public class Vector
    {
        private double _x;

        public double X
        {
            get { return _x; }
            set { _x = value; }
        }
        private double _y;

        public double Y
        {
            get { return _y; }
            set { _y = value; }
        }
        private double _z;

        public double Z
        {
            get { return _z; }
            set { _z = value; }
        }

        public Vector(double x, double y, double z)
        {
            _x = x;
            _y = y;
            _z = z;
        }

        public Vector(Vector rhs)
        {
            _x = rhs.X;
            _y = rhs.Y;
            _z = rhs.Z;
        }

        public override string ToString()
        {
            return "( " + _x.ToString() + " , " + _y.ToString() + " , " + _z.ToString() + " )";
        }

        ==#region ==

        /**//// <summary>
        /// X、Y、Z是否均相等
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        public static bool operator ==(Vector left, Vector right)
        {
            return left.Equals(right);
        }

        /**//// <summary>
        /// 两个三维向量不相等
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        public static bool operator !=(Vector left, Vector right)
        {
            return !left.Equals(right);
        }

        /**//// <summary>
        /// 重载Equals
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if (this.X == ((Vector)obj).X && this.Y == ((Vector)obj).Y && this.Z == ((Vector)obj).Z) return true;
            return false;
        }


        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }
        #endregion
    }