클래스는 .NET에 대해서는 CLS 규격을 준수하지만 모노에는 적합하지 않습니다.

Question

자체 버전 클래스를 만들어야했습니다. .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); 
    } 
} 

사용자 정의 예외 클래스는 단순히 경우 ArgumentNullException 래퍼되는 "자동 채우기"그들이 정말 어떤 유형을 추가되지 않도록 저를위한 메시지.

Answer 1

.NET에서 CLS를 준수하지만 Mono에서는 호환되지 않는 경우 Mono의 버그입니다. 버그를 신고하십시오. http://bugzilla.xamarin.com