Introducción a Reflection (II): Obteniendo metadatos de una clase


En artículos anteriores hemos visto la potencia de las clases contenidas en el espacio de nombres Reflection. Hoy vamos a intentar profundizar un poco más en la potencia que podemos obtener utilizando estos recursos.
Como hemos visto, Reflection proporciona clases que permiten leer los metadatos de una clase. Bien… habrá quien se pregunte… ¿qué es un metadato? Un metadato no es más que un dato que describe a otro dato. Por ejemplo, en el ámbito que vamos a ver a continuación, el nombre de la clase es en sí un metadato. De hecho, la propia clase en sí es un metadato, ya que describe un “patrón” o estructura de los objetos que derivan de ella.
Reflection nos proporciona una serie de clases que se encargan de encapsular ensamblados, módulos y tipos. Esto nos permite realizar acciones como conocer el nombre de una clase o invocar un método de un objeto -a priori- desconocido en tiempo real.

A modo didáctico, veremos las posibilidades de exploración e invocación de reflection. Para comenzar, crearemos una clase con dos atributos, dos propiedades, dos métodos y cuatro constructores, a la que llamaremos ClasePrueba:

using System;
using System.Collections.Generic;
using System.Text;

namespace Simple.Test
{
 /// <summary>
 /// Clase de prueba, cuyo objetivo es demostrar la utilización del espacio de nombres Reflection
 /// </summary>
 /// 
 /// Daniel Garcia (contacto at danigarcia punto o erre ge)
 /// 26/05/2009    Creacion
 /// 
 public class ClasePrueba
 {
    #region Atributos y Propiedades

    private int variableEntera;
    private string variableCadena;

    public int PropiedadEntero
    {
       get { return variableEntera;}
       set { variableEntera = value;}
    }

    public string PropiedadCadena
    {
       get { return variableCadena; }
       set { variableCadena = value; }
    }

 #endregion

 #region Constructores

    public ClasePrueba()
    {
       variableCadena = "";
       variableEntera = 0;
    }

    public ClasePrueba(int entero)
    {
       variableCadena = "";
       variableEntera = entero;
    }

    public ClasePrueba(string cadena)
    {
       variableCadena = cadena;
       variableEntera = 0;
    }

   public ClasePrueba(int entero, string cadena)
    {
       variableCadena = cadena;
       variableEntera = entero;
    }

 #endregion

 #region Funciones

    public int sumarUno(int dato)
    {
       PropiedadEntero = dato + 1;
       return PropiedadEntero;
    }

    public string insertarLetra(char caracter)
    {
       PropiedadCadena += caracter;
       return PropiedadCadena;
    }

 #endregion

    }
}

Creada nuestra clase, es hora de comenzar a “reflexionar” sobre el tema. Como punto de inicio, instanciaremos un objeto de la clase ClasePrueba y declararemos una referencia Type a la asignaremos el tipo de nuestro objeto, mediante la función GetType().

 // Instanciamos el objeto
 ClasePrueba objeto = new ClasePrueba();

 // Obtenemos su tipo
 Type tipoObjeto = objeto.GetType();

A continuación, “exprimimos” el contenido de nuestro tipo, obteniendo información variada como métodos, constructores, propiedades o miembros en general.

 // Obtenemos información sobre miembros, constructores y métodos
 ConstructorInfo[] Constructores = tipoObjeto.GetConstructors();
 MemberInfo[] Miembros = tipoObjeto.GetMembers();
 PropertyInfo[] Propiedades = tipoObjeto.GetProperties();
 MethodInfo[] Metodos = tipoObjeto.GetMethods();

Finalmente, mostrar la información por pantalla será tarea sencilla recorriendo los arrays con distintas informaciones.

 Console.WriteLine("Constructores:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (ConstructorInfo info in Constructores)
     Console.WriteLine(info.ToString());

 Console.WriteLine("Miembros:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (MemberInfo info in Miembros)
     Console.WriteLine(info.ToString());

 Console.WriteLine("Propiedades:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (PropertyInfo info in Propiedades)
     Console.WriteLine(info.ToString());

 Console.WriteLine("Metodos:");
 Console.WriteLine("-------------------------------------------------------------");
 foreach (MethodInfo info in Metodos)
     Console.WriteLine(info.ToString());

El resultado es fascinante: toda la información sobre la clase al alcance de un click.

090501Reflection
Posteriormente comprobaremos otra tarea sencilla con Reflection: invocar métodos de un objeto.

2 comments

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s