Afficher le type d’informations

Article
04/02/2024

La classe System.Type est un élément central de la réflexion. Le common language runtime crée l’objet Type pour un type chargé quand la réflexion le demande. Vous pouvez utiliser les méthodes, les champs, les propriétés et les classes imbriquées d’un objet Typepour connaître toutes les informations le concernant.

Utilisez Assembly.GetType ou Assembly.GetTypes pour obtenir les objets Type des assemblys n’ayant pas été chargés, en passant le nom du ou 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 les objets Type d’un module.

Remarque

Si vous souhaitez examiner et manipuler des méthodes et des types génériques, consultez les informations supplémentaires fournies dans Réflexion et types génériques et Guide pratique pour 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 = Object::typeid->Module->Assembly;

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

' Gets the mscorlib assembly in which the object is defined.
Dim a As Assembly = GetType(Object).Module.Assembly

L’exemple suivant montre comment obtenir les objets Type d’un assembly chargé.

// Loads an assembly using its file name.
Assembly^ a = Assembly::LoadFrom("MyExe.exe");
// Gets the type names from the assembly.
array<Type^>^ types2 = a->GetTypes();
for each (Type^ t in types2)
{
    Console::WriteLine(t->FullName);
}

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

' Loads an assembly using its file name.
Dim a As Assembly = Assembly.LoadFrom("MyExe.exe")
' Gets the type names from the assembly.
Dim types2() As Type = a.GetTypes()
For Each t As Type In types2
    Console.WriteLine(t.FullName)
Next t

Une fois que vous avez obtenu l’objet Type, vous pouvez découvrir les informations relatives aux membres de ce type de nombreuses manières. 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 actuel.

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

Si vous avez un 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.

System.Type et ConstructorInfo

L’exemple suivant montre comment lister 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 namespace System;
using namespace System::Reflection;

class ListMembers
{
public:
    static void Main()
    {
        Type^ t = System::String::typeid;
        Console::WriteLine ("Listing all the public constructors of the {0} type", t);
        // Constructors.
        array<ConstructorInfo^>^ ci = t->GetConstructors(BindingFlags::Public | BindingFlags::Instance);
        Console::WriteLine ("//Constructors");
        PrintMembers(ci);
    }

    static void PrintMembers(array<MemberInfo^>^ ms)
    {
        for each (MemberInfo^ m in ms)
        {
            Console::WriteLine ("{0}{1}", "     ", m);
        }
        Console::WriteLine();
    }
};

int main()
{
    ListMembers::Main();
}

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

' This program lists all the public constructors
' of the System.String class.

Imports System.Reflection

Class ListMembers
    Public Shared Sub Main()
        Dim t As Type = GetType(String)
        Console.WriteLine("Listing all the public constructors of the {0} type", t)
        ' Constructors.
        Dim ci As ConstructorInfo() = t.GetConstructors((BindingFlags.Public Or BindingFlags.Instance))
        Console.WriteLine("//Constructors")
        PrintMembers(ci)
    End Sub
    Public Shared Sub PrintMembers(ms() As MemberInfo)
        Dim m As MemberInfo
        For Each m In ms
            Console.WriteLine("{0}{1}", "     ", m)
        Next m
        Console.WriteLine()
    End Sub
End Class

MemberInfo, MethodInfo, FieldInfo et PropertyInfo

Obtenez des informations sur les méthodes, propriétés, événements et champs d’un type à l’aide des objets MemberInfo, MethodInfo, FieldInfo et PropertyInfo.

L’exemple suivant utilise MemberInfo pour lister le nombre de membres de la classe System.IO.FileSystem.IO.File et la propriété IsPublic pour déterminer la visibilité de la classe.

using namespace System;
using namespace System::IO;
using namespace System::Reflection;

public ref class MyMemberInfo
{
public:
    static void Main()
    {
        Console::WriteLine ("\nReflection.MemberInfo");
        // Gets the Type and MemberInfo.
        Type^ myType = Type::GetType("System.IO.File");
        array<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);
        }
    }
};

int main()
{
    MyMemberInfo::Main();
}

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

Imports System.IO
Imports System.Reflection

Class MyMemberInfo
    Public Shared Sub Main()
        Console.WriteLine("\nReflection.MemberInfo")
        ' Gets the Type and MemberInfo.
        Dim myType As Type = Type.GetType("System.IO.File")
        Dim myMemberInfoArray() As MemberInfo = 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)
        End If
    End Sub
End Class

L’exemple suivant examine 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 namespace System;
using namespace System::Reflection;

public ref 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;
    }
};

int main()
{
    MyMethodInfo::Main();
}

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

' This code displays information about the GetValue method of FieldInfo.
Imports System.Reflection
Class MyMethodInfo
    Public Shared Sub Main()
        Console.WriteLine("Reflection.MethodInfo")
        ' Gets and displays the Type.
        Dim myType As Type = Type.GetType("System.Reflection.FieldInfo")
        ' Specifies the member for which you want type information.
        Dim myMethodInfo As MethodInfo = myType.GetMethod("GetValue")
        Console.WriteLine((myType.FullName & "." & myMethodInfo.Name))
        ' Gets and displays the MemberType property.
        Dim myMemberTypes As MemberTypes = myMethodInfo.MemberType
        If MemberTypes.Constructor = myMemberTypes Then
            Console.WriteLine("MemberType is of type All")
        ElseIf MemberTypes.Custom = myMemberTypes Then
            Console.WriteLine("MemberType is of type Custom")
        ElseIf MemberTypes.Event = myMemberTypes Then
            Console.WriteLine("MemberType is of type Event")
        ElseIf MemberTypes.Field = myMemberTypes Then
            Console.WriteLine("MemberType is of type Field")
        ElseIf MemberTypes.Method = myMemberTypes Then
            Console.WriteLine("MemberType is of type Method")
        ElseIf MemberTypes.Property = myMemberTypes Then
            Console.WriteLine("MemberType is of type Property")
        ElseIf MemberTypes.TypeInfo = myMemberTypes Then
            Console.WriteLine("MemberType is of type TypeInfo")
        End If
        Return
    End Sub
End Class

L’exemple suivant utilise toutes les classes Reflection *Info avec BindingFlags pour lister 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 namespace System;
using namespace System::IO;
using namespace System::Reflection;

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

        // Lists static fields first.
        array<FieldInfo^>^ fi = t->GetFields(BindingFlags::Static |
            BindingFlags::NonPublic | BindingFlags::Public);
        Console::WriteLine("// Static Fields");
        PrintMembers(fi);

        // Static properties.
        array<PropertyInfo^>^ pi = t->GetProperties(BindingFlags::Static |
            BindingFlags::NonPublic | BindingFlags::Public);
        Console::WriteLine("// Static Properties");
        PrintMembers(pi);

        // Static events.
        array<EventInfo^>^ ei = t->GetEvents(BindingFlags::Static |
            BindingFlags::NonPublic | BindingFlags::Public);
        Console::WriteLine("// Static Events");
        PrintMembers(ei);

        // Static methods.
        array<MethodInfo^>^ mi = t->GetMethods (BindingFlags::Static |
            BindingFlags::NonPublic | BindingFlags::Public);
        Console::WriteLine("// Static Methods");
        PrintMembers(mi);

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

    static void PrintMembers(array<MemberInfo^>^ ms)
    {
        for each (MemberInfo^ m in ms)
        {
            Console::WriteLine ("{0}{1}", "     ", m);
        }
        Console::WriteLine();
    }
};

int main()
{
    ListMembers::Main();
}

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

' This program lists all the members of the
' System.IO.BufferedStream class.
Imports System.IO
Imports System.Reflection

Class ListMembers
    Public Shared Sub Main()
        ' Specifies the class.
        Dim t As Type = GetType(System.IO.BufferedStream)
        Console.WriteLine("Listing all the members (public and non public) of the {0} type", t)
        ' Lists static fields first.
        Dim fi As FieldInfo() = t.GetFields((BindingFlags.Static Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Static Fields")
        PrintMembers(fi)
        ' Static properties.
        Dim pi As PropertyInfo() = t.GetProperties((BindingFlags.Static Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Static Properties")
        PrintMembers(pi)
        ' Static events.
        Dim ei As EventInfo() = t.GetEvents((BindingFlags.Static Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Static Events")
        PrintMembers(ei)
        ' Static methods.
        Dim mi As MethodInfo() = t.GetMethods((BindingFlags.Static Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Static Methods")
        PrintMembers(mi)
        ' Constructors.
        Dim ci As ConstructorInfo() = t.GetConstructors((BindingFlags.Instance Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Constructors")
        PrintMembers(ci)
        ' Instance fields.
        fi = t.GetFields((BindingFlags.Instance Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Instance Fields")
        PrintMembers(fi)
        ' Instance properties.
        pi = t.GetProperties((BindingFlags.Instance Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Instance Properties")
        PrintMembers(pi)
        ' Instance events.
        ei = t.GetEvents((BindingFlags.Instance Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Instance Events")
        PrintMembers(ei)
        ' Instance methods.
        mi = t.GetMethods((BindingFlags.Instance Or BindingFlags.NonPublic Or BindingFlags.Public))
        Console.WriteLine("// Instance Methods")
        PrintMembers(mi)
        Console.WriteLine(ControlChars.CrLf & "Press ENTER to exit.")
        Console.Read()
    End Sub

    Public Shared Sub PrintMembers(ms() As MemberInfo)
        Dim m As MemberInfo
        For Each m In ms
            Console.WriteLine("{0}{1}", "     ", m)
        Next m
        Console.WriteLine()
    End Sub
End Class

Partager via

Afficher le type d’informations

System.Type et ConstructorInfo

MemberInfo, MethodInfo, FieldInfo et PropertyInfo

Ressources supplémentaires