Markieren Sie das Kontrollkästchen Englisch, um die englische Version dieses Artikels anzuzeigen. Sie können den englischen Text auch in einem Popup-Fenster einblenden, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Anzeigen von Typinformationen

 

Die System.Type-Klasse ist für die Reflektion von zentraler Bedeutung. Auf Anforderung der Reflektion erstellt Common Language Runtime den Type für einen geladenen Typ. Sie können die Methoden, Felder, Eigenschaften und geschachtelten Klassen dieses Type-Objekts verwenden, um sämtliche Informationen über diesen Typ zu erhalten.

Mit Assembly.GetType oder Assembly.GetTypes können Sie Type-Objekte nicht geladener Assemblys abrufen, indem Sie den Namen des gewünschten Typs bzw. der gewünschten Typen übergeben. Mit Type.GetType können Sie Type-Objekte einer bereits geladenen Assembly abrufen. Mit Module.GetType und Module.GetTypes können Sie Type-Modulobjekte abrufen.

System_CAPS_noteHinweis

Zusätzliche Informationen zum Überprüfen und Bearbeiten von generischen Typen und Methoden finden Sie unter Reflektion und generische Typen und Gewusst wie: Untersuchen und Instanziieren von generischen Typen mit Reflektion.

Das folgende Beispiel zeigt die Syntax, die erforderlich ist, um das Assembly-Objekt und -Modul für eine Assembly abzurufen.

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

Im folgenden Beispiel werden die Namen von Type-Objekten einer geladenen Assembly ausgegeben.

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

Sobald Sie einen Type erhalten haben, gibt es viele Möglichkeiten, Informationen über die Member dieses Typs zu erhalten. Um Informationen über alle Member eines Typs zu erhalten, können Sie z. B. die Type.GetMembers-Methode aufrufen. Diese ruft wiederum ein Array von MemberInfo-Objekten ab, die alle Member des aktuellen Typs beschreiben.

Sie können auch Methoden der Type-Klasse verwenden, um Informationen über einen oder mehrere Konstruktoren, Methoden, Ereignisse, Felder oder Eigenschaften zu erhalten, die Sie mit Namen angeben. Type.GetConstructor kapselt beispielsweise einen bestimmten Konstruktor der aktuellen Klasse.

Wenn Sie über einen Type verfügen, können Sie die Type.Module-Eigenschaft verwenden, um ein Objekt abzurufen, das das Modul mit dem Typ kapselt. Verwenden Sie die Module.Assembly-Eigenschaft zum Suchen eines Objekts, das die Assembly mit dem Modul kapselt. Sie können die Assembly, die den Typ kapselt, mit der Type.Assembly-Eigenschaft direkt abrufen.

Im folgenden Beispiel werden die Konstruktoren einer Klasse (in diesem Fall der String-Klasse) aufgelistet.

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

Informationen über die Methoden, Eigenschaften, Ereignisse und Felder eines Typs können Sie mit den Objekten MemberInfo, MethodInfo, FieldInfo und PropertyInfo abrufen.

Im folgenden Beispiel wird MemberInfo verwendet, um die Anzahl der Member der System.IO.File-Klasse aufzulisten. Die System.Type.IsPublic-Eigenschaft dient zum Bestimmen der Sichtbarkeit der Klasse.

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

Im folgenden Beispiel wird der Typ eines angegebenen Members untersucht. Für einen Member der MemberInfo-Klasse wird Reflektion durchgeführt. Anschließend wird dessen Typ angezeigt.

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

Im folgenden Beispiel werden die *Info-Klassen der Reflektion zusammen mit BindingFlags verwendet, um alle Member (Konstruktoren, Felder, Eigenschaften, Ereignisse und Methoden) der angegebenen Klasse aufzulisten. Die Member werden in statische und Instanzkategorien unterteilt.

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