C#操作符（运算符）重载

仅贴出了二维平面坐标点的方法，三维坐标与此类似，欢迎博友们多多提出宝贵的意见

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace TestOperator {
    public class OperatorBase {
        public  OperatorBase() { }

        public new virtual string ToString()
        {
            return string.Empty;
        }

        public virtual IEnumerator GetEnumerator()
        {
            yield return this;
        }

        public virtual void Dispose()
        {
            GC.Collect();
        }

        public static OperatorBase operator /(OperatorBase stLeftOp, OperatorBase stRightOP)
        {
            return new OperatorBase();
        }

        public static OperatorBase operator *(OperatorBase stLeftOp, OperatorBase stRightOP)
        {
            return new OperatorBase();
        }

        public static OperatorBase operator +(OperatorBase stLeftOp, OperatorBase stRightOP)
        {
            return new OperatorBase();
        }

        public static OperatorBase operator -(OperatorBase stLeftOp, OperatorBase stRightOP)
        {
            return new OperatorBase();
        }

        public virtual bool? Equals(OperatorBase destOp)
        {
            return null;
        }

        public virtual int? Distance(OperatorBase destOp)
        {
            return null;
        }
    }
}

 

using System;
using System.Text;
using System.Collections;

namespace TestOperator {
    public class StOperator2 : OperatorBase {
        private double _x, _y;

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

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

        public StOperator2() : base() { }

        public StOperator2(double x, double y)
        {
            this._x = x;
            this._y = y;
        }

        public StOperator2(StOperator2 stOp)
        {
            _x = stOp.X;
            _y = stOp.Y;
        }

        public override string ToString()
        {
            return "(" + X + "," + Y + ")";
        }

        /// <summary>
        /// "+"号运算符的重载
        /// </summary>
        /// <param name="stLeftOp">左操作符</param>
        /// <param name="stRightOp">右操作符</param>
        /// <returns>经过运算后的操作符结果</returns>
        public static StOperator2 operator +(StOperator2 stLeftOp, StOperator2 stRightOp)
        {
            //TODO:此方法头部的operator关键字告诉编译器它是一个运算符的重载

            StOperator2 resultOp = new StOperator2(stLeftOp);

            resultOp.X += stRightOp.X;
            resultOp.Y += stRightOp.Y;

            return resultOp;
        }

        /// <summary>
        /// "-"号运算符的重载
        /// </summary>
        /// <param name="stLeftOp">左操作符</param>
        /// <param name="stRightOp">右操作符</param>
        /// <returns>经过运算后的操作符结果</returns>
        public static StOperator2 operator -(StOperator2 stLeftOp, StOperator2 stRightOp)
        {
            //TODO:此方法头部的operator关键字告诉编译器它是一个运算符的重载

            StOperator2 resultOp = new StOperator2(stLeftOp);

            resultOp.X -= stRightOp.X;
            resultOp.Y -= stRightOp.Y;

            return resultOp;
        }

        /// <summary>
        /// "*"号运算符的重载
        /// </summary>
        /// <param name="stLeftOp">左操作符</param>
        /// <param name="stRightOP">右操作符</param>
        /// <returns>经过运算后的操作符结果</returns>
        public static StOperator2 operator *(StOperator2 stLeftOp, StOperator2 stRightOP)
        {
            StOperator2 resultOp = new StOperator2(stLeftOp);

            resultOp.X *= stRightOP.X;
            resultOp.Y *= stRightOP.Y;

            return resultOp;
        }

        /// <summary>
        /// "/"号运算符的重载
        /// </summary>
        /// <param name="stLeftOp">左操作符</param>
        /// <param name="stRightOP">右操作符</param>
        /// <returns>经过运算后的操作符结果</returns>
        public static StOperator2 operator /(StOperator2 stLeftOp, StOperator2 stRightOP)
        {
            StOperator2 resultOp = new StOperator2(stLeftOp);

            resultOp.X /= stRightOP.X;
            resultOp.Y /= stRightOP.Y;

            return resultOp;
        }

        /// <summary>
        /// 比较操作符是否相等
        /// </summary>
        /// <param name="destOp">目标操作符</param>
        /// <returns>相等---return true否则---return false</returns>
        public override bool? Equals(OperatorBase destOp)
        {
            bool? bret = null;
            StOperator2 destStOp2 = (StOperator2)destOp;
            bret = (this.X == destStOp2.X) && (this.Y == destStOp2.Y) ? true : false;
            return bret;
        }

        /// <summary>
        /// 测算两点间距离
        /// </summary>
        /// <param name="destOp">目标操作符（目标点）</param>
        /// <returns>两点间距离</returns>
        public override int? Distance(OperatorBase destOp)
        {
            double? distance = null;
            StOperator2 stDestOp3 = (StOperator2)destOp;
            distance = Math.Sqrt(Math.Pow(this.X - stDestOp3.X, 2) + Math.Pow(this.Y - stDestOp3.Y, 2));
            return (int)distance;
        }
    }
}

====下面是调用的代码=========================================

OperatorBase stOp1 = new StOperator3 { X = -3.0, Y = 2.0};
OperatorBase stOp2 = new StOperator3 (1.2 , -1.5)

OperatorBase stOp3 = (StOperator3)stOp1 + (StOperator3)stOp2;
OperatorBase stOp4 = (StOperator3)stOp1 * (StOperator3)stOp3;
Console.WriteLine("Operator1=" + stOp1.ToString());
Console.WriteLine("Operator2=" + stOp2.ToString());
Console.WriteLine("Operator3=" + stOp3.ToString());
Console.WriteLine("Operator4=" + stOp4.ToString());

stOp3 = ((StOperator3)stOp1 - (StOperator3)stOp2);
stOp4 = (StOperator3)stOp1 / (StOperator3)stOp2;
Console.WriteLine("Operator3=" + stOp3.ToString());
Console.WriteLine("Operator4=" + stOp4.ToString());
OperatorBase[] stOps = new OperatorBase[4] { stOp4, stOp3, stOp2, stOp1 };
foreach (StOperator3 s in stOps) {
     Console.WriteLine(s.ToString());
     s.Dispose();
}