Determinar la versión del ensamblado del marco (CLR)

class Program {
  static void Main(string[] args) { 
      System.Console.WriteLine(
             System.Reflection.Assembly.LoadFrom(args[0]).ImageRuntimeVersion);
  }
}

Compile y ejecute la aplicación anterior bajo el último.NET Framework (ya que un CLR anterior puede no poder cargar ensamblados que requieran un CLR más nuevo) y ejecútelo pasando la ruta al ensamblado que desea verificar como argumento de línea de comandos.

Una aclaración...

El problema con todos los métodos mencionados es que devolverán la versión 4.0 si el ensamblado se compiló contra.NET framework 4.0, 4.5 o 4.5.1.

La forma de calcular esta versión programáticamente en tiempo de ejecución es usando el Sistema.Ejecución.Versionado.TargetFrameworkAttribute for the given assembly, for example

using System;
using System.Linq;
using System.Reflection;
using System.Runtime.Versioning;

...    

object[] list = Assembly.GetExecutingAssembly().GetCustomAttributes(true);
var attribute = list.OfType<TargetFrameworkAttribute>().First();

Console.WriteLine(attribute.FrameworkName);
Console.WriteLine(attribute.FrameworkDisplayName);

Volverá

a.FrameworkName ".NETFramework,Version=v4.0"    string
a.FrameworkDisplayName  ".NET Framework 4"      string

a.FrameworkName ".NETFramework,Version=v4.5"    string
a.FrameworkDisplayName  ".NET Framework 4.5"    string

a.FrameworkName ".NETFramework,Version=v4.5.1"  string
a.FrameworkDisplayName  ".NET Framework 4.5.1"  string

Aquí hay un PowerShell equivalente al código.NET sugerido en otra respuesta. Usar PowerShell significa que puede omitir algunos pasos, como crear y compilar un ensamblado.

En un símbolo del sistema de PowerShell, ejecute lo siguiente:

[System.Reflection.Assembly]::LoadFrom("C:\...\MyAssembly.dll").ImageRuntimeVersion

De forma predeterminada, PowerShell utiliza el tiempo de ejecución de.NET v2, por lo que obtendrá una excepción para los ensamblados dirigidos a v4. Pregunta de desbordamiento de pila ¿Cómo puedo ejecutar PowerShell con el tiempo de ejecución de. NET 4? detalles de los métodos para cambiar eso, si requerir.

Desde la línea de comandos

Descarga tu dll / exe / CLRHEADER

Sugeriría usar ReflectionOnlyLoadFrom () en lugar de LoadFrom()

Tiene la ventaja de que puede cargar ensamblajes x64 e ia64 cuando se ejecuta en una máquina x86, mientras que LoadFrom() no lo hará.

Aunque todavía no carga ensamblados.Net 4.0 desde un powershell 2.0.

Como sugirió @mistika, es mejor usar ReflectionOnlyLoadFrom() en lugar de LoadFrom(). La desventaja de esto es que llamar a GetCustomAttributes() en un ensamblado cargado con ReflectionOnlyLoadFrom() arroja una excepción. Necesitas llamar a GetCustomAttributesData() en su lugar:

var assembly = Assembly.ReflectionOnlyLoadFrom(assemblyPath);
var customAttributes = assembly.GetCustomAttributesData();
var targetFramework = customAttributes.FirstOrDefault(attr => attr.AttributeType.Equals(typeof(TargetFrameworkAttribute)));

var frameworkName = string.Empty;
var frameworkDisplayName = string.Empty;
if (null != targetFramework)
{
    if(targetFramework.ConstructorArguments.Any())
    {
        // first argument is the name of the framework.
        frameworkName = (string)targetFramework.ConstructorArguments[0].Value;
    }

    // search for a named argument called "FrameworkDisplayName"
    var frameworkDisplayNameArg = targetFramework.NamedArguments.FirstOrDefault(arg => arg.MemberName.Equals("FrameworkDisplayName"));
    if (null != frameworkDisplayNameArg)
    {
        frameworkDisplayName = (string)frameworkDisplayNameArg.TypedValue.Value;
    }
}

Console.WriteLine("Framework Name: " + frameworkName);
Console.WriteLine("Framework Display Name: " + frameworkDisplayName);

Aquí hay un liner de powershell one que mostrará la versión del framework de destino para ensamblajes dirigidos a v4 y superiores.

 Resolve-Path($args) | Select @{N='Assembly'; E={$_ }}, @{N='TargetFramework'; E={(([Reflection.Assembly]::ReflectionOnlyLoadFrom($_).GetCustomAttributesData() | Where-Object { $_.AttributeType -like "System.Runtime.Versioning.TargetFrameworkAttribute" })).NamedArguments.TypedValue}} | Format-Table

Uso:

C:\test\> show-targetfw.ps1 *.dll

Assembly             TargetFramework
--------             --------
C:\test\a.dll        ".NET Framework 4.6.1"
C:\test\b.dll        ".NET Framework 4.5.2"

Una herramienta muy bonita es JustDecompile de Telerik. Puede abrir ensamblados y la herramienta muestra si tienen como objetivo 4.5, 4.5.1 o 4.6

Si desea incluir el resultado en un script, le recomiendo usar la salida de texto de ildasm.exe, y luego grep "Cadena de versión" de la salida.

"C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools\ildasm.exe" /text D:\LocalAssemblies\Toolfactory.Core.BaseTypes.dll /noil /headers | find "' Version String"

Tenga en cuenta que incluyo un ' por lo que el comando find no reconoce "Version String Length"

Pruebe este ejecutable Información del ensamblado para obtener la versión del ensamblado, que le indica la versión de CLR que requiere, y también otra información tales como Opciones de compilación, Procesador de destino y Referencias: