类与.NET兼容，但在Mono中不兼容

我必须构建自己的版本类。在.NET中它是CLS兼容的，但在Mono中它不是出于某种原因。你知道为什么吗

[Serializable]
public class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version>
{
    private int major;
    private int minor;
    private int revision;
    private int build;

    protected Version()
    {
    }

    public Version(int major, int minor)
    {
        Major = major;
        Minor = minor;
    }

    public Version(int major, int minor, int revision, int build) : this(major, minor)
    {
        Revision = revision;
        Build = build;
    }

    public Version(string version)
    {
        if (string.IsNullOrWhiteSpace(version))
        {
            throw new ControlInfluence.Exceptions.ArgumentNullStringException("version");
        }

        string[] parts = version.Split('.');
        if ((parts.Length != 4) && (parts.Length != 2))
        {
            throw new ArgumentException("'version' must have 2 or 4 numbers separated by '.'.", "version");
        }
        if (!int.TryParse(parts[0], out major))
        {
            throw new ArgumentException("'version' must have 2 or 4 numbers separated by '.'.", "version");
        }
        if (!int.TryParse(parts[1], out minor))
        {
            throw new ArgumentException("'version' must have 2 or 4 numbers separated by '.'.", "version");
        }
        if (!int.TryParse(parts[2], out revision))
        {
            throw new ArgumentException("'version' must have 2 or 4 numbers separated by '.'.", "version");
        }
        if (!int.TryParse(parts[3], out build))
        {
            throw new ArgumentException("'version' must have 2 or 4 numbers separated by '.'.", "version");
        }
    }

    public int Major
    {
        get
        {
            return major;
        }
        set
        {
            major = value;
        }
    }

    public int Minor
    {
        get
        {
            return minor;
        }
        set
        {
            minor = value;
        }
    }

    public int Build
    {
        get
        {
            return build;
        }
        set
        {
            build = value;
        }
    }

    public int Revision
    {
        get
        {
            return revision;
        }
        set
        {
            revision = value;
        }
    }

    public override string ToString()
    {
        return string.Format(CultureInfo.InvariantCulture, "{0}.{1}.{2}.{3}", Major, Minor, Revision, Build);
    }

    public static bool operator <(Version left, Version right)
    {
        if ((left == null) || (right == null))
        {
            return false;
        }

        return left.CompareTo(right) < 0;
    }

    public static bool operator >(Version left, Version right)
    {
        if ((left == null) || (right == null))
        {
            return false;
        }

        return left.CompareTo(right) > 0;
    }

    #region ICloneable Members

    public object Clone()
    {
        return new Version(Major, Minor, Revision, Build);
    }

    #endregion

    #region IComparable Members

    public int CompareTo(object obj)
    {
        Version other = obj as Version;
        if (other == null)
        {
            return -1;
        }
        return CompareTo(other);
    }

    #endregion

    #region IComparable<Version> Members

    public int CompareTo(Version other)
    {
        if (other == null)
        {
            return -1;
        }

        int compareMajor = Major.CompareTo(other.Major);
        if (compareMajor != 0)
        {
            return compareMajor;
        }
        int compareMinor = Minor.CompareTo(other.Minor);
        if (compareMinor != 0)
        {
            return compareMinor;
        }
        int compareRevision = Revision.CompareTo(other.Revision);
        if (compareRevision != 0)
        {
            return compareRevision;
        }
        return Build.CompareTo(other.Build);
    }

    #endregion

    #region IEquatable<Version> Members

    public bool Equals(Version other)
    {
        return CompareTo(other) == 0;
    }

    #endregion

    public override bool Equals(object obj)
    {
        Version version = obj as Version;
        if (version == null)
        {
            return false;
        }
        return Equals(version);
    }

    public static bool operator ==(Version left, Version right)
    {
        if (Object.ReferenceEquals(left, null) && Object.ReferenceEquals(right, null))
        {
            return true;
        }
        if (Object.ReferenceEquals(left, null) || Object.ReferenceEquals(right, null))
        {
            return false;
        }

        return left.Equals(right);
    }

    public static bool operator !=(Version left, Version right)
    {
        if ((left == null) || (right == null))
        {
            return false;
        }

        return !left.Equals(right);
    }
}

[可序列化]
公共类版本：iClonable、IComparable、IComparable、IEquatable
{
私立国际专业；
私家未成年人；
私人修订；
私人楼宇；
受保护版本（）
{
}
公共版本（整数大调、整数小调）
{
主修=主修；
未成年人=未成年人；
}
公共版本（int-major，int-minor，int-revision，int-build）：这个（major，minor）
{
修订=修订；
建造=建造；
}
公共版本（字符串版本）
{
if（string.IsNullOrWhiteSpace（version））
{
抛出新的ControlInfluence.Exceptions.ArgumentNullStringException（“版本”）；
}
string[]parts=version.Split（'.'）；
如果（（parts.Length！=4）和&（parts.Length！=2））
{
抛出新ArgumentException（“'version'必须有2或4个数字，以“.”分隔，“'version”）；
}
如果（！int.TryParse（部件[0]，输出主）
{
抛出新ArgumentException（“'version'必须有2或4个数字，以“.”分隔，“'version”）；
}
如果（！int.TryParse（第[1]部分，未成年人））
{
抛出新ArgumentException（“'version'必须有2或4个数字，以“.”分隔，“'version”）；
}
如果（！int.TryParse（第[2]部分，out版次））
{
抛出新ArgumentException（“'version'必须有2或4个数字，以“.”分隔，“'version”）；
}
如果（！int.TryParse（零件[3]，外部构建））
{
抛出新ArgumentException（“'version'必须有2或4个数字，以“.”分隔，“'version”）；
}
}
公共情报专业
{
得到
{
返回专业；
}
设置
{
主要=价值；
}
}
公共int小调
{
得到
{
返回未成年人；
}
设置
{
次要=价值；
}
}
公共int构建
{
得到
{
返回构建；
}
设置
{
构建=价值；
}
}
公共int修订
{
得到
{
返回修订；
}
设置
{
修订=价值；
}
}
公共重写字符串ToString（）
{
返回string.Format（CultureInfo.InvariantCulture，“{0}.{1}.{2}.{3}”，主要、次要、修订、生成）；
}
公共静态布尔运算符（左版、右版）
{
如果（（左==null）| |（右==null））
{
返回false；
}
返回左侧。比较（右侧）>0；
}
#区域可克隆成员
公共对象克隆（）
{
返回新版本（主要版本、次要版本、修订版本、构建版本）；
}
#端区
#区域i可比较成员
公共整数比较（对象对象对象）
{
版本其他=obj作为版本；
如果（其他==null）
{
返回-1；
}
返回比较（其他）；
}
#端区
#区域i可比较成员
公共整数比较（其他版本）
{
如果（其他==null）
{
返回-1；
}
int compareMajor=Major.CompareTo（其他.Major）；
如果（比较主！=0）
{
返回比较主；
}
int compareMinor=次要。比较到（其他。次要）；
如果（比较器！=0）
{
返回比较器；
}
int compareVision=修订版.CompareTo（其他.修订版）；
if（compareVision！=0）
{
回归比较视野；
}
返回Build.CompareTo（其他.Build）；
}
#端区
#区域可容纳成员
公共布尔等于（其他版本）
{
返回比较到（其他）==0；
}
#端区
公共覆盖布尔等于（对象对象对象）
{
版本=obj作为版本；
如果（版本==null）
{
返回false；
}
返回等于（版本）；
}
公共静态布尔运算符==（版本左，版本右）
{
if（Object.ReferenceEquals（左，null）和&Object.ReferenceEquals（右，null））
{
返回true；
}
if（Object.ReferenceEquals（左，空）| | Object.ReferenceEquals（右，空））
{
返回false；
}
返回左。等于（右）；
}
公共静态布尔运算符！=（左版、右版）
{
如果（（左==null）| |（右==null））
{
返回false；
}
返回！左。等于（右）；
}
}

---

我抛出的自定义异常类只是围绕ArgumentNullException的包装，它为我“自动填充”消息，这样他们就不会向消息中添加任何类型。

如果它在.NET中兼容CLS，但在Mono上不兼容，那它就是Mono中的一个bug。请在

什么不符合要求中提交错误？某种警告/错误可能会有帮助。没有说明原因，只是我已经想到了，但我想在提交错误报告之前确定它是一个错误。它肯定是一个错误，但可能已经在mono 3.x中修复了？你测试过上一个版本了吗？我相信在3.x上运行会检查的