Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés

Viewing Type Information

 

La clase System.Type es fundamental para la reflexión. Common Language Runtime crea Type para un tipo cargado cuando lo solicita la reflexión. Se pueden utilizar los métodos, campos, propiedades y clases anidadas de un objeto Type para averiguarlo todo sobre dicho tipo.

Utilice Assembly.GetType o Assembly.GetTypes para obtener objetos Type de los ensamblados que no han sido cargados, pasando el nombre de los tipos que desea. Utilice Type.GetType para obtener los objetos Type de un ensamblado cargado. Utilice Module.GetType y Module.GetTypes para obtener los objetos Type del módulo.

System_CAPS_noteNota

Si desea examinar y manipular tipos y métodos genéricos, vea la información adicional que se proporciona en Reflection and Generic Types y en How to: Examine and Instantiate Generic Types with Reflection.

En el ejemplo siguiente se muestra la sintaxis necesaria para obtener el objeto Assembly y el módulo de un ensamblado.

// Gets the mscorlib assembly in which the object is defined.
Assembly a = typeof(object).Module.Assembly;

En el ejemplo siguiente se muestra cómo obtener los objetos Type de un ensamblado cargado.

// Loads an assembly using its file name.
Assembly a = Assembly.LoadFrom("MyExe.exe");
// Gets the type names from the assembly.
Type[] types2 = a.GetTypes();
foreach (Type t in types2)
{
    Console.WriteLine(t.FullName);
}

Tras obtener un Type, existen varias maneras de detectar información sobre los miembros de dicho tipo. Por ejemplo, para obtener información sobre todos los miembros del tipo, llame al método Type.GetMembers, que obtiene una matriz de objetos MemberInfo que describe cada uno de los miembros del tipo actual.

También se pueden utilizar métodos en la clase Type para recuperar información sobre uno o varios constructores, métodos, eventos, propiedades o campos especificados por su nombre. Por ejemplo, Type.GetConstructor encapsula un constructor específico de la clase actual.

Si tiene Type, puede utilizar la propiedad Type.Module para obtener un objeto que encapsule el módulo que contiene dicho tipo. Se utiliza la propiedad Module.Assembly para buscar un objeto que encapsule el ensamblado que contiene el módulo. Para obtener directamente el ensamblado que encapsula el tipo, utilice la propiedad Type.Assembly.

En el ejemplo siguiente se indica cómo enumerar los constructores de una clase; en este caso, la clase String.

// This program lists all the public constructors
// of the System.String class.
using System;
using System.Reflection;

class ListMembers
{
    public static void Main()
    {
        Type t = typeof(System.String);
        Console.WriteLine("Listing all the public constructors of the {0} type", t);
        // Constructors.
        ConstructorInfo[] ci = t.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
        Console.WriteLine("//Constructors");
        PrintMembers(ci);
    }

    public static void PrintMembers(MemberInfo[] ms)
    {
        foreach (MemberInfo m in ms)
        {
            Console.WriteLine("{0}{1}", "     ", m);
        }
        Console.WriteLine();
    }
}

Para obtener información sobre los métodos, propiedades, eventos y campos del tipo, utilice los objetos MemberInfo, MethodInfo, FieldInfo o PropertyInfo.

En el ejemplo siguiente, se utiliza MemberInfo para mostrar el número de miembros de la clase System.IO.File y se utiliza la propiedad System.Type.IsPublic para determinar la visibilidad de la clase.

using System;
using System.IO;
using System.Reflection;

class Mymemberinfo
{
    public static void Main()
    {
        Console.WriteLine ("\nReflection.MemberInfo");
        // Gets the Type and MemberInfo.
        Type MyType = Type.GetType("System.IO.File");
        MemberInfo[] Mymemberinfoarray = MyType.GetMembers();
        // Gets and displays the DeclaringType method.
        Console.WriteLine("\nThere are {0} members in {1}.",
            Mymemberinfoarray.Length, MyType.FullName);
        Console.WriteLine("{0}.", MyType.FullName);
        if (MyType.IsPublic)
        {
            Console.WriteLine("{0} is public.", MyType.FullName);
        }
    }
}

En el ejemplo siguiente se investiga el tipo del miembro especificado. Realiza una reflexión en un miembro de la clase MemberInfo y muestra su tipo.

// This code displays information about the GetValue method of FieldInfo.
using System;
using System.Reflection;

class MyMethodInfo
{
    public static int Main()
    {
        Console.WriteLine("Reflection.MethodInfo");
        // Gets and displays the Type.
        Type MyType = Type.GetType("System.Reflection.FieldInfo");
        // Specifies the member for which you want type information.
        MethodInfo Mymethodinfo = MyType.GetMethod("GetValue");
        Console.WriteLine(MyType.FullName + "." + Mymethodinfo.Name);
        // Gets and displays the MemberType property.
        MemberTypes Mymembertypes = Mymethodinfo.MemberType;
        if (MemberTypes.Constructor == Mymembertypes)
        {
            Console.WriteLine("MemberType is of type All");
        }
        else if (MemberTypes.Custom == Mymembertypes)
        {
            Console.WriteLine("MemberType is of type Custom");
        }
        else if (MemberTypes.Event == Mymembertypes)
        {
            Console.WriteLine("MemberType is of type Event");
        }
        else if (MemberTypes.Field == Mymembertypes)
        {
            Console.WriteLine("MemberType is of type Field");
        }
        else if (MemberTypes.Method == Mymembertypes)
        {
            Console.WriteLine("MemberType is of type Method");
        }
        else if (MemberTypes.Property == Mymembertypes)
        {
            Console.WriteLine("MemberType is of type Property");
        }
        else if (MemberTypes.TypeInfo == Mymembertypes)
        {
            Console.WriteLine("MemberType is of type TypeInfo");
        }
        return 0;
    }
}

En el ejemplo siguiente se utilizan todas las clases *Info de Reflection junto con BindingFlags para enumerar todos los miembros (constructores, campos, propiedades, eventos y métodos) de la clase especificada, dividiendo los miembros en las categorías de miembros estáticos y miembros de instancia.

// This program lists all the members of the
// System.IO.BufferedStream class.
using System;
using System.IO;
using System.Reflection;

class ListMembers
{
    public static void Main()
    {
        // Specifies the class.
        Type t = typeof(System.IO.BufferedStream);
        Console.WriteLine("Listing all the members (public and non public) of the {0} type", t);

        // Lists static fields first.
        FieldInfo[] fi = t.GetFields(BindingFlags.Static |
            BindingFlags.NonPublic | BindingFlags.Public);
        Console.WriteLine("// Static Fields");
        PrintMembers(fi);

        // Static properties.
        PropertyInfo[] pi = t.GetProperties(BindingFlags.Static |
            BindingFlags.NonPublic | BindingFlags.Public);
        Console.WriteLine("// Static Properties");
        PrintMembers(pi);

        // Static events.
        EventInfo[] ei = t.GetEvents(BindingFlags.Static |
            BindingFlags.NonPublic | BindingFlags.Public);
        Console.WriteLine("// Static Events");
        PrintMembers(ei);

        // Static methods.
        MethodInfo[] mi = t.GetMethods (BindingFlags.Static |
            BindingFlags.NonPublic | BindingFlags.Public);
        Console.WriteLine("// Static Methods");
        PrintMembers(mi);

        // Constructors.
        ConstructorInfo[] ci = t.GetConstructors(BindingFlags.Instance |
            BindingFlags.NonPublic | BindingFlags.Public);
        Console.WriteLine("// Constructors");
        PrintMembers(ci);

        // Instance fields.
        fi = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic |
            BindingFlags.Public);
        Console.WriteLine("// Instance Fields");
        PrintMembers(fi);

        // Instance properites.
        pi = t.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic |
            BindingFlags.Public);
        Console.WriteLine ("// Instance Properties");
        PrintMembers(pi);

        // Instance events.
        ei = t.GetEvents(BindingFlags.Instance | BindingFlags.NonPublic |
            BindingFlags.Public);
        Console.WriteLine("// Instance Events");
        PrintMembers(ei);

        // Instance methods.
        mi = t.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic
            | BindingFlags.Public);
        Console.WriteLine("// Instance Methods");
        PrintMembers(mi);

        Console.WriteLine("\r\nPress ENTER to exit.");
        Console.Read();
    }

    public static void PrintMembers (MemberInfo [] ms)
    {
        foreach (MemberInfo m in ms)
        {
            Console.WriteLine ("{0}{1}", "     ", m);
        }
        Console.WriteLine();
    }
}
Mostrar: