Cómo... Mostrar los miembros de un tipo usando Reflection

Enumerar los miembros de una clase (tipo), usando Reflection

Publicado el 08/Ene/2004
Actualizado el 08/Ene/2004

En este ejemplo, te mostraré cómo averiguar los miembros de un tipo utilizando Reflection (reflexión), por ejemplo para saber los métodos, propiedades, constructores y campos que tiene.

En el código que te mostraré, para no complicar mucho la cosa y así te enteres mejor, simplemente se mostrarán los "miembros", pero no los parámetros ni tipos devueltos.
Para averiguar esta información... le echas un vistazo a la documentación y así experimentas por tu cuenta... je, je.

El método se llama infoTipo y se le pasará por parámetro el tipo que queremos examinar.
Por ejemplo, si queremos saber los miembros del tipo String, podríamos llamar al método de esta forma:
infoTipo(GetType(String))
Y si lo que quieres es saber los miembros de un tipo que has declarado:
Dim prueba As New ClasePrueba
infoTipo(prueba.GetType)

En otra ocasión te mostraré cómo saber los parámetros que tiene y esas cosillas, pero mientras tanto... inténtalo por tu cuenta, que así aprenderás más...

Nos vemos.
Guillermo
P.S.
El código de ejemplo se muestra tanto en Visual Basic .NET como en C#.

El código para VB .NET

'------------------------------------------------------------------------------
' Enumerar el contenido de una clase por medio de reflexión         (08/Ene/04)
'
' ©Guillermo 'guille' Som, 2004
'------------------------------------------------------------------------------
Imports System.Reflection

Module Module1
    Public Sub Main(ByVal args() As String)
        Dim cprueba As New ClasePrueba
        '
        infoTipo(cprueba.GetType)
        '
        Console.ReadLine()
    End Sub
    '
    Private Sub infoTipo(ByVal t As Type)
        Dim flags As BindingFlags = BindingFlags.Instance _
                        Or BindingFlags.Public _
                        Or BindingFlags.DeclaredOnly _
                        Or BindingFlags.Static
        Dim s As String = String.Format("Los miembros públicos de: {0}", t.Name)
        Console.WriteLine(s)
        Console.WriteLine(New String("="c, s.Length))
        '
        Console.WriteLine("Los campos")
        Dim cs As FieldInfo() = t.GetFields(flags)
        For Each m As FieldInfo In cs
            Console.WriteLine("   {0}", m.Name)
        Next
        Console.WriteLine()
        '
        Console.WriteLine("Los métodos")
        Dim mi As MethodInfo() = t.GetMethods(flags)
        For Each m As MethodInfo In mi
            ' no mostrar los que tienen nombres especiales
            ' por ejemplo, las propiedades tendrán dos métodos asociados:
            ' get_NombrePropiedad y set_NomprePropiedad
            If m.IsSpecialName = False Then
                Console.WriteLine("   {0}", m.Name)
            End If
        Next
        Console.WriteLine()
        '
        Console.WriteLine("Las propiedades")
        Dim pr As PropertyInfo() = t.GetProperties(flags)
        For Each m As PropertyInfo In pr
            Console.WriteLine("   {0}", m.Name)
        Next
        Console.WriteLine()
        '
        Console.WriteLine("Los eventos")
        Dim evs As EventInfo() = t.GetEvents(flags)
        For Each m As EventInfo In evs
            Console.WriteLine("   {0}", m.Name)
        Next
        Console.WriteLine()
    End Sub
End Module

Public Class ClasePrueba
    ' los constructores
    Public Sub New()
    End Sub
    Public Sub New(ByVal valor As String)
        CampoPublico1 = valor
    End Sub
    ' los campos
    Public CampoPublico1 As String
    Private campoPrivado1 As Boolean
    ' las propiedades
    Public Property Propiedad1() As Boolean
        Get
            Return campoPrivado1
        End Get
        Set(ByVal value As Boolean)
            campoPrivado1 = value
        End Set
    End Property
    ' los métodos
    Public Sub MetodoPublico1()
        Console.WriteLine("El MetodoPublico1")
    End Sub
    Public Sub MetodoPublico2(ByVal saludo As String)
        Console.WriteLine("El MetodoPublico2: {0}", saludo)
    End Sub
    Public Overrides Function ToString() As String
        Return "Esta es la clase ClasePrueba"
    End Function
End Class

El código para C#

//-----------------------------------------------------------------------------
// Enumerar el contenido de una clase por medio de reflexión        (08/Ene/04)
// Versión en C#, código convertido con deVBaCS
//
// ©Guillermo 'guille' Som, 2004
//-----------------------------------------------------------------------------
using System.Reflection;
using System;

/// 
/// Descripción breve de Class1.
/// 
class Class1
{
    /// 
    /// Punto de entrada principal de la aplicación.
    /// 
    [STAThread]
    static void Main(string[] args)
    {
        //
        // TODO: agregar aquí código para iniciar la aplicación
        //
        ClasePrueba cprueba = new  ClasePrueba();
        //
        //
        //miembrosTipo(cprueba.GetType());
        infoTipo(cprueba.GetType());
        //infoTipoSimple(GetType(String));
        //
        Console.ReadLine();
    }
    //
    private static void infoTipo(Type  t)
    {
        BindingFlags flags  = BindingFlags.Instance
            | BindingFlags.Public
            | BindingFlags.DeclaredOnly
            | BindingFlags.Static;
        string s  = String.Format("Los miembros públicos de: {0}", t.Name);
        Console.WriteLine(s);
        Console.WriteLine(new string('=', s.Length));
        //
        Console.WriteLine("Los campos");
        FieldInfo[] cs  = t.GetFields(flags);
        foreach(FieldInfo m in cs)
        {
            Console.WriteLine("   {0}", m.Name);
        }
        Console.WriteLine();
        //
        Console.WriteLine("Los métodos");
        MethodInfo[] mi  = t.GetMethods(flags);
        foreach(MethodInfo m in mi)
        {
            // no mostrar los que tienen nombres especiales
            // por ejemplo, las propiedades tendrán dos métodos asociados:
            // get_NombrePropiedad y set_NomprePropiedad
            if( m.IsSpecialName == false )
            {
                Console.WriteLine("   {0}", m.Name);
            }
        }
        Console.WriteLine();
        //
        Console.WriteLine("Las propiedades");
        PropertyInfo[] pr  = t.GetProperties(flags);
        foreach(PropertyInfo m in pr)
        {
            Console.WriteLine("   {0}", m.Name);
        }
        Console.WriteLine();
        //
        Console.WriteLine("Los eventos");
        EventInfo[] evs  = t.GetEvents(flags);
        foreach(EventInfo m in evs)
        {
            Console.WriteLine("   {0}", m.Name);
        }
        Console.WriteLine();
    }
}
//
public class ClasePrueba
{
    // los constructores
    public ClasePrueba()
    {
    }  
    public ClasePrueba(string  valor)
    {
        CampoPublico1 = valor;
    }  
    // los campos
    public string CampoPublico1;
    private bool campoPrivado1;
    // las propiedades
    public bool  Propiedad1
    {
        get
        {
            return campoPrivado1;
        }
        set
        {
            campoPrivado1 = value;
        }
    }  
    // los métodos
    public void MetodoPublico1()
    {
        Console.WriteLine("El MetodoPublico1");
    }  
    public void MetodoPublico2(string  saludo)
    {
        Console.WriteLine("El MetodoPublico2: {0}", saludo);
    }  
    public override string ToString()
    {
        return "Esta es la clase ClasePrueba";
    }  
}