NuGet.Versioning

The floating subset of a version range.

Create a floating range.

Section to float.

Create a floating range.

Section to float. Min version of the range.

FloatRange

Section to float. Min version of the range. The original release label. Invalid labels are allowed here.

True if a min range exists.

The minimum version of the float range. This is null for cases such as *

Defined float behavior

The original release label. Invalid labels are allowed here.

Indicates if the includes prerelease versions.

True if the given version falls into the floating range.

Parse a floating version into a FloatRange

Create a floating version string in the format: 1.0.0-alpha-*

Equals

Override Object.Equals

Hash code

An item that exposes a NuGetVersion

NuGet semantic version

IVersionComparer represents a version comparer capable of sorting and determining the equality of SemanticVersion objects.

Version range comparer

A hybrid implementation of SemVer that supports semantic versioning as described at http://semver.org while not strictly enforcing it to allow older 4-digit versioning schemes to continue working.

Creates a NuGetVersion using NuGetVersion.Parse(string)

Version string

Creates a NuGetVersion from an existing NuGetVersion

Creates a NuGetVersion from a .NET Version

Version numbers Prerelease label Build metadata

Creates a NuGetVersion X.Y.Z

X.y.z x.Y.z x.y.Z

Creates a NuGetVersion X.Y.Z-alpha

X.y.z x.Y.z x.y.Z Prerelease label

Creates a NuGetVersion X.Y.Z-alpha#build01

X.y.z x.Y.z x.y.Z Prerelease label Build metadata

Creates a NuGetVersion X.Y.Z-alpha.1.2#build01

X.y.z x.Y.z x.y.Z Prerelease labels Build metadata

Creates a NuGetVersion W.X.Y.Z

W.x.y.z w.X.y.z w.x.Y.z w.x.y.Z

Creates a NuGetVersion W.X.Y.Z-alpha#build01

W.x.y.z w.X.y.z w.x.Y.z w.x.y.Z Prerelease label Build metadata

Creates a NuGetVersion W.X.Y.Z-alpha.1#build01

W.x.y.z w.X.y.z w.x.Y.z w.x.y.Z Prerelease labels Build metadata

Creates a NuGetVersion from a .NET Version with additional release labels, build metadata, and a non-normalized version string.

Version numbers prerelease labels Build metadata Non-normalized original version string

Returns the version string.

This method includes legacy behavior. Use ToNormalizedString() instead. Versions with SemVer 2.0.0 components are automatically normalized.

A System.Version representation of the version without metadata or release labels.

True if the NuGetVersion is using legacy behavior.

Revision version R (x.y.z.R)

Returns true if version is a SemVer 2.0.0 version

Returns the original, non-normalized version string.

Creates a NuGetVersion from a string representing the semantic version.

Parses a version string using loose semantic versioning rules that allows 2-4 version components followed by an optional special version.

Parses a version string using strict SemVer rules.

Creates a legacy version string using System.Version

Specifies the floating behavior type.

Lowest version, no float

Highest matching pre-release label

x.y.z.*

x.y.*

x.*

Float major and pre-release, *-*

Float revision and pre-release x.y.z.*-*

Float patch and pre-release x.y.*-*

Float minor and pre-release x.*-*

Float major and prerelease, but only with partial prerelease *-rc.*. *-* is captured by

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to Value cannot be null or an empty string..

Looks up a localized string similar to Parameter '{0}' cannot be null when parameter '{1}' is not null..

Looks up a localized string similar to '{0}' is not a valid float range string..

Looks up a localized string similar to '{0}' is not a valid version string..

Looks up a localized string similar to Type '{0}' is not supported..

Strings that contain {x} arguments might throw exceptions in string.Format when the number of arguments change, but the args to string.Format do not. By putting all calls to a particular resource in a C# class, we can use the compiler to check that all references pass the correct number of arguments.

A strict SemVer implementation

A base version operations

Creates a SemanticVersion from an existing SemanticVersion

Version to clone.

Creates a SemanticVersion X.Y.Z

X.y.z x.Y.z x.y.Z

Creates a NuGetVersion X.Y.Z-alpha

X.y.z x.Y.z x.y.Z Prerelease label

Creates a NuGetVersion X.Y.Z-alpha#build01

X.y.z x.Y.z x.y.Z Prerelease label Build metadata

Creates a NuGetVersion X.Y.Z-alpha.1.2#build01

X.y.z x.Y.z x.y.Z Release labels that have been split by the dot separator Build metadata

Internal constructor.

Version Full release label Build metadata

Internal constructor.

X.y.z x.Y.z x.y.Z x.y.z.R Prerelease label Build metadata

Internal constructor.

Version Release labels Build metadata

Major version X (X.y.z)

Minor version Y (x.Y.z)

Patch version Z (x.y.Z)

A collection of pre-release labels attached to the version.

The full pre-release label for the version.

True if pre-release labels exist for the version.

True if metadata exists for the version.

Build metadata attached to the version.

Gives a normalized representation of the version. This string is unique to the identity of the version and does not contain metadata.

Gives a full representation of the version include metadata. This string is not unique to the identity of the version. Other versions that differ on metadata will have a different full string representation.

Get the normalized string.

Custom string format.

Internal string formatter.

Hash code

Object compare.

Compare to another SemanticVersion.

Equals

True if the VersionBase objects are equal based on the given comparison mode.

Compares NuGetVersion objects using the given comparison mode.

Equals

Not equal

Less than

Less than or equal

Greater than

Greater than or equal

Parses a SemVer string using strict SemVer rules.

Parse a version string

false if the version is not a strict semver

Parse the version string into version/release/build The goal of this code is to take the most direct and optimized path to parsing and validating a semver. Regex would be much cleaner, but due to the number of versions created in NuGet Regex is too slow.

Provides a type converter to convert objects to and from various other representations.

Gets a value indicating whether this converter can convert an object in the given source type to a using the specified context.

An that provides a format context. A that represents the type you wish to convert from. if this object can perform the conversion; otherwise, .

Converts the given object to the type of this converter, using the specified context and culture information.

An that provides a format context. The to use as the current culture. The to convert. An that represents the converted value. value is not a valid value for the target type. The conversion cannot be performed.

Gets a value indicating whether this converter can convert an object to the given destination type using the context.

An that provides a format context. A that represents the type you wish to convert to. if this object can perform the conversion; otherwise, .

Converts the given value object to a object using the arguments.

An that provides a format context. The to use as the current culture. The to convert. The to convert the value to. An that represents the converted value. The conversion cannot be performed.

An IVersionComparer for NuGetVersion and NuGetVersion types.

Gets an IVersionComparer based on the specified VersionComparison mode.

The version comparison mode to use. An IVersionComparer instance.

Creates a VersionComparer using the default mode.

Creates a VersionComparer that respects the given comparison mode.

comparison mode

Determines if both versions are equal.

Compares the given versions using the VersionComparison mode.

Gives a hash code based on the normalized version string.

Compare versions.

Compares the 4th digit of the version number.

A default comparer that compares metadata as strings.

A comparer that uses only the version numbers.

Compares versions without comparing the metadata.

A version comparer that follows SemVer 2.0.0 rules.

Compares sets of release labels.

Release labels are compared as numbers if they are numeric, otherwise they will be compared as strings.

Returns an array of release labels from the version, or null.

Compare release labels

Returns the fourth version number or zero.

Version comparison modes.

Semantic version 2.0.1-rc comparison with additional compares for extra NuGetVersion fields.

Compares only the version numbers.

Include Version number and Release labels in the compare.

Include all metadata during the compare.

Version extension methods.

Find the version that best matches the VersionRange and the floating behavior.

Custom formatter for NuGet versions.

A static instance of the VersionFormatter class.

Format a version string.

Get version format type.

Appends the full version string including metadata. This is primarily for display purposes.

Appends a normalized version string. This string is unique for each version 'identity' and does not include leading zeros or metadata.

Represents a range of versions and a preferred order.

Immutable, although subclasses may introduce mutable state.

Creates a range that is greater than or equal to the minVersion.

Lower bound of the version range.

Creates a range that is greater than or equal to the minVersion with the given float behavior.

Lower bound of the version range. Floating behavior.

Clones a version range and applies a new float range.

Creates a VersionRange with the given min and max.

Lower bound of the version range. True if minVersion satisfies the condition. Upper bound of the version range. True if maxVersion satisfies the condition. The floating range subset used to find the best version match. The original string being parsed to this object.

True if the range has a floating version above the min version.

Optional floating range used to determine the best version match.

Original string being parsed to this object.

Normalized range string.

A legacy version range compatible with NuGet 2.8.3

A short legacy version range compatible with NuGet 2.8.3. Ex: 1.0.0

Format the version range with an IFormatProvider

Format the range

Format the version range in Pretty Print format.

Return the version that best matches the range.

Determines if a given version is better suited to the range than a current version.

Removes the floating snapshot part of the minimum version if it exists. Ex: 1.0.0-* -> 1.0.0

Remove the snapshot version section of a version

ToLegacyShortString that also includes floating ranges

Equals implementation for VersionRange.

Compare the obj as VersionRange.

Returns the VersionRangeBase hashcode

A range that accepts all versions, prerelease and stable.

A range that accepts all versions, prerelease and stable, and floats to the highest.

A range that accepts all stable versions

A range that accepts all versions, prerelease and stable, and floats to the highest.

A range that rejects all versions

The version string is either a simple version or an arithmetic range e.g. 1.0 --> 1.0 ≤ x (,1.0] --> x ≤ 1.0 (,1.0) --> x < 1.0 [1.0] --> x == 1.0 (1.0,) --> 1.0 < x (1.0, 2.0) --> 1.0 < x < 2.0 [1.0, 2.0] --> 1.0 ≤ x ≤ 2.0

Direct parse

Parses a VersionRange from its string representation.

Returns the smallest range that includes all given versions.

Returns the smallest range that includes all given ranges.

Returns the greatest common range that satisfies all given ranges.

Verify the range has an actual width. Ex: no version can satisfy (3.0.0, 3.0.0)

A base version range that handles ranges only and not any of the preferred version logic.

Creates a VersionRange with the given min and max.

Lower bound of the version range. True if minVersion satisfies the condition. Upper bound of the version range. True if maxVersion satisfies the condition.

True if MinVersion exists;

True if MaxVersion exists.

True if both MinVersion and MaxVersion exist.

True if MinVersion exists and is included in the range.

True if MaxVersion exists and is included in the range.

Maximum version allowed by this range.

Minimum version allowed by this range.

Determines if an NuGetVersion meets the requirements.

SemVer to compare True if the given version meets the version requirements.

Determines if an NuGetVersion meets the requirements using the given mode.

SemVer to compare VersionComparison mode used to determine the version range. True if the given version meets the version requirements.

Determines if an NuGetVersion meets the requirements using the version comparer.

SemVer to compare. Version comparer used to determine if the version criteria is met. True if the given version meets the version requirements.

Compares the object as a VersionRange with the default comparer

Returns the hash code using the default comparer.

Default compare

Use the VersionRangeComparer for equality checks

Use a specific VersionComparison for comparison

Use a specific IVersionComparer for comparison

SubSet check

Infer if the range should allow prerelease versions based on if the lower or upper bounds contain prerelease labels.

A version range comparer capable of using different VersionComparers to check if ranges are equivalent.

Default version range comparer.

Compare versions with a specific VersionComparison

Compare versions with a specific IVersionComparer

Default Version comparer

Compare versions using the Version and Release

Gets the appropriate version range comparer based on the specified version comparison.

The version comparison to use. An instance of .

Checks if two version ranges are equivalent. This follows the rules of the version comparer when checking the bounds.

Creates a hash code based on all properties of the range. This follows the rules of the version comparer when comparing the version bounds.

Custom formatter for NuGet .

A static instance of the class.

Format a version range string.

Format type.

Builds a normalized string with no short hand

Builds a string to represent the VersionRange. This string can include short hand notations.

Creates a legacy short string that is compatible with NuGet 2.8.3

Creates a legacy string that is compatible with NuGet 2.8.3

A pretty print representation of the VersionRange.

Provides a resource pool that enables reusing instances of instances.

Renting and returning buffers with an can increase performance in situations where instances are created and destroyed frequently, resulting in significant memory pressure on the garbage collector. This class is thread-safe. All members may be used by multiple threads concurrently. The string builder must be returned, even if an exception is thrown while it is in use. Failure to do results in other callers not being able to rent the string builder.

Retrieves a that is at least the requested length.

The minimum capacity of the needed. A that is at least in length. This buffer is loaned to the caller and should be returned to the same pool via so that it may be reused in subsequent usage of . It is not a fatal error to not return a rented string builder, but failure to do so may lead to decreased application performance, as the pool may need to create a new instance to replace the one lost.

Returns to the pool an array that was previously obtained via on the same instance, returning the built string.

The previously obtained from to return to the pool. Once a has been returned to the pool, the caller gives up all ownership of the instance and must not use it. The reference returned from a given call to must only be returned via once. The default may hold onto the returned instance in order to rent it again, or it may release the returned instance if it's determined that the pool already has enough instances stored. The string, built from .

Compares two enumerables for equality, ordered according to the specified key and optional comparer. Handles null values gracefully.

The type of the list The type of the sorting key This list The other list The function to extract the key from each item in the list An optional comparer for comparing keys An optional comparer for sequences

Compares two collections for equality, ordered according to the specified key and optional comparer. Handles null values gracefully.

Compares two lists for equality, ordered according to the specified key and optional comparer. Handles null values gracefully.

Compares two sequence for equality, allowing either sequence to be null. If one is null, both have to be null for equality.

Compares two collections for equality, allowing either collection to be null. If one is null, both have to be null for equality.

Compares two lists for equality, allowing either list to be null. If one is null, both have to be null for equality.

Compares two sets for equality, allowing either sequence to be null. If one is null, both have to be null for equality.

Determines if the current string contains a value equal "false". Leading and trailing whitespace are trimmed and the comparison is case-insensitive

The string to compare. if the current string is equal to a value of "false", otherwise .

Hash code creator, based on the original NuGet hash code combiner/ASP hash code combiner implementations

Create a unique hash code for the given set of items

Return the enumerable as a List of T, copying if required. Optimized for common case where it is an List of T. Avoid mutating the return value.

https://aspnetwebstack.codeplex.com/SourceControl/latest#src/Common/CollectionExtensions.cs

Return the ISet as a HashSet of T, copying if required. Optimized for common case where it is a HashSet of T. Avoid mutating the return value.

Helper function to append an to a . Calling directly causes an allocation by first converting the to a string and then appending that result:


             public StringBuilder Append(int value)
             {
                 return Append(value.ToString(CultureInfo.CurrentCulture));
             }

Note that this uses the current culture to do the conversion while does not do any cultural sensitive conversion.

The to append to. The to append.

Avoids allocating an enumerator when enumerating an .

Returns a struct-based enumerator that avoids heap allocation during enumeration. If the underlying type is then this method will delegate to , otherwise the collection's items are accessed by index via 's indexer directly. When using a struct-based enumerator, no heap allocation occurs during enumeration via . This is in contrast to the interface-based enumerator which will always be allocated on the heap.


              list = ...;
            
             foreach (string item in list.NoAllocEnumerate())
             {
                 // ...
             }]]>

Provides a struct-based enumerator for use with . Do not use this type directly. Use instead.

A struct-based enumerator for use with . Do not use this type directly. Use instead.

Avoids allocating an enumerator when enumerating an where the concrete type has a well known struct enumerator, such as for , or when index-based access is possible via .

Several collection types (e.g. ) provide a struct-based enumerator type (e.g. ) which the compiler can use in statements. When using a struct-based enumerator, no heap allocation occurs during such enumeration. This is in contrast to the interface-based enumerator which will always be allocated on the heap. This method returns a custom struct enumerator that will avoid any heap allocation if (which is declared via interface ) is actually of known concrete type that provides its own struct enumerator. If so, it delegates to that type's enumerator without any boxing or other heap allocation. If is not of a known concrete type, the returned enumerator falls back to the interface-based enumerator, which will be allocated on the heap. Benchmarking shows the overhead in such cases is low enough to be within the measurement error, meaning this is an inexpensive optimization that won't regress behavior and with low downside for cases where it cannot apply an optimization.


              source = ...;
            
             foreach (string item in source.NoAllocEnumerate())
             {
                 // ...
             }]]>

Provides a struct-based enumerator for use with . Do not use this type directly. Use instead.

A struct-based enumerator for use with . Do not use this type directly. Use instead.

Avoids allocating an enumerator when enumerating an where the concrete type has a well known struct enumerator, such as for .


              dictionary = ...;
            
             foreach ((string key, string value) in dictionary.NoAllocEnumerate())
             {
                 // ...
             }]]>

Provides a struct-based enumerator for use with . Do not use this type directly. Use instead.

A struct-based enumerator for use with . Do not use this type directly. Use instead.

Provides a resource pool that enables reusing instances of instances.

Retrieves a shared instance.

Retrieves a that is at least the requested length.

Returns to the pool an array that was previously obtained via on the same instance, returning the built string.

Specifies that null is allowed as an input even if the corresponding type disallows it.

Specifies that null is disallowed as an input even if the corresponding type allows it.

Specifies that an output may be null even if the corresponding type disallows it.

Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns.

Specifies that when a method returns , the parameter may be null even if the corresponding type disallows it.

Initializes the attribute with the specified return value condition.

The return value condition. If the method returns this value, the associated parameter may be null.

Gets the return value condition.

Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it.

Initializes the attribute with the specified return value condition.

The return value condition. If the method returns this value, the associated parameter will not be null.

Gets the return value condition.

Specifies that the output will be non-null if the named parameter is non-null.

Initializes the attribute with the associated parameter name.

The associated parameter name. The output will be non-null if the argument to the parameter specified is non-null.

Gets the associated parameter name.

Applied to a method that will never return under any circumstance.

Specifies that the method will not return if the associated Boolean parameter is passed the specified value.

Initializes the attribute with the specified parameter value.

The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to the associated parameter matches this value.

Gets the condition parameter value.

Specifies that the method or property will ensure that the listed field and property members have not-null values.

Initializes the attribute with a field or property member.

The field or property member that is promised to be not-null.

Initializes the attribute with the list of field and property members.

The list of field and property members that are promised to be not-null.

Gets field or property member names.

Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.

Initializes the attribute with the specified return value condition and a field or property member.

The return value condition. If the method returns this value, the associated parameter will not be null. The field or property member that is promised to be not-null.

Initializes the attribute with the specified return value condition and list of field and property members.

The return value condition. If the method returns this value, the associated parameter will not be null. The list of field and property members that are promised to be not-null.

Gets the return value condition.

Gets field or property member names.