Recuperar la versión de Target Framework y el perfil de Target Framework de un ensamblado.Net
reflection .net-assembly (4)
La solución de njappboy funciona muy bien. Necesitaba la versión VB.Net, así que aquí está la conversión.
Dim assems = AppDomain.CurrentDomain.GetAssemblies()
Dim filteredType = GetType(Runtime.Versioning.TargetFrameworkAttribute)
Dim assemblyMatches = assems.[Select](Function(x) New With {Key .Assembly = x,
Key .TargetAttribute = CType(x.GetCustomAttribute(filteredType),
Runtime.Versioning.TargetFrameworkAttribute)}).Where(
Function(x) x.TargetAttribute IsNot Nothing)
For Each assem In assemblyMatches
Dim framework = New System.Runtime.Versioning.FrameworkName(
assem.TargetAttribute.FrameworkName)
Console.WriteLine("Assembly: ''{0}'' targets .NET version: ''{1}''.",
assem.Assembly.FullName, framework.Version)
Next
¿Hay alguna forma de acceder a los valores que se utilizaron para TargetFrameworkVersion y / o TargetFrameworkProfile cuando se compiló un ensamblado .Net?
Los valores de los que estoy hablando son los que contenían el archivo del proyecto.
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<OtherStuff>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>
<OtherStuff>
</PropertyGroup>
<OtherStuff>
</OtherStuff>
</Project>
Básicamente, me gustaría saber qué era la versión objetivo del marco cuando se compiló el ensamblaje y, si es posible, también el perfil del marco objetivo.
Y no estoy hablando de la versión actualmente cargada del CLR, Environment.Version no es lo que estoy buscando.
Idealmente, la solución usaría la Reflexión del Sistema, pero si tengo que recurrir a otros métodos, lo haré.
Pruebe también este ejemplo para recuperar las versiones actuales y de destino de .NET framework en tiempo de ejecución (funciona para .NET V4.X):
Dim ca As Object() = System.Reflection.Assembly.GetEntryAssembly().GetCustomAttributes(False)
For Each c In ca.Where(Function(x) x.TypeId.Name = "TargetFrameworkAttribute")
Console.WriteLine("Target .NET framework for " & Application.ProductName & " : " & c.FrameworkDisplayName)
Next
Console.WriteLine("Current .NET framework for " & Application.ProductName & " : " & System.Diagnostics.FileVersionInfo.GetVersionInfo(GetType(Integer).Assembly.Location).ProductVersion)
Si el ensamblaje se compiló con TargetFrameworkAttribute (ensamblado en el ámbito), puede determinar de manera fácil y uniforme el objetivo del perfil del marco.
Pruebe este ejemplo y haga referencia a sus propios ensamblajes personalizados con diferentes objetivos.
class Program
{
static void Main(string[] args)
{
// Lets examine all assemblies loaded into the current application domain.
var assems = AppDomain.CurrentDomain.GetAssemblies();
// The target framework attribute used when the assemby was compiled.
var filteredType = typeof(TargetFrameworkAttribute);
// Get all assemblies that have the TargetFrameworkAttribute applied.
var assemblyMatches = assems.Select(x => new { Assembly = x, TargetAttribute = (TargetFrameworkAttribute)x.GetCustomAttribute(filteredType) })
.Where(x => x.TargetAttribute != null);
// Report assemblies framework target
foreach (var assem in assemblyMatches)
{
var framework = new System.Runtime.Versioning.FrameworkName(assem.TargetAttribute.FrameworkName);
Console.WriteLine("Assembly: ''{0}'' targets .NET version: ''{1}''.",
assem.Assembly.FullName,
framework.Version);
}
Console.ReadLine();
}
}
Si está satisfecho con la versión del CLR que compiló el ensamblaje, puede usar la propiedad Assembly.ImageRuntimeVersion . Según MSDN, esa propiedad:
representa la versión del Common Language Runtime (CLR) guardada en el archivo que contiene el manifiesto.
y
De forma predeterminada, ImageRuntimeVersion se establece en la versión de CLR utilizada para compilar el ensamblaje. Sin embargo, podría haberse establecido en otro valor en el momento de la compilación.
Por supuesto, eso no le da la versión específica de .NET Framework (por ejemplo: .NET Frameworks 2, 3.0 y 3.5 están todos en el CLR 2.0).
Si la versión de CLR no es suficiente, podría intentar "estimar" (adivinar inteligentemente) qué versión debe basarse en los ensamblajes a los que hace referencia. Para .NET 1 y 4, la versión CLR debería ser suficiente. Sin embargo, si la versión de CLR era 2.0, no sabría si eso significaba 2.0, 3.0 o 3.5, por lo que podría probar un poco más de lógica. Por ejemplo, si vio que el ensamblado hacía referencia a System.Core (utilizando Assembly.GetReferencedAssemblies() ), entonces sabría que la versión es 3.5 desde que System.Core era nuevo en 3.5. Eso no es exactamente sólido, ya que el ensamblaje en cuestión podría no usar ningún tipo de ensamblaje, por lo que no podría atraparlo. Para tratar de detectar más casos, puede recorrer todos los ensamblajes a los que se hace referencia y verificar sus números de versión, tal vez filtrando solo ensamblajes que comienzan con el Sistema para evitar falsos positivos con otras bibliotecas. Si ve algún ensamblado de System. * Referenciado que tenga una versión de 3.5.xx, entonces también puede estar bastante seguro de que fue creado para 3.5.
Como se ha dado cuenta, no creo que el TargetFrameworkProfile escape más allá de Visual Studio. Sin embargo, si resulta que hay un archivo app.config para la aplicación, es posible que Visual Studio haya puesto el marco de destino allí. Por ejemplo, si configura el proyecto para usar el perfil de cliente 4.0, Visual Studio crea un app.config como este:
<?xml version="1.0"?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0,Profile=Client"/>
</startup>
</configuration>