Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

Affichage des informations de type

La classe System.Type est l'élément central de la réflexion. Le Common Language Runtime crée Type pour un type chargé, lorsque la réflexion le demande. Vous pouvez utiliser les méthodes, champs, propriétés et classes imbriquées d'un objet Type pour connaître toutes les informations relatives à ce type.

Utilisez Assembly.GetType ou Assembly.GetTypes pour obtenir les objets Type des assemblys n'ayant pas été chargés, en passant le nom des types souhaités. Utilisez Type.GetType pour obtenir les objets Type d'un assembly déjà chargé. Utilisez Module.GetType et Module.GetTypes pour obtenir des objets de module Type.

Remarque Remarque

Si vous souhaitez examiner et manipuler des types et des méthodes génériques, consultez les informations supplémentaires fournies dans Réflexion et types génériques et Comment : examiner et instancier des types génériques avec la réflexion.

L'exemple suivant montre la syntaxe nécessaire pour obtenir l'objet Assembly et le module d'un assembly.


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


L'exemple suivant montre comment obtenir des objets Type à partir d'un assembly chargé.


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


Une fois Type obtenu, il existe de nombreuses façons de découvrir les informations relatives aux membres de ce type. Par exemple, vous pouvez rechercher des informations sur tous les membres du type en appelant la méthode Type.GetMembers, qui obtient un tableau d'objets MemberInfo décrivant chaque membre du type en cours.

Vous pouvez également utiliser des méthodes sur la classe Type pour récupérer des informations sur les constructeurs, méthodes, événements, champs ou propriétés que vous spécifiez par le nom. Par exemple, Type.GetConstructor encapsule un constructeur spécifique de la classe en cours.

Si vous disposez de Type, vous pouvez utiliser la propriété Type.Module pour obtenir un objet qui encapsule le module contenant ce type. Utilisez la propriété Module.Assembly pour localiser un objet qui encapsule l'assembly contenant le module. Vous pouvez obtenir directement l'assembly qui encapsule le type en utilisant la propriété Type.Assembly.

L'exemple suivant montre comment répertorier les constructeurs d'une classe, dans le cas présent, la 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();
    }
}


Obtenez des informations à propos des méthodes du type, propriétés, événements et champs à l'aide de MemberInfo, MethodInfo, FieldInfoou objets PropertyInfo.

L'exemple suivant utilise MemberInfo pour répertorier le nombre de membres de la classe System.IO.File et utilise la propriété System.Type.IsPublic pour déterminer la visibilité de la 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);
        }
    }
}


L'exemple suivant recherche le type du membre spécifié. Il effectue une réflexion sur un membre de la classe MemberInfo, puis affiche son type.


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


L'exemple suivant utilise toutes les classes Reflection *Info avec BindingFlags pour répertorier tous les membres (constructeurs, champs, propriétés, événements et méthodes) de la classe spécifiée et les afficher en deux catégories : statique et instance.


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


Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft