121

I've got an executable file, and I would like to know which version(s) of the Microsoft .NET Framework this file needs to be started.

Is there an easy way to find this information somewhere?

(So far I tried ILDASM and DUMPBIN without any luck.)

Improve this question
2

13 Answers 13

Reset to default
98

Using Notepad, three decades old, 200kb in size, preinstalled tool:

  • open application with notepad appname.exe,
  • search for word framework,
  • repeat last search with F3 until .NET Framework,version=vX.Y shows up
  • if nothing found (versions below 3.0) search for v2. ... still 100 times easier then installing gigabytes of dot net analyzer tools and garbage studios.

update: Thought and Marcus suggested in comments that search term could also be netstandard or netframework

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

This is great- especially if you don't have access to decompile/other tools
Update: It may not be found, and instead there may be a ".NETStandard,version=..."
Update: on an app I've just verified, the string does not include the space: .NETFramework,Version=v4.7.2
My .exe (winforms) has zero string of any of the above
55

I think the closest you can reliably get is to determine what version of the CLR is required. You can do this by using ILDASM and looking at the "MANIFEST" node or Reflector and looking at the dissasembly view of the "Application.exe" node as IL. In both cases there is a comment that indicates the CLR version. In ILDASM, the comment is "// Metadata version" and in Reflector the comment is "Target Runtime Version".

Here are examples for a .NET WinForms application named WindowsFormsApplication1.exe:

ILDASM:

// Metadata version: v2.0.50727
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 2:0:0:0
}
.assembly extern System
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 2:0:0:0
}

Reflector:

.module WindowsFormsApplication1.exe
.subsystem 0x0002
// MVID: {CA3D2090-16C5-4899-953E-4736D6BC0FA8}
// Target Runtime Version: v2.0.50727

You can also look at the list of referenced assemblies and look for the reference with the highest version number.

Again, using ILDASM looking at the "MANIFEST" node data:

.assembly extern System.Drawing
{
  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A )                         // .?_....:
  .ver 2:0:0:0
}
.assembly extern System.Core
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 3:5:0:0
}

And using Reflector, looking at the dissambly (still as IL) for each reference listed:

.assembly extern System.Core
{
    .ver 3:5:0:0
    .publickeytoken = (B7 7A 5C 56 19 34 E0 89)
}

By finding the reference with the highest version metadata you can determine what version of the Framework that reference came from, which would indicate that you need the same version of the Framework installed for the application to run. That being said, I wouldn't treat this as 100% reliable, but I don't think it will change any time soon.

Improve this answer

3 Comments

Unfortunately Microsoft introduces a breaking change for the above technique. .NET 4.5 assemblies cannot run on raw .NET 4, and to tell a .NET 4.5 assembly you need to also read System.Runtime.Versioning.TargetFrameworkAttribute. lextm.com/2013/02/how-to-tell-net-45-only-assemblies.html
@LexLi link does not work
@Zoli halfblood.pro/how-to-tell-net-4-5-only-assemblies-f5e9041533bb
38

A more simplified approach would be to use dotPeek and see what shows up in the tree.

See the properties panel: enter image description here

Improve this answer

Comments

27

You can now use ILSpy to examine the target framework of an assembly. After loading the assembly, click on the root of the assembly node, and you can find the information under the TargetFramework declaration:

[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
Improve this answer

3 Comments

Note that TargetFrameworkAttribute was only added in .NET 4.0, so will not be present on assemblies compiled against .NET 3.5 or earlier.
ILSpy shows "Runtime: vXXX" in comments when clicking the loaded assembly root node. I was able to see a v1.1.4322 framework project.
It shows me: // Architecture: x64 // Runtime: .NET 4.0
16

From the command line: find "Framework" MyApp.exe

Improve this answer

2 Comments

Note: it's case-sensitive, "findframework" (lower f) will not work.
Does not work. All I get as result for my WinForms .exe: PresentationFramework
15

From code you can use Assembly.ImageRuntimeVersion but by looking at the file probably the best thing to do would be to use reflector and see which version of mscorlib is being referenced.

Edit: Even better would be to use ildasm, open your assembly and then view the manifest for the assembly. The first line of the manifest will tell you the exact version of CLR that the assembly was built for.

Improve this answer

1 Comment

This is wrong. The OP asked about the version of .NET Framework, not the version of the CLR Runtime. This answer address the latter. As an example, I am running against Framework 4.7.2531.0 which uses the CLR Runtime version 4.0.30139. ImageRuntimeVersion returns the CLR version, not the Framework version.
12

You can use a tool called CorFlags.exe. It has been around since .NET 2.0, and I know for sure that it is included in the Windows SDK 7.0. By default (on Windows XP Pro) it is installed to C:\Program Files\Microsoft SDKs\Windows\v7.0A\bin\CorFlags.exe. Provide it with the file path to a managed module (without any other command-line flags) to display its header information, which includes the version.

Keep in mind that this utility is designed to modify the PE32 header of a module, so don't use any of the flags until you read the documentation carefully.

Improve this answer

1 Comment

Cannot distinguish between .Net4 and .Net4.5
6

You can obtain the .NET version of a file in Windows using Powershell. The following script;

$path=’.\’
$ErrorActionPreference = "SilentlyContinue"
$files=Get-ChildItem -Path $path -Recurse -include *.dll,*.exe
foreach($file in $files)
{
    $filename = $file.BaseName
    $version = $([System.Reflection.Assembly]::ReflectionOnlyLoadFrom($file.FullName).GetCustomAttributesData() |
                 select-object -ExpandProperty ConstructorArguments | 
                 select-object -ExpandProperty Value | 
                 select-string -Pattern '.NET')
    Write-Output "$filename,$version"
}

provides the following result; enter image description here

Note that the result extracted the .NET version for the exe files in that folder, but it will also do the same for a dll.

Improve this answer

3 Comments

This didn't work for me. I copied and pasted everything into powershell with my path altered to the exe path and it just tells me the name of the application, nothing else
Nicely done; to make it work in PowerShell Core, replace ReflectionOnlyLoadFrom with LoadFile
Same for me, says nothing about my Winforms exe, only the filename printed
3

For newer .NET 6.0 applications the notepad method did not work for me, but if there is a *.deps.json file next to the exes that's a big clue - often contains the version in form of the following section

"runtimeTarget": {
    "name": ".NETCoreApp,Version=v6.0/win-x86"

Edit: following up, you can also look for a pair of .exe and .dll files with the same name, try opening the DLL file in notepad and search for NETCoreApp, you should find something like this:

.NETCoreApp,Version=v6.0
Improve this answer

Comments

2

Or you can just find out which reference of System.Core it has. That will tell you the .NET Framework version this app is using. For 2.0 the version of System.Core will be 2.0.xxx.xxx. For 3.5 the version will be 3.5.xxx.xxx, etc.

Improve this answer

1 Comment

I don't think this is true. I have a target framework of 4.5 but use System.Core 4.0.XXX.XXX
2

On Linux/OSX/unix you can use:

strings that_app.exe | grep 'v2.\|Framework'
Improve this answer

Comments

0
  1. Open ILSpy: Launch the ILSpy application on your computer.
  2. Open EXE in ILSpy: Use the "File" menu or a similar option to open the EXE file within ILSpy. This action allows you to decompile and view the contents of the executable.
  3. Select the Root Entry: In ILSpy select top entry.
  4. View Left-Hand Side Pane: After selecting the top entry or any other part of the code, you should see details about that element in the left-hand side pane. This may include information about the assembly.
  5. Check Version Name: In the left-hand side pane, there may be information about the version of the assembly. Look for a section that provides details like the assembly version, file version, or product version.enter image description here
Improve this answer

Comments

0

One thing that all previous answers neglected to mention, the target framework of a compiled .NET program does not include the target framework of its included libraries. It is possible to have an application targeting .NET Framework 4.8 including libraries targeting at least as old as 2.0.

I used dotPeek to view references in an application. Open the program, right click it in Assembly Explorer -> References Hierarchy

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.