How can I get the assembly version as a integer in C#?

Question

I can get it as a string:

Assembly.GetExecutingAssembly().GetName().Version()

How can I convert this number to an int?

---

Example input:

8.0.0.1

Expected output:

8001

Answer 1

You could string.Split('.'), iterate and int.parse()

Answer 2

They are numbers, so you could just convert them to strings and stack them after each other:

Version v = Assembly.GetExecutingAssembly().GetName().Version;
string compacted = string.Format("{0}{1}{2}{3}", v.Major, v.Minor, v.Build, v.Revision);
int compactInt = int.Parse(compacted);

This of course only works well as long as each component is less than ten. After that you can't determine what the actual version is. The string "12345" can be 1.23.4.5 or 12.3.4.5 or 1.2.34.5 or...

If you know that they are all below ten, you could do it numerically:

Version v = Assembly.GetExecutingAssembly().GetName().Version;
int compactInt = v.Major * 1000 + v.Minor * 100 + v.Build * 10 + v.Revision;

If you don't know that, it gets a bit more complicated, but you can still do it without creating a string and parse it. It would be a bit faster, but it's 10 - 20 lines of code.

Answer 3

The following 'works':

string version = "8.0.0.1";
int versionNumber = int.Parse(version.Replace(".", ""));

However, there would be no difference between version 8.0.11.0 and 8.0.1.10!

Answer 4

I would just do this:

Integer.Parse(Assembly.GetExecutingAssembly().GetName().Version().ToString().Replace(".", ""))

I stand Corrected.

Answer 5

You could also run into the situation where an assembly has a version of 0.0.1.1 and then the version looks like: 11. Definitely not desired.

Answer 6

Try this:

Version v = Assembly.GetExecutingAssembly().GetName().Version;
long s = long.Parse(v.Major.ToString("0000") + v.MajorRevision.ToString("0000") + v.Minor.ToString("0000") + v.MinorRevision.ToString("0000"));

Answer 7

What is the problem you're trying to solve? Are you checking to see if the running version of some library is greater than or equal to some known bug-free version? If so, the right thing to do is not to treat a .-delimited string of numbers as a single number, but to compare them individually to your target.

Answer 8

Rather than that approach, and assuming that each of your version string elements is less than 255, you could just take each element as a byte in a 32 bit unsigned integer. This would not be very human readable, but would ensure that if V1 < V2 in version comparison then f(V1) < f(V2) for the integer conversion f.

Answer 9

If you really have to do this conversion, you should at least reserve an adequate amount of digits for every version part.

Two digits for Major, Minor and Revision and four for Build:

var version = Assembly.GetExecutingAssembly().GetName().Version();

Debug.Assert(version.Major >= 0 && version.Major < 100)
Debug.Assert(version.Minor >= 0 && version.Minor < 100)
Debug.Assert(version.Build >= 0 && version.Build < 10000)
Debug.Assert(version.Revision >= 0 && version.Revision < 100)

long longVesion = version.Major * 100000000L + 
                  version.Minor * 1000000L + 
                  version.Build * 100L + 
                  version.Revision;

int intVersion  = (int) longVersion;

Debug.Assert((long)intVersion == longVersion)

Note that this method will still fail for some exotic versions!

Don't even think about version 21.47.4836.48 :)

EDIT: Added assertions.