jueves, 16 de diciembre de 2010

Obtener PublicKeyToken de una assembly

Muchas veces, nos hemos encontrado con la necesidad de obtener el PublicKeyToken de una assembly para poderlo añadir por ejemplo a una directiva <%@ Page %> o <%@ Control %>  de nuestra solución, esto se consigue mediante la herramienta sn.exe (Strong Name Tool).

Para usar esta herramienta sería necesario abrir una consola de visual studio y ejecutar esta herramient pasándole los parámetros apropiados. Podemos automatizar este proceso usando la opción de añadir una External Tool a nuestro Visual Studio, lo podemos hacer la siguiente forma:

En Visual Studio hacemos:

  • Menú Tools > External Tools
  • Pulsamos Add
  • Title: Get &PublicKeyToken
  • Command: C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\sn.exe
  • Arguments: -Tp $(TargetPath)
  • Marcamos la opción “Use Output Window”
  • Pulsamos OK

Con este procedimiento se nos ha añadido una nueva opción de menú en el menú Tools con el nombre Get PublicKeyToken. Y voilà ya podemos obtener nuestro publicKeyToken del proyecto en el que estemos situados.

Fuente: http://blogs.msdn.com/b/kaevans/archive/2008/06/18/getting-public-key-token-of-assembly-within-visual-studio.aspx

miércoles, 1 de diciembre de 2010

Reflection y como ser un Jedi (Parte 3)

En el anterior post vimos la potencia de Reflection a la hora de preguntar por sus métodos, propiedades, variables, etc. a un ensamblado y además hubo un poco de teoría en cuanto a conceptos como MSIL, CLR, JIT, etc., eso sí, muy básica. Para más información Google.

Por último decir, que la potencia sin control no sirve de nada, con reflection la línea que hay entre la fuerza y el lado oscuro es muy delgada. Es decir con un par de líneas de código nos podemos saltar muchos principios de los lenguajes orientados a objetos, como por ejemplo la encapsulación. Reflection nos permitiría invocar a un constructor privado, o invocar a un método privado, o obtener las variables privadas de cualquier classe. Por eso, tenemos que ser muy conscientes de que estamos tocando con reflection.

Reflection y como ser un Jedi (Part 2)

Resumen: En la entrada anterior vimos una definición de reflection y los namespaces necessarios, para trabajar con reflection. Más adelante se vió algunos ejemplos de cómo crear objetos y como consultar los diferentes constructores de un tipo determinado.

Hecho este pequeño recordatorio vamos a ver que más cosillas podriamos hacer con reflection y subir así un nivel en nuestro curso de Jedi, a saber, ser un Padawan.

Haciendo algún pequeño cambio a nuestro programa, podemos consultar también los métodos, propiedades y variables (fields) de nuestro código.

EJEMPLO 2:
Vamos a ver que métodos tiene nuestra StupidClass:

using System;
using System.Reflection;

namespace StupidNameSpace
{
public class Program
{
static void Main(string[] args)
{
// Obtenemos el tipo, tenemos que pasadle todo el fully qualified name,
// tened en cuenta que estamos en el mismo namespace, y en el mismo assembly, sino fuera así,
// tendriamos que pasarle, el nombre del assembly.
var type = Type.GetType("StupidNameSpace.StupidClass");

MethodInfo[] methods = type.GetMethods();
foreach (MethodInfo mi in methods)
{
Console.WriteLine(string.Format("Method name: {0}",mi.Name));
if(mi.IsPrivate) Console.WriteLine("Private");
else Console.WriteLine("Public");
if(mi.IsStatic) Console.WriteLine("Static");

if (mi.IsVirtual) Console.WriteLine("Virtual");
var parameters = mi.GetParameters();
if(parameters.Length > 0) Console.WriteLine("Parameters:");

foreach(ParameterInfo pi in parameters)
{
Console.WriteLine(string.Format("--> Parameter name: {0}",pi.Name));
Console.WriteLine(string.Format("--> Parameter type: {0}",pi.ParameterType));
}
}

Console.Read();
}
}
}



Cómo se puede observar no supondría ninguna complicación mostrar las propiedades utilizando el método GetProperties que devuelve un array de PropertyInfo o el mostrar los fields utilizando el método GetFields que a su vez devuelve un array de FieldInfo.



Es más, podriamos usar el método GetMethodBody() de la clase MethodInfo, que nos prové acceso a los metadatos y al MSIL del método.



Recordad MSIL significa Microsoft Intermediate Language, es el código que se genera al compilar nuestra aplicación, este código no es un lenguaje máquina en sí, bueno es un “lenguaje máquina” capaz de ser leído por el CLR (Common Language Runtime, “la máquina virtual de .NET”), éste código, será transformado en verdadero código máquina para nuestra procesador por el JIT (just-in-time compiler) que es un componente del CLR.



De esta forma podriamos crearnos un lector de código MSIL, para obtener el código MSIL de los ensamblados que queramos. Es interesante ver algunos ejemplos de esto mismo en:



http://blogs.msdn.com/b/haibo_luo/archive/2005/10/02/476242.aspx



http://www.codeproject.com/KB/cs/sdilreader.aspx



Aquí obtenemos una buena explicación del MSIL:



http://www.codeproject.com/KB/msil/ilassembly.aspx



Llegados a este punto decir que disponemos de una maravillosa herramienta, llamada .Net Reflector que va un paso más allá y nos permite obtener tanto el código MSIL de un assembly, como el código de alto nivel C#, VB, etc.