예제 #1
0
        public Int32 CompareTo(AppVersion other)
        {
            Int32 major = Major.CompareTo(other.Major);

            if (major != 0)
            {
                return(major);
            }

            Int32 minor = Minor.CompareTo(other.Minor);

            if (minor != 0)
            {
                return(minor);
            }

            Int32 patch = Patch.CompareTo(other.Patch);

            if (patch != 0)
            {
                return(patch);
            }

            return(BuildTime?.CompareTo(other.BuildTime) ?? -1);
        }
예제 #2
0
        /// <summary>
        /// Compares two semantic versions by precedence as defined in the SemVer spec. Versions
        /// that differ only by build metadata have the same precedence.
        /// </summary>
        /// <param name="other">The semantic version.</param>
        /// <returns>
        /// A value that indicates the relative order of the objects being compared.
        /// The return value has these meanings:
        ///  Less than zero: This instance precedes <paramref name="other" /> in the sort order.
        ///  Zero: This instance occurs in the same position in the sort order as <paramref name="other" />.
        ///  Greater than zero: This instance follows <paramref name="other" /> in the sort order.
        /// </returns>
        private int CompareByPrecedence(SemVersion other)
        {
            if (other is null)
            {
                return(1);
            }

            var r = Major.CompareTo(other.Major);

            if (r != 0)
            {
                return(r);
            }

            r = Minor.CompareTo(other.Minor);
            if (r != 0)
            {
                return(r);
            }

            r = Patch.CompareTo(other.Patch);
            if (r != 0)
            {
                return(r);
            }

            return(CompareComponent(Prerelease, other.Prerelease, true));
        }
        public int CompareTo(Semver other)
        {
            var difference = Major.CompareTo(other.Major);

            if (difference != 0)
            {
                return(difference);
            }

            difference = Minor.CompareTo(other.Minor);
            if (difference != 0)
            {
                return(difference);
            }

            difference = Patch.CompareTo(other.Patch);
            if (difference != 0)
            {
                return(difference);
            }

            difference = Prerelease.CompareTo(other.Prerelease);
            if (difference != 0)
            {
                return(difference);
            }

            return(Trailer.CompareTo(other.Trailer));
        }
예제 #4
0
        public int CompareTo(object obj)
        {
            if (obj == null)
            {
                return(1);
            }

            if (!(obj is ISemVer other))
            {
                throw new ArgumentOutOfRangeException("object is not ISemVer");
            }

            int majorResult = Major.CompareTo(other.Major);

            if (majorResult != 0)
            {
                return(majorResult);
            }

            int minorResult = Minor.CompareTo(other.Minor);

            if (minorResult != 0)
            {
                return(minorResult);
            }

            int patchResult = Patch.CompareTo(other.Patch);

            if (patchResult != 0)
            {
                return(patchResult);
            }

            return(ReleaseFlag.CompareTo(other.ReleaseFlag));
        }
        public int CompareTo(object obj)
        {
            if (obj == null)
            {
                throw new ArgumentNullException(nameof(obj));
            }

            var other = (SemanticVersion)obj;

            var result = Major.CompareTo(other.Major);

            if (result != 0)
            {
                return(result);
            }

            result = Minor.CompareTo(other.Minor);
            if (result != 0)
            {
                return(result);
            }

            result = Patch.CompareTo(other.Patch);
            if (result != 0)
            {
                return(result);
            }

            return(CompareComponent(Prerelease, other.Prerelease, true));
        }
예제 #6
0
        /// <summary>
        /// Compares to semantic versions by precedence. This does the same as a Equals, but ignores the build information.
        /// </summary>
        /// <param name="other">The semantic version.</param>
        /// <returns>
        /// A value that indicates the relative order of the objects being compared.
        /// The return value has these meanings: Value Meaning Less than zero
        ///  This instance precedes <paramref name="other" /> in the version precedence.
        ///  Zero This instance has the same precedence as <paramref name="other" />. i
        ///  Greater than zero This instance has creater precedence as <paramref name="other" />.
        /// </returns>
        public int CompareByPrecedence(SemVersion other)
        {
            if (ReferenceEquals(other, null))
            {
                return(1);
            }

            var r = Major.CompareTo(other.Major);

            if (r != 0)
            {
                return(r);
            }

            r = Minor.CompareTo(other.Minor);
            if (r != 0)
            {
                return(r);
            }

            r = Patch.CompareTo(other.Patch);
            if (r != 0)
            {
                return(r);
            }

            r = CompareComponent(Prerelease, other.Prerelease, true);
            return(r);
        }
예제 #7
0
        public int CompareTo(object obj)
        {
            if (!(obj is SemanticVersion other))
            {
                return(-1);
            }

            if (Major != other.Major)
            {
                return(Major.CompareTo(other.Major));
            }
            if (Minor != other.Minor)
            {
                return(Minor.CompareTo(other.Minor));
            }
            if (Patch != other.Patch)
            {
                return(Patch.CompareTo(other.Patch));
            }
            if (PreReleaseTag != other.PreReleaseTag)
            {
                return(string.Compare(PreReleaseTag, other.PreReleaseTag, StringComparison.Ordinal));
            }
            // IMPORTANT: According to the SemVer 2.0 standard, we do not compare based on the build metadata.
            return(0);
        }
        /// <summary>
        /// Compares this instance to another <see cref="ReleaseVersion"/> and returns an indication of their relative precedence.
        /// Dot-separated prerelease labels are individually compared. Versions that only differ in build metadata have the same
        /// precedence.
        /// </summary>
        /// <param name="value">The <see cref="ReleaseVersion"/> to compare against this instance.</param>
        /// <returns>Returns a signed integer indicating whether this instance precedes, follows or appears in the same position in
        /// the sort order as the specified <paramref name="value"/>.
        /// </returns>
        public int ComparePrecedenceTo(ReleaseVersion value)
        {
            // Versions that only differ in build metadata have the same precedence.
            // Reference: https://semver.org/#spec-item-10
            if (value is null)
            {
                return(1);
            }

            int result = Major.CompareTo(value.Major);

            if (result != 0)
            {
                return(result);
            }

            result = Minor.CompareTo(value.Minor);

            if (result != 0)
            {
                return(result);
            }

            result = Patch.CompareTo(value.Patch);

            if (result != 0)
            {
                return(result);
            }

            return(CompareIdentifiers(Prerelease, value.Prerelease));
        }
        public int CompareTo(Semver2Version other)
        {
            var majorMinorComparison = base.CompareTo(other);

            if (majorMinorComparison == 0)
            {
                var patchComparison = Patch.CompareTo(other.Patch);
                if (patchComparison == 0)
                {
                    var preReleaseComparison = PreRelease.CompareTo(other.PreRelease);
                    if (preReleaseComparison == 0)
                    {
                        return(Build.CompareTo(other.Build));
                    }
                    else
                    {
                        return(preReleaseComparison);
                    }
                }

                return(patchComparison);
            }

            return(majorMinorComparison);
        }
예제 #10
0
        /// <summary>
        ///   Compares the current object with another object of the same type.
        /// </summary>
        /// <returns> A value that indicates the relative order of the objects being compared. The return value has the following meanings: Value Meaning Less than zero This object is less than the <paramref
        ///    name="other" /> parameter.Zero This object is equal to <paramref name="other" /> . Greater than zero This object is greater than <paramref
        ///    name="other" /> . </returns>
        /// <param name="other"> An object to compare with this object. </param>
        public virtual int CompareTo(SemanticVersion other)
        {
            if (other == null)
            {
                return(1);
            }

            if (Major != other.Major)
            {
                return(Major.CompareTo(other.Major));
            }
            if (Minor != other.Minor)
            {
                return(Minor.CompareTo(other.Minor));
            }
            if (Patch != other.Patch)
            {
                return(Patch.CompareTo(other.Patch));
            }

            int i = CompareLabels(PreRelease, other.PreRelease, true);

            if (i != 0)
            {
                return(i);
            }

            return(CompareLabels(Build, other.Build, false));
        }
예제 #11
0
        public int CompareTo(SemVersion other)
        {
            var result = Major.CompareTo(other.Major);

            if (result != 0)
            {
                return(result);
            }

            result = Minor.CompareTo(other.Minor);
            if (result != 0)
            {
                return(result);
            }

            result = Patch.CompareTo(other.Patch);
            if (result != 0)
            {
                return(result);
            }

            result = CompareExtension(Prerelease, other.Prerelease, true);

            if (result != 0)
            {
                return(result);
            }

            return(0);
        }
        public int CompareTo(SemanticVersion other)
        {
            var result = Major.CompareTo(other.Major);

            if (result != 0)
            {
                return(result);
            }

            result = Minor.CompareTo(other.Minor);
            if (result != 0)
            {
                return(result);
            }

            result = Patch.CompareTo(other.Patch);
            if (result != 0)
            {
                return(result);
            }

            result = PreRelease.CompareTo(other.PreRelease);
            if (result != 0)
            {
                return(result);
            }

            return(Build.CompareTo(other.Build));
        }
예제 #13
0
 /// <summary>
 /// Compares this object with another SemanticVersion according to Semver 2.0.0 precedence rules.
 /// </summary>
 /// <param name="other">another SemanticVersion</param>
 /// <returns>0 if equal, -1 if the current object has lower precedence, or 1 if the current object has higher precedence</returns>
 public int ComparePrecedence(SemanticVersion other)
 {
     if (Major != other.Major)
     {
         return(Major.CompareTo(other.Major));
     }
     if (Minor != other.Minor)
     {
         return(Minor.CompareTo(other.Minor));
     }
     if (Patch != other.Patch)
     {
         return(Patch.CompareTo(other.Patch));
     }
     if (String.IsNullOrEmpty(Prerelease) && String.IsNullOrEmpty(other.Prerelease))
     {
         return(0); // build component is ignored in precedence comparison
     }
     // *no* prerelease component always has higher precedence than *any* prerelease component
     if (String.IsNullOrEmpty(Prerelease))
     {
         return(1);
     }
     if (String.IsNullOrEmpty(other.Prerelease))
     {
         return(-1);
     }
     return(CompareIdentifiers(Prerelease.Split('.'), other.Prerelease.Split('.')));
 }
예제 #14
0
        private int CompareVersionInformation(SemanticVersion other)
        {
            int majorCompare = Major.CompareTo(other.Major);

            if (majorCompare != 0)
            {
                return(majorCompare);
            }

            int minorCompare = Minor.CompareTo(other.Minor);

            if (minorCompare != 0)
            {
                return(minorCompare);
            }

            int patchCompare = Patch.CompareTo(other.Patch);

            if (patchCompare != 0)
            {
                return(patchCompare);
            }

            return(0);
        }
예제 #15
0
 public int CompareTo(SematicVersion sematicVersion)
 {
     if (sematicVersion != null)
     {
         int result = Major.CompareTo(sematicVersion.Major);
         if (result == 0)
         {
             result = Minor.CompareTo(sematicVersion.Minor);
             if (result == 0)
             {
                 result = Patch.CompareTo(sematicVersion.Patch);
                 if (result == 0)
                 {
                     if (HasPreRelease == false && sematicVersion.HasPreRelease == false)
                     {
                         result = 0;
                     }
                     else if (HasPreRelease && !sematicVersion.HasPreRelease)
                     {
                         result = -1;
                     }
                     else if (!HasPreRelease && sematicVersion.HasPreRelease)
                     {
                         result = 1;
                     }
                     else
                     {
                         string[] a = PreRelease.ToArray();
                         string[] b = sematicVersion.PreRelease.ToArray();
                         for (int i = 0; i < a.Length && i < b.Length; i++)
                         {
                             result = a[i].CompareTo(b[i]);
                             if (result != 0)
                             {
                                 break;
                             }
                         }
                         if (result == 0)
                         {
                             if (a.Length > b.Length)
                             {
                                 result = 1;
                             }
                             else if (a.Length < b.Length)
                             {
                                 result = -1;
                             }
                         }
                     }
                 }
             }
         }
         return(result);
     }
     else
     {
         throw new ArgumentNullException();
     }
 }
예제 #16
0
        private IEnumerable <int> PartComparisons(Version other)
        {
            yield return(Major.CompareTo(other.Major));

            yield return(Minor.CompareTo(other.Minor));

            yield return(Patch.CompareTo(other.Patch));
        }
예제 #17
0
    public int CompareTo(BuildVersion other)
    {
        if ((Revision == 0) && (other.Revision == 0))
        {
            if (!IsDevMark && other.IsDevMark)
            {
                return(-1);
            }
            else if (IsDevMark && !other.IsDevMark)
            {
                return(1);
            }
        }

        int majorCompare = Major.CompareTo(other.Major);

        if (majorCompare != 0)
        {
            return(majorCompare);
        }

        int minorCompare = Minor.CompareTo(other.Minor);

        if (minorCompare != 0)
        {
            return(minorCompare);
        }

        int patchCompare = Patch.CompareTo(other.Patch);

        if (patchCompare != 0)
        {
            return(patchCompare);
        }

        int revisionCompare = Revision.CompareTo(other.Revision);

        if (revisionCompare != 0)
        {
            return(revisionCompare);
        }

        string normTag      = Tag ?? string.Empty;
        string normOtherTag = other.Tag ?? string.Empty;

        if (normTag != normOtherTag)
        {
            return(normTag.CompareTo(normOtherTag));
        }

        return(0);
    }
예제 #18
0
        public int CompareTo(VersionInfo other)
        {
            int majorCompare = Major.CompareTo(other?.Major);

            if (majorCompare != 0)
            {
                return(majorCompare);
            }

            int minorCompare = Minor.CompareTo(other?.Minor);

            if (minorCompare != 0)
            {
                return(minorCompare);
            }

            int patchCompare = Patch.CompareTo(other?.Patch);

            if (patchCompare != 0)
            {
                return(patchCompare);
            }

            int revisionCompare = BuildNumber.CompareTo(other?.BuildNumber);

            if (revisionCompare != 0)
            {
                return(revisionCompare);
            }

            if (BuildNumber == 0 && other?.BuildNumber == 0)
            {
                if (!IsBasedOnDevMark && other.IsBasedOnDevMark)
                {
                    return(1);
                }
                else if (IsBasedOnDevMark && !other.IsBasedOnDevMark)
                {
                    return(-1);
                }
            }

            string preReleaseTag      = PreReleaseTag ?? string.Empty;
            string otherPreReleaseTag = other?.PreReleaseTag ?? string.Empty;

            if (preReleaseTag != otherPreReleaseTag)
            {
                return(preReleaseTag.CompareTo(otherPreReleaseTag));
            }

            return(0);
        }
예제 #19
0
        public int CompareTo(SdkVersionInfo other)
        {
            var majorComparison = Major.CompareTo(other.Major);

            if (majorComparison != 0)
            {
                return(majorComparison);
            }

            var minorComparison = Minor.CompareTo(other.Minor);

            if (minorComparison != 0)
            {
                return(minorComparison);
            }

            var featureComparison = Feature.CompareTo(other.Feature);

            if (featureComparison != 0)
            {
                return(featureComparison);
            }

            var patchComparison = Patch.CompareTo(other.Patch);

            if (patchComparison != 0)
            {
                return(patchComparison);
            }

            // 3.1.100-preview1-01445 is lesser than 3.1.100
            if (IsPrerelease && !other.IsPrerelease)
            {
                return(-1);
            }

            if (!IsPrerelease && other.IsPrerelease)
            {
                return(1);
            }

            if (IsPrerelease && other.IsPrerelease)
            {
                // We are not parsing the preview part here and are only using string comparison
                // One more thing to complicate thing is that the preview part format has changed between
                // 3.* and 5.*, so this comparison is just fine.
                return(string.Compare(PrereleaseVersion, other.PrereleaseVersion, ignoreCase: true));
            }

            return(0);
        }
예제 #20
0
        public int CompareTo(SemanticVersion other)
        {
            if (other == null)
            {
                return(1);
            }

            int result = Major.CompareTo(other.Major);

            if (result != 0)
            {
                return(result);
            }

            result = Minor.CompareTo(other.Minor);

            if (result != 0)
            {
                return(result);
            }

            result = Patch.CompareTo(other.Patch);

            if (result != 0)
            {
                return(result);
            }

            //A version not marked with prerelease is later than one with a prerelease designation
            if (PrereleaseVersion == null && other.PrereleaseVersion != null)
            {
                return(1);
            }

            //A version not marked with prerelease is later than one with a prerelease designation
            if (PrereleaseVersion != null && other.PrereleaseVersion == null)
            {
                return(-1);
            }

            result = StringComparer.OrdinalIgnoreCase.Compare(PrereleaseVersion, other.PrereleaseVersion);

            if (result != 0)
            {
                return(result);
            }

            return(StringComparer.OrdinalIgnoreCase.Compare(OriginalText, other.OriginalText));
        }
예제 #21
0
        public int CompareTo(VersionInfo other)
        {
            var r = Major.CompareTo(other.Major);

            if (r != 0)
            {
                return(r);
            }
            r = Minor.CompareTo(other.Minor);
            if (r != 0)
            {
                return(r);
            }
            return(Patch.CompareTo(other.Patch));
        }
예제 #22
0
        public int CompareTo(StructuredVersion other)
        {
            var majorDiff = Major.CompareTo(other.Major);

            if (majorDiff != 0)
            {
                return(majorDiff);
            }
            var minorDiff = Minor.CompareTo(other.Minor);

            if (minorDiff != 0)
            {
                return(minorDiff);
            }
            var patchDiff = Patch.CompareTo(other.Patch);

            if (patchDiff != 0)
            {
                return(patchDiff);
            }
            if (Build != other.Build)
            {
                if (Build is null)
                {
                    return(-1);
                }
                if (other.Build is null)
                {
                    return(-1);
                }
                return(Build.Value.CompareTo(other.Build.Value));
            }
            // Null comes *after* anything else when it comes to prereleases,
            // so we can't just use StringComparer.
            if (Prerelease is null && other.Prerelease is null)
            {
                return(0);
            }
            if (Prerelease is null)
            {
                return(1);
            }
            if (other.Prerelease is null)
            {
                return(-1);
            }
            return(string.CompareOrdinal(Prerelease, other.Prerelease));
        }
        public int compareIgnoreDate(ScriptVersion other)
        {
            int compare = Major.CompareTo(other.Major);

            if (compare != 0)
            {
                return(compare);
            }

            compare = Minor.CompareTo(other.Minor);
            if (compare != 0)
            {
                return(compare);
            }

            return(Patch.CompareTo(other.Patch));
        }
예제 #24
0
        public int CompareTo([CanBeNull] SemanticVersion other)
        {
            if (other == null)
            {
                return(1);
            }

            // Compare to the most significant part which is different

            if (!Major.Equals(other.Major))
            {
                return(Major.CompareTo(other.Major));
            }

            if (!Minor.Equals(other.Minor))
            {
                return(Minor.CompareTo(other.Minor));
            }

            if (!Patch.Equals(other.Patch))
            {
                return(Patch.CompareTo(other.Patch));
            }

            if (Tag != other.Tag)
            {
                // Versions with a prerelease tag are considered older than those without
                // i.e. `1.0.0-beta` < `1.0.0`
                if (Tag != null && other.Tag == null)
                {
                    return(-1);
                }
                if (Tag == null && other.Tag != null)
                {
                    return(1);
                }

                // They both have a tag, so just order them by tag
                return(string.Compare(Tag, other.Tag, StringComparison.Ordinal));
            }

            return(0);
        }
예제 #25
0
        /// <summary>
        /// This method determines the ordering of VersionNumber instances.
        /// </summary>
        /// <see cref="IComparable{T}.CompareTo"/>
        public int CompareTo(VersionNumber other)
        {
            var compare = Major.CompareTo(other.Major);

            if (compare != 0)
            {
                return(compare);
            }

            compare = Minor.CompareTo(other.Minor);
            if (compare != 0)
            {
                return(compare);
            }

            compare = Patch.CompareTo(other.Patch);
            if (compare != 0)
            {
                return(compare);
            }

            if (PreReleaseLabel == null && other.PreReleaseLabel == null)
            {
                return(0);
            }

            if (PreReleaseLabel != null && other.PreReleaseLabel == null)
            {
                return(-1);
            }

            if (PreReleaseLabel == null && other.PreReleaseLabel != null)
            {
                return(1);
            }

            if (PreReleaseLabel != null && other.PreReleaseLabel != null)
            {
                return(PreReleaseLabel.CompareTo(other.PreReleaseLabel));
            }

            return(0);
        }
예제 #26
0
        public int CompareTo(Version other)
        {
            if (ReferenceEquals(this, other))
            {
                return(0);
            }
            if (ReferenceEquals(null, other))
            {
                return(1);
            }
            var majorComparison = Major.CompareTo(other.Major);

            if (majorComparison != 0)
            {
                return(majorComparison);
            }
            var minorComparison = Minor.CompareTo(other.Minor);

            if (minorComparison != 0)
            {
                return(minorComparison);
            }
            var patchComparison = Patch.CompareTo(other.Patch);

            if (patchComparison != 0)
            {
                return(patchComparison);
            }
            if (!IsPrerelease && !other.IsPrerelease)
            {
                return(0);
            }
            if (!IsPrerelease)
            {
                return(1);
            }
            if (!other.IsPrerelease)
            {
                return(-1);
            }
            return(CompareNonEmptyIdents(Prerelease, other.Prerelease));
        }
예제 #27
0
        /// <summary>
        /// </summary>
        /// <param name="other"></param>
        /// <returns>
        ///     greater than 0 newer
        /// </returns>
        public int CompareTo(SuffixVersion other)
        {
            var majorComparison = Major.CompareTo(other.Major);

            if (majorComparison != 0)
            {
                return(majorComparison);
            }

            var minorComparison = Minor.CompareTo(other.Minor);

            if (minorComparison != 0)
            {
                return(minorComparison);
            }

            var patchComparison = Patch.CompareTo(other.Patch);

            if (patchComparison != 0)
            {
                return(patchComparison);
            }

            if (PreRelease == string.Empty)
            {
                return(other.PreRelease == string.Empty ? 0 : 1);
            }

            if (other.PreRelease == string.Empty)
            {
                return(-1);
            }

            var suffixComparison = string.Compare(PreRelease, other.PreRelease, StringComparison.Ordinal);

            if (suffixComparison != 0)
            {
                return(suffixComparison);
            }

            return(Build.CompareTo(other.Build));
        }
예제 #28
0
        public int CompareTo([CanBeNull] SemanticVersion other)
        {
            if (other == null)
            {
                return(1);
            }

            //Compare to the most significant part which is different

            if (!Major.Equals(other.Major))
            {
                return(Major.CompareTo(other.Major));
            }

            if (!Minor.Equals(other.Minor))
            {
                return(Minor.CompareTo(other.Minor));
            }

            if (!Patch.Equals(other.Patch))
            {
                return(Patch.CompareTo(other.Patch));
            }

            if (Tag != other.Tag)
            {
                // versions with a prerelease tag are considered newer

                if (Tag != null && other.Tag == null)
                {
                    return(1);
                }

                if (Tag == null && other.Tag != null)
                {
                    return(-1);
                }
            }

            return(0);
        }
예제 #29
0
        /// <summary>
        /// <seealso href="http://semver.org/#spec-item-11">SemVer spec</seealso>
        /// Precedence refers to how versions are compared to each other when ordered.
        /// Precedence MUST be calculated by separating the version into major, minor, patch and
        /// pre-release identifiers in that order (Build metadata does not figure into precedence).
        /// Precedence is determined by the first difference when comparing each of these
        /// identifiers from left to right as follows: Major, minor, and patch versions are always compared numerically.
        /// Example: 1.0.0 &lt; 2.0.0 &lt; 2.1.0 &lt; 2.1.1.
        /// When major, minor, and patch are equal, a pre-release version has lower precedence than a normal version.
        /// Example: 1.0.0-alpha &lt; 1.0.0.
        /// Precedence for two pre-release versions with the same major, minor, and patch version
        /// MUST be determined by comparing each dot separated identifier from left to right until
        /// a difference is found as follows:
        /// identifiers consisting of only digits are compared numerically and identifiers with
        /// letters or hyphens are compared lexically in ASCII sort order.
        /// Numeric identifiers always have lower precedence than non-numeric identifiers.
        /// A larger set of pre-release fields has a higher precedence than a smaller set,
        /// if all of the preceding identifiers are equal.
        /// Example: 1.0.0-alpha &lt; 1.0.0-alpha.1 &lt; 1.0.0-alpha.beta &lt; 1.0.0-beta &lt;
        /// 1.0.0-beta.2 &lt; 1.0.0-beta.11 &lt; 1.0.0-rc.1 &lt; 1.0.0.
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public int CompareTo(SemVer other)
        {
            if (ReferenceEquals(other, null))
            {
                return(1);
            }

            var compare = Major.CompareTo(other.Major);

            if (compare != 0)
            {
                return(compare);
            }

            compare = Minor.CompareTo(other.Minor);
            if (compare != 0)
            {
                return(compare);
            }

            compare = Patch.CompareTo(other.Patch);
            if (compare != 0)
            {
                return(compare);
            }

            // a pre-release version has lower precedence than a normal version
            if (!IsPreRelease && other.IsPreRelease)
            {
                return(1);
            }
            if (IsPreRelease && !other.IsPreRelease)
            {
                return(-1);
            }

            return(CompareIdentifiers(PreReleaseIdentifiers, other.PreReleaseIdentifiers));
        }
예제 #30
0
        /// <summary>
        /// Compare semantic verions using precedence rules from https://semver.org/#spec-item-11
        /// </summary>
        /// <param name="other">Semantic version to compare to</param>
        /// <returns>-1, if this precedes other, +1 if other precedes this, or 0 if no precedence could be determined</returns>
        public int CompareTo(SemanticVersion other)
        {
            Contract.Requires(null != other);
            var major = Major.CompareTo(other.Major);

            if (0 != major)
            {
                return(major);
            }
            var minor = Minor.CompareTo(other.Minor);

            if (0 != minor)
            {
                return(minor);
            }
            var patch = Patch.CompareTo(other.Patch);

            if (0 != patch)
            {
                return(patch);
            }
            // pre-release is tricky, null to be considered greater than any value
            var thisPrereleaseEmpty  = string.IsNullOrEmpty(Prerelease);
            var otherPrereleaseEmpty = string.IsNullOrEmpty(other.Prerelease);

            if (thisPrereleaseEmpty || otherPrereleaseEmpty)
            {
                return(!thisPrereleaseEmpty ? -1 : otherPrereleaseEmpty ? 0 : +1);
            }
            var prerelease = string.Compare(Prerelease, other.Prerelease, StringComparison.CurrentCulture);

            if (0 != prerelease)
            {
                return(prerelease);
            }
            // we do not compare metadata, per standard
            return(0);
        }