Come scoprire quale versione di .NET Framework deve essere eseguita da un eseguibile?

Ho un file eseguibile e vorrei sapere quali versioni del framework .NET è necessario avviare questo file.

C'è un modo semplice per trovare queste informazioni da qualche parte?

(Finora ho provato ILDASM e DUMPBIN senza fortuna.)

Penso che la cosa più vicina che puoi ottenere in modo affidabile sia determinare quale versione di CLR è richiesta. È possibile farlo utilizzando ILDASM ed esaminando il nodo "MANIFEST" o Reflector e osservando la vista di dissassemblaggio del nodo "Application.exe" come IL. In entrambi i casi è presente un commento che indica la versione CLR. In ILDASM, il commento è "// Versione metadati" e in Reflector il commento è "Versione runtime di destinazione".

Di seguito sono riportati degli esempi per un'applicazione .NET WinForms denominata 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
}

Riflettore:

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

È anche possibile esaminare l'elenco degli assembly a cui si fa riferimento e cercare il riferimento con il numero di versione più alto.

Ancora una volta, utilizzando ILDASM guardando i dati del nodo "MANIFEST":

.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
}

E usando Reflector, guardando il dissambly (ancora come IL) per ogni riferimento elencato:

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

Trovando il riferimento con i metadati della versione più alta è possibile determinare da quale versione del Framework proviene il riferimento, il che indicherebbe che è necessaria la stessa versione del Framework installato per l'esecuzione dell'applicazione. Detto questo, non lo considererei affidabile al 100%, ma non credo che cambierà presto.

Utilizzo di Blocco note , vecchio di tre decenni, dimensioni 200kb, strumento preinstallato:

• apri l'applicazione con notepad appname.exe,
• cerca la parola "framework",
• ripetere l'ultima ricerca con F3finché non viene .NET Framework,version=vX.Yvisualizzato
• se non viene trovato nulla (versioni inferiori alla 3.0), cercare v2.... ancora 100 volte più facile quindi installare gigabyte di strumenti di analisi di dot net e garbage studios.

Qualsiasi altro editor / visualizzatore può aprire anche binari, come Notepad ++ o l'ottimo lister visualizzatore di testo / esadecimale di totalCommander .

Un approccio più semplificato sarebbe usare dotPeek e vedere cosa compare nell'albero.

Vedi il pannello delle proprietà:

È ora possibile usare ILSpy per esaminare il framework di destinazione di un assembly. Dopo aver caricato l'assembly, fai clic sulla radice del nodo dell'assembly e puoi trovare le informazioni sotto la dichiarazione TargetFramework:

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

Dal codice puoi usare Assembly.ImageRuntimeVersionma guardando il file probabilmente la cosa migliore da fare sarebbe usare reflector e vedere a quale versione mscorlibsi fa riferimento.

Modifica: ancora meglio sarebbe usare ildasm , aprire l'assembly e quindi visualizzare il manifest per l'assembly. La prima riga del manifesto indicherà la versione esatta di CLR per cui è stato creato l'assembly.

Puoi usare uno strumento chiamato CorFlags.exe. È in circolazione da .NET 2.0 e so per certo che è incluso in Windows SDK 7.0. Per impostazione predefinita (su Windows XP Pro) è installato in C: \ Programmi \ Microsoft SDKs \ Windows \ v7.0A \ bin \ CorFlags.exe. Fornisci il percorso del file a un modulo gestito (senza altri flag della riga di comando) per visualizzare le informazioni di intestazione, che include la versione.

Tieni presente che questa utility è progettata per modificare l'intestazione PE32 di un modulo, quindi non utilizzare nessuno dei flag finché non leggi attentamente la documentazione .

Dalla riga di comando: find "Framework" MyApp.exe

Oppure puoi semplicemente scoprire quale riferimento di System.Core ha. Questo ti dirà la versione di .NET Framework che questa app sta utilizzando. Per 2.0 la versione di System.Core sarà 2.0.xxx.xxx. Per 3.5 la versione sarà 3.5.xxx.xxx, ecc.

È possibile ottenere la versione .NET di un file in Windows utilizzando Powershell. Il seguente 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"
}

fornisce il seguente risultato;

Nota che il risultato ha estratto la versione .NET per i file exe in quella cartella, ma farà lo stesso anche per una dll.

Su Linux / OSX / unix puoi usare:

strings that_app.exe | grep 'v2.\|Framework'