Getting Accurate File Versions

Posted: December 16, 2013 in FileSystem, PowerShell
Tags: , ,

I used to think that getting a file version in PowerShell was a fairly simple process:

PS> (Get-Item c:\windows\system32\mshtml.dll).VersionInfo.FileVersion
11.00.9600.16410 (winblue_gdr.130923-1706)

There are two issues with that method, though:
1. That property can contain text along with the version
2. It turns out that in Windows Vista and higher, that property might not be coming from the file you think it is.

Issue #1 just means that the property is only good if you’re visually checking the version, or if no comparisons with other versions are necessary.

Issue #2 is the big one for me. What appears to be going on is that the FileVersion string is considered a non-fixed part of the version information, and it is pulled from the MUI resource file (if one exists). This file contains the language specific settings, and it looks like it only gets updated when the major or minor file version of associated file changes. If the private file version changes, it doesn’t look like the MUI file is changed.

That means that the FileVersion property has the potential to give you information that isn’t completely up to date. Critical patches from MS usually just update vulnerable code, so there’s no need to change language-specific things in the MUI file.

So, how can you get accurate file version information? Well, you can combine other properties from the VersionInfo object to create an accurate file version:

PS> $VersionInfo = (Get-Item C:\Windows\System32\mshtml.dll).VersionInfo
PS> $FileVersion = ("{0}.{1}.{2}.{3}" -f $VersionInfo.FileMajorPart, 
PS> $FileVersion

That’s still pretty simple, but it takes a lot more typing. Because of that extra typing, though, your version is now in a known format, i.e., ‘x.x.x.x’. And, if you cast it to a [version] type, you can compare versions as if they were numbers:

PS> [version] $FileVersion -gt "11.0.9600.16410"

There is one thing to note here:
Version comparisons between different formats, e.g., 1.2.3 and, might not return what you’re expecting. See the remarks section here. Here are some examples of what I’m talking about:

# Gotcha #1
PS> [version] "1.2.3" -eq [version] ""

# Gotcha #2
PS> [version] "1.2.3" -lt [version] ""

# Example of different formats working as you would expect
PS> [version] "1.2.3" -gt [version] ""

# Another example of different formats working
PS> [version] "1.3" -gt [version] ""

As long as you keep your version formats the same, though, the comparison operators will work exactly as you would expect them to. I recommend keeping them in the ‘x.x.x.x’ format.

Something else about the comparisons: In the examples, casting the second string to a [version] isn’t actually necessary. When a comparison operation occurs in PowerShell, the type of the first object is used for the comparisons. That means that the second string in the examples is automatically converted to a [version], even if you don’t tell PowerShell to do it. If you run this command, you’ll get an error:

PS> [version] "" -gt "potato"
Could not compare "" to "potato". Error: "Cannot convert value "potato" to type "System.Version". Error: "Version string portion was too short or too long.""
At line:1 char:1
+ [version] "" -gt "potato"
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : ComparisonFailure

I just put a string there, but PowerShell tried to make it a [version] object. It doesn’t hurt to always explicitly use the type (you could even argue that it’s a best practice), but it’s not necessary if you’re trying to cut down on the characters you have to type. Just make sure that the first object is actually a [version] type.

Like I said before, the biggest drawback to combining the four File*Part properties is how much typing it requires. So, I decided to make PowerShell always get the file version for me, and automatically add it to a file object:

# PowerShell must be at least v3 to do this:
Update-TypeData -TypeName System.IO.FileInfo -MemberType ScriptProperty -MemberName PSFileVersion -Value {
    if ($this.VersionInfo.FileVersion) {
        [version] ("{0}.{1}.{2}.{3}" -f $this.VersionInfo.FileMajorPart, 

That method requires version 3.0. If you have 2.0, you should be able to get it to work, though. The difference is that you have to save an XML file, and then use the Update-TypeData cmdlet to read that file. Here’s the XML file:

                    if ($this.VersionInfo.FileVersion) {
                        [version] ("{0}.{1}.{2}.{3}" -f $this.VersionInfo.FileMajorPart, 

And here’s the command:

# Replace $PathToXmlFile with proper path:
Update-TypeData -AppendPath $PathToXmlFile

This works on my machine when forcing PowerShell to run version 2, but I haven’t tested it on a machine that truly has PowerShell v2 installed.

Now, when you use Get-Item, Get-ChildItem, or anything that returns a [System.IO.FileInfo] object, the object will have a PSFileVersion property. Here are some examples of this functionality:

# Use Get-ChildItem to display file names and versions:
PS> dir C:\Windows\system32 -Filter msh*.dll | ? psfileversion | select name, psfileversion

Name          PSFileVersion  
----          -------------  
mshtml.dll    11.0.9600.16476
MshtmlDac.dll 11.0.9600.16384
mshtmled.dll  11.0.9600.16384
mshtmler.dll  11.0.9600.16384

# Same as before, but this shows the accurate System.Version version and the inaccurate VersionInfo.FileVersion:
PS> dir C:\Windows\system32 -Filter msh*.dll | ? psfileversion | select name, psfileversion, @{N="FileVersionString";E={$_.VersionInfo.FileVersion}}

Name          PSFileVersion   FileVersionString                         
----          -------------   -----------------                         
mshtml.dll    11.0.9600.16476 11.00.9600.16410 (winblue_gdr.130923-1706)
MshtmlDac.dll 11.0.9600.16384 11.00.9600.16384 (winblue_rtm.130821-1623)
mshtmled.dll  11.0.9600.16384 11.00.9600.16384 (winblue_rtm.130821-1623)
mshtmler.dll  11.0.9600.16384 11.00.9600.16384 (winblue_rtm.130821-1623)

# Comparisons:
PS> (Get-Item C:\Windows\System32\mshtml.dll).PSFileVersion -gt "11.0.9600.16410"
PS> (Get-Item C:\Windows\System32\mshtml.dll).PSFileVersion -lt "11.0.9600.16410"

# List all of the files with versions under system32:
dir C:\Windows\System32 | ? psfileversion | select name, psfileversion | Out-GridView

You can find this on the Script Repository here.

  1. Keith says:

    Instead of getting the fileversion from fileversioninfo ( and trying to fix it wouldn’t it be easier to get the productversion from fileversioninfo ( and use that as your file version? The product version is typically, at least on the systems I’ve tested it on, the same as the file version, without the words that you’re trying to strip out. Example below:

    PS C:\> $a = Get-Item c:\windows\system32\mshtml.dll
    PS C:\> $a.VersionInfo.FileVersion
    9.00.8112.16421 (WIN7_IE9_RTM.110308-0330)
    PS C:\> $a.VersionInfo.ProductVersion

    To compare all the EXEs on your system you could run the following command:

    get-childitem “C:\” -include *.exe -recurse|foreach { $Name = $ ; $Dir=$_.DirectoryName ; $ProductVersion = (Get-Command $_.FullName).FileVersionInfo.ProductVersion ; $FileVersion = (Get-Command $_.FullName).FileVersionInfo.FileVersion ; $AllInfo = “$Dir|$Name|$ProductVersion|$FileVersion” ; $AllInfo | Out-File -FilePath “C:\temp\VersionInfo.txt” -Append }

    This will give you a text file showing the directory to the EXE, the EXE name, the ProductVersion, and the FileVersion.

    • Rohn Edwards says:

      Good question and suggestion. That fixes problem #1 from the post, but you still have problem #2: FileVersion and ProductVersion aren’t necessarily coming from the .dll or .exe file that you’re checking against. If there is an associated MUI file (and most important Microsoft files are going to use these), then those properties come from the MUI file instead of the actual file you’re checking. When a critical update comes out, I don’t think the MUI files are updated, which means the revision information won’t match anymore.

      On a side note, I just noticed that there are FileVersionRaw and ProductVersionRaw script properties on the file objects in PSv5 that make my type data method above unnecessary.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s