Ler em inglês

Compartilhar via


Ver informações do tipo

A classe System.Type é fundamental para reflexão. O Common Language Runtime cria o Type para um tipo carregado quando a reflexão o solicita. Você pode usar métodos, campos, propriedades e classes aninhadas de um objeto Type para descobrir tudo sobre esse tipo.

Use Assembly.GetType ou Assembly.GetTypes para obter Type objetos de assemblies que não foram carregados, passando o nome do tipo ou tipos desejados. Use Type.GetType para obter os objetos Type de um assembly que já está carregado. Use Module.GetType e Module.GetTypes para obter objetos do módulo Type.

Observação

Se você quiser examinar e manipular tipos genéricos e métodos, consulte as informações adicionais fornecidas na Reflexão e tipos genéricos e Como examinar e instanciar tipos genéricos com reflexão.

O exemplo a seguir mostra a sintaxe necessária obter o objeto Assembly e o módulo para um assembly.

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

O exemplo a seguir demonstra a obtenção de objetos Type de um assembly carregado.

// 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);
}

Depois de obter um Type, há muitas maneiras de descobrir informações sobre os membros desse tipo. Por exemplo, você pode descobrir sobre todos os membros do tipo chamando o método Type.GetMembers, que obtém uma matriz de objetos MemberInfo que descrevem cada um dos membros do tipo atual.

Você também pode usar métodos na classe Type para recuperar informações sobre um ou mais construtores, métodos, eventos, campos ou propriedades especificados por nome. Por exemplo, Type.GetConstructor encapsula um construtor específico da classe atual.

Se você tiver um Type, poderá usar a propriedade Type.Module para obter um objeto que encapsula o módulo que contém esse tipo. Use a propriedade Module.Assembly para localizar um objeto que encapsula o assembly que contém o módulo. Você pode obter o assembly que encapsula o tipo diretamente usando a propriedade Type.Assembly.

System.Type e ConstructorInfo

O exemplo a seguir mostra como listar os construtores de uma classe, nesse caso, a classe 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();
    }
}

MemberInfo, MethodInfo, FieldInfo e PropertyInfo

Obtenha informações sobre métodos, propriedades, eventos e campos do tipo usando os objetos MemberInfo, MethodInfo, FieldInfo ou PropertyInfo.

O exemplo a seguir usa MemberInfo para listar o número de membros na classe System.IO.File e usa a propriedade IsPublic para determinar a visibilidade da classe.

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);
        }
    }
}

O exemplo a seguir examina o tipo do membro especificado. Ele realiza reflexão sobre um membro da classe MemberInfo e lista seu 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;
    }
}

O exemplo a seguir usa todas as classes Reflection *Info junto com BindingFlags para listar todos os membros (construtores, campos, propriedades, eventos e métodos) da classe especificada, dividindo os membros em categorias estáticas e de instância.

// 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 properties.
        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();
    }
}