Buenas tardes, hace unos dias escribi un poco sobre la Reflexión en java, pero acaso la Reflexión en C# es lo mismo ?

La Reflexión es la capacidad de algunos lenguajes de acceder a su estructura mediante su metadata. Los lenguajes de .NEt Framework 2.0 proveen esta funcionalidad mediante el assembly System.Reflection.

En este namespace podemos encontrar clases que hacen referencia al contenido de un Assembly, Tipo de Datos, Propiedades, miembros, métodos, etc.

using System.Reflection;

Utilizando reflexión podemos consultar los tipos contenidos en un assembly, sus miembros, propiedades y métodos, asi como sus permisos de acceso, entre otras características.

La reflexión nos proporciona objetos del tipo Type.

“La capacidad de la reflexión de la plataforma .NET (similar a la de la plataforma Java) nos permite explorar información sobre los tipos de los objetos en tiempo de ejecución.”

El primer ejemplo que expondré sobre la utilización de Reflexión será reconocer el tipo de un assembly y listar su contenido. Se puede obtener un assembly de varias maneras, las más comunes son obtener el assembly que se está ejecutando (actual) y obtener un assembly en base a su nombre (puede ser una librería de clases). A continuación se listan ambas opciones:

//Carga el Assembly en ejecución actual.
Assembly actual = Assembly.GetExecutingAssembly();

// Carga un Assembly en base a su nombre
// (Sin la extension .dll, .exe, etc.)
Assembly asm = Assembly.Load("LibreriaDeTesting");

Ahora que tenemos una referencia al assembly podemos inspeccionar su contenido y obtener información relevante

// Carga un Assembly en base a su nombre
// (Sin la extension .dll, .exe, etc.)
Assembly asm = Assembly.Load("LibreriaDeTesting");

Type[] tipos = asm.GetTypes();
foreach (Type tipo in tipos)
{
    // Imprimimos los nombres de las clases solamente.
    if (tipo.IsClass)
        System.Console.WriteLine("Clase : " + tipo.Name);
}

Se puede consultar si un tipo es una clase, enum, interfaz, clase abstracta, tipo primitivo, elemento público, arreglo, tipo genérico, puntero, serializable, entre otras propiedades posibles. Estas consultas se hacen en base a propiedades de la forma tipo.IsXXXX, donde XXXX será: Class, Enum, Interface, etc.

Ahora que sabemos como acceder a los tipos de un assembly, podemos obtener información específica de cada tipo:

// Carga un Assembly en base a su nombre
// (Sin extension .dll, .exe, etc.))
Assembly asm = Assembly.Load("LibreriaDeTesting");

Type[] tipos = asm.GetTypes();
foreach (Type tipo in tipos)
{
    // Imprimimos los nombres de las clases solamente.
    if (tipo.IsClass){
        System.Console.WriteLine("nClase : " + tipo.Name);

    PropertyInfo[] propiedades = tipo.GetProperties();
    System.Console.WriteLine("Propiedades:");
    foreach (PropertyInfo prop in propiedades)
    {
        string nombre = prop.Name;
        string tipoCampo = prop.PropertyType.Name;
        System.Console.WriteLine("t-Propiedad:" + nombre +
              ", tipo:" + tipoCampo);
    }

    MethodInfo[] metodos = tipo.GetMethods();
    System.Console.WriteLine("Metodos:");
    foreach (MethodInfo met in metodos)
    {
        string nombre = met.Name;
        string tipoCampo = met.ReturnType.Name;
        System.Console.WriteLine("t-Metodo:" + nombre + ", tipo:" +
                tipoCampo);
    }
}

También es posible saber si una clase define o no un atributo en particular.

// Carga un Assembly en base a su nombre
// (Sin extension .dll, .exe, etc.)
Assembly asm = Assembly.Load("LibreriaDeTesting");

Type[] tipos = asm.GetTypes();
foreach (Type tipo in tipos)
{
    // Imprimimos los nombres de las clases solamente.
    if (tipo.IsClass){
        System.Console.Write("nClase : " + tipo.Name);

        if (tipo.IsDefined(typeof(Serializable), false))
        {
            System.Console.Write(" – Es Serializable!");
        }
        System.Console.WriteLine();
    }
}

El alcance de esto en realidad es .. la posibilidad de definir nuestros propios atributos para luego consultar qué clases, métodos, miembros o propiedades definen dichos atributos y realizar las acciones que estimemos pertinentes.

Si deseamos llamar a un método en especifico…

string tipo = “ClaseQueContieneElMetodo”;
string ensamblado = “NombreEnsamblado”;

Assembly a = Assembly.Load(ensamblado);

//Obtenemos una instáncia del objeto
Type typeT = a.GetType(ensamblado + “.” + tipo);

MethodInfo methodinf =  typeT.GetMethod("Metodo_a_llamar");