2

I recently ran into a snag when this compare failed:

System.Version compareVersion = new Version(2, 0, 0, 0);
System.Version actualVersion = new Version(2, 0);

if(actualVersion >= compareVersion) // returns false

I understand the implementation mechanics behind it, because the last two digits are initialized as -1 and -1 is less than 0.

But: What's the rationale behind it? From a mathematical standpoint there is no difference between 1 and 1.0 and 1.000000 no matter how many zeros I append.

TheLethalCoder
  • 6,668
  • 6
  • 34
  • 69
Dee J. Doena
  • 1,631
  • 3
  • 16
  • 26
  • 4
    [Ddocumentation](https://msdn.microsoft.com/en-us/library/system.version%28v=vs.110%29.aspx#Anchor_6) supports your observations: _" If the build or revision number of a Version object is undefined, that Version object is considered to be earlier than a Version object whose build or revision number is equal to zero."_ – cbr Nov 20 '15 at 08:55
  • In [FDT 1.2 and 1.2.1](http://www.fdtgroup.org/), each part of the version number is a float, So you can have major version 1.234, minor version 5.678 etc. That's nice, isn't it? – Thomas Weller Nov 20 '15 at 09:02
  • 4
    "From a mathematical standpoint ..." From a mathematical standpoint, numbers have a single decimal separator. Therefore, whatever `1.0.0.0` *is*, it's not the same as numbers about which you may have some intuitions. It's a *string* that happens to contain digits and may contain *multiple* instances of a symbol that you're used to seeing as a decimal separator. – Damien_The_Unbeliever Nov 20 '15 at 09:02

2 Answers2

1

As per the docs

"A difference in build number represents a recompilation of the same source. Different build numbers might be used when the processor, platform, or compiler changes."

The third argument to the constructor is the build number which gets initialised to -1 if not assigned when the Version object is constructed. Conceivably a Version object could be created before an assembly or assemblies is built for the first time e.g. in some build pipeline logic. Once the assemblies are built and a build number exists a new Version object with build number would succeed the Version without.

Since the "greater than" and "less than" operator overloads are really about determining the relative times of builds (i.e whether one Version predates or postdates another) a version which has never been built or revised "is less than" a version which has.

cl0h
  • 91
  • 1
  • 8
1

Here's my take on it. I might be completely wrong, but as you are asking for rationale, this is how I see version numbers and their use.

Version numbers are not actually numbers, they are really just identifiers with some semantics and comparison logic based on that semantics. Part of that logic is being able to check whether two versions are compatible.

In that sense, 2.0 represents any 2.0 derivative, or 2.0.*.*. When you use relational operators with versions, you actually want to answer the compatibility question, where >= means something like is backwards compatible with.

So, V1 >= V2 would mean is V1 backwards compatible with V2.

  • 2.0.0.0 >= 2.0.*.* -> true, as 2.0.0.0 should be able to run on system supporting claiming to support 2.0.*.*
  • 2.0.*.* >= 2.0.0.0 -> false, as not every 2.0.*.* version is guaranteed to be compatible with 2.0.0.0

[EDIT: answering the comment]

shouldn't then 2.0.*.* at least be equal to 2.0.0.0? Because (in your words) "2.0.0.0 should be able to run on system supporting claiming to support 2.0.*.*"

I think what's confusing you is that we picked 2.0.0.0 which is intuitivelly understood as base version, thus logically equivalent to 2.0.*.*, but it isn't.

It shouldn't be equal, as 2.0.*.* means any 2.0 version (not just specific one that was picked), thus ANY_20_VERSION == 2000_VERSION is false. In other words, this would mean that any 2.0 derivative should be able to satisfy the relation (not just specific one that was picked), and obviously 2.0.0.1 is not same as 2.0.0.0

Zdeslav Vojkovic
  • 14,391
  • 32
  • 45
  • But letting the "greater than" aside for a minute, by your logic shouldn't then `2.0.*.*` at least be equal to `2.0.0.0`? Because (in your words) "`2.0.0.0` should be able to run on system supporting claiming to support `2.0.*.*`" – Dee J. Doena Nov 20 '15 at 13:09