Type.GetNestedTypes Methode

Quelle:

Type.cs

Quelle:

Type.cs

Quelle:

Type.cs

Quelle:

Type.cs

Quelle:

Type.cs

public:
 cli::array <Type ^> ^ GetNestedTypes();

public:
 virtual cli::array <Type ^> ^ GetNestedTypes();

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)]
public Type[] GetNestedTypes();

public Type[] GetNestedTypes();

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)>]
member this.GetNestedTypes : unit -> Type[]

member this.GetNestedTypes : unit -> Type[]

abstract member GetNestedTypes : unit -> Type[]
override this.GetNestedTypes : unit -> Type[]

Public Function GetNestedTypes () As Type()

Gibt zurück

Ein Array von Type Objekten, die die öffentlichen Typen darstellen, die in der aktuellen Type (die Suche ist nicht rekursiv) oder ein leeres Array vom Typ Type , wenn keine öffentlichen Typen in der aktuellen Typegeschachtelt sind.

Implementiert

Attribute

DynamicallyAccessedMembersAttribute

Beispiele

Das folgende Beispiel definiert eine geschachtelte Klasse und ein struct In MyClassund ruft dann Objekte der geschachtelten Typen mithilfe des Typs von MyClass.

using System;
using System.Reflection;
public class MyClass
{
    public class NestClass
    {
        public static int myPublicInt=0;
    }
    public struct NestStruct
    {
        public static int myPublicInt=0;
    }
}

public class MyMainClass
{
    public static void Main()
    {
        try
        {
            // Get the Type object corresponding to MyClass.
            Type myType=typeof(MyClass);
            // Get an array of nested type objects in MyClass.
            Type[] nestType=myType.GetNestedTypes();
            Console.WriteLine("The number of nested types is {0}.", nestType.Length);
            foreach(Type t in nestType)
                Console.WriteLine("Nested type is {0}.", t.ToString());
        }
        catch(Exception e)
        {
            Console.WriteLine("Error"+e.Message);
        }
    }
}

Imports System.Reflection

Public Class MyClass1
    Public Class NestClass
        Public Shared myPublicInt As Integer = 0
    End Class

    Public Structure NestStruct
        Public myPublicInt As Integer
    End Structure 'NestStruct
End Class

Public Class MyMainClass
    Public Shared Sub Main()
        Try
            ' Get the Type object corresponding to MyClass.
            Dim myType As Type = GetType(MyClass1)
            ' Get an array of nested type objects in MyClass.                 
            Dim nestType As Type() = myType.GetNestedTypes()
            Console.WriteLine("The number of nested types is {0}.", nestType.Length)
            Dim t As Type
            For Each t In nestType
                Console.WriteLine("Nested type is {0}.", t.ToString())
            Next t
        Catch e As Exception
            Console.WriteLine("Error", e.Message.ToString())
        End Try
    End Sub
End Class

Hinweise

In .NET 6 und früheren Versionen gibt die GetNestedTypes-Methode keine Typen in einer bestimmten Reihenfolge zurück, z. B. alphabetisch oder Deklarationsreihenfolge. Ihr Code darf nicht von der Reihenfolge abhängen, in der Typen zurückgegeben werden, da diese Reihenfolge unterschiedlich ist. Ab .NET 7 ist die Sortierung jedoch auf der Grundlage der Metadatenbestellung in der Assembly deterministisch.

Es werden nur die öffentlichen Typen zurückgegeben, die sofort in den aktuellen Typ geschachtelt sind; die Suche ist nicht rekursiv.

Die folgende Tabelle zeigt, welche Member einer Basisklasse von den Get Methoden zurückgegeben werden, wenn sie einen Typ widerspiegeln.

Mitgliedertyp	Static	Nicht statisch
Konstruktor	No	No
Feld	No	Yes. Ein Feld ist immer hide-by-name-and-signature.
Event	Nicht anwendbar	Die allgemeine Typsystemregel besteht darin, dass die Vererbung mit der der Methode identisch ist, die die Eigenschaft implementiert. Reflection behandelt Eigenschaften als Hide-by-Name-and-Signature. Siehe Hinweis 2 unten.
Methode	No	Yes. Eine Methode (sowohl virtuell als auch nicht-virtuell) kann Hide-by-name oder Hide-by-name-and-signature sein.
Geschachtelter Typ	No	No
Eigentum	Nicht anwendbar	Die allgemeine Typsystemregel besteht darin, dass die Vererbung mit der der Methode identisch ist, die die Eigenschaft implementiert. Reflection behandelt Eigenschaften als Hide-by-Name-and-Signature. Siehe Hinweis 2 unten.

1. Hide-by-name-and-signature berücksichtigt alle Elemente der Signatur, einschließlich angepasste Modifikatoren, Rückgabetypen, Parametertypen, Sentinels und nicht verwaltete Aufrufkonventionen. Dies ist ein binärer Vergleich.

2. Bei der Reflection sind Eigenschaften und Ereignisse Hide-by-Name-and-Signature. Wenn Sie über eine Eigenschaft mit einem Get- und einem Set-Accessor in der Basisklasse verfügen, die abgeleitete Klasse jedoch nur über einen Get-Accessor verfügt, blendet die abgeleitete Klasseneigenschaft die Basisklasseneigenschaft aus, und Sie können nicht auf den Setter der Basisklasse zugreifen.

3. Benutzerdefinierte Attribute sind nicht Teil des allgemeinen Typsystems.

Wenn der aktuelle Type Parameter einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, durchsucht diese Methode die geschachtelten Typen der Klasseneinschränkung.

Wenn ein geschachtelter Typ generisch ist, gibt diese Methode die generische Typdefinition zurück. Dies gilt auch dann, wenn der eingeschlossene generische Typ ein geschlossener konstruierter Typ ist.

Informationen zu geschachtelten generischen Typen und zum Erstellen geschachtelter generischer Typen aus ihren generischen Typdefinitionen finden Sie unter MakeGenericType.

Weitere Informationen

• GetNestedType(String)

Quelle:

Type.cs

Quelle:

Type.cs

Quelle:

Type.cs

Quelle:

Type.cs

Quelle:

Type.cs

public:
 abstract cli::array <Type ^> ^ GetNestedTypes(System::Reflection::BindingFlags bindingAttr);

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)]
public abstract Type[] GetNestedTypes(System.Reflection.BindingFlags bindingAttr);

public abstract Type[] GetNestedTypes(System.Reflection.BindingFlags bindingAttr);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)>]
abstract member GetNestedTypes : System.Reflection.BindingFlags -> Type[]

abstract member GetNestedTypes : System.Reflection.BindingFlags -> Type[]

Public MustOverride Function GetNestedTypes (bindingAttr As BindingFlags) As Type()

Parameter

Gibt zurück

Ein Array von Type Objekten, die alle typen darstellen, die in der aktuellen Type , die den angegebenen Bindungseinschränkungen entsprechen (die Suche ist nicht rekursiv), oder ein leeres Array vom Typ Type, wenn keine geschachtelten Typen gefunden werden, die den Bindungseinschränkungen entsprechen.

Implementiert

Attribute

DynamicallyAccessedMembersAttribute

Beispiele

Im folgenden Beispiel werden zwei geschachtelte öffentliche Klassen und zwei geschachtelte geschützte Klassen erstellt und Informationen für Klassen angezeigt, die den angegebenen Bindungseinschränkungen entsprechen.

using System;
using System.Reflection;

// Create a class with 2 nested public and 2 nested protected classes.
public class MyTypeClass
{
    public class Myclass1
    {
    }

    public class Myclass2
    {
    }

    protected class MyClass3
    {
    }

    protected class MyClass4
    {
    }
}

public class TypeMain
{
    public static void Main()
    {
        Type myType = (typeof(MyTypeClass));
        // Get the public nested classes.
        Type[] myTypeArray = myType.GetNestedTypes(BindingFlags.Public);
        Console.WriteLine("The number of nested public classes is {0}.", myTypeArray.Length);
        // Display all the public nested classes.
        DisplayTypeInfo(myTypeArray);
        Console.WriteLine();

        // Get the nonpublic nested classes.
        Type[] myTypeArray1 = myType.GetNestedTypes(BindingFlags.NonPublic|BindingFlags.Instance);
        Console.WriteLine("The number of nested protected classes is {0}.", myTypeArray1.Length);
        // Display all the nonpublic nested classes.
        DisplayTypeInfo(myTypeArray1);		
    }

    public static void DisplayTypeInfo(Type[] myArrayType)
    {
        // Display the information for all the nested classes.
        foreach (var t in myArrayType)
            Console.WriteLine("The name of the nested class is {0}.", t.FullName);
    }
}
// The example displays the following output:
//       The number of public nested classes is 2.
//       The name of the nested class is MyTypeClass+Myclass1.
//       The name of the nested class is MyTypeClass+Myclass2.
//
//       The number of protected nested classes is 2.
//       The name of the nested class is MyTypeClass+MyClass3.
//       The name of the nested class is MyTypeClass+MyClass4.

Imports System.Reflection

' Create a class with three properties.
Public Class MyTypeClass
    Public Class Myclass1
    End Class 

    Public Class Myclass2
    End Class 

    Protected Class MyClass3
    End Class 

    Protected Class MyClass4
    End Class 
End Class 

Public Class TypeMain
    Public Shared Sub Main()
        Dim myType As Type = GetType(MyTypeClass)

        ' Get the public nested classes.
        Dim myTypeArray As Type() = myType.GetNestedTypes((BindingFlags.Public))
        Console.WriteLine("The number of public nested classes is {0}.", myTypeArray.Length.ToString())
        ' Display all the public nested classes.
        DisplayTypeInfo(myTypeArray)
        Console.WriteLine()
        
        ' Get the nonpublic nested classes.
        Dim myTypeArray1 As Type() = myType.GetNestedTypes((BindingFlags.NonPublic))
        Console.WriteLine("The number of protected nested classes is {0}.", myTypeArray1.Length.ToString())
        ' Display  the information for all nested classes.
        DisplayTypeInfo(myTypeArray1)
    End Sub 

    Public Shared Sub DisplayTypeInfo(ByVal myArrayType() As Type)
        ' Display the information for all nested classes.
        For Each t In myArrayType
            Console.WriteLine("The name of the nested class is {0}.", t.FullName)
        Next 
    End Sub 
End Class  
' The example displays the following output:
'       The number of public nested classes is 2.
'       The name of the nested class is MyTypeClass+Myclass1.
'       The name of the nested class is MyTypeClass+Myclass2.
'       
'       The number of protected nested classes is 2.
'       The name of the nested class is MyTypeClass+MyClass3.
'       The name of the nested class is MyTypeClass+MyClass4.

Hinweise

Die Suche nach geschachtelten Typen ist nicht rekursiv.

In .NET 6 und früheren Versionen gibt die GetNestedTypes-Methode keine Typen in einer bestimmten Reihenfolge zurück, z. B. alphabetisch oder Deklarationsreihenfolge. Ihr Code darf nicht von der Reihenfolge abhängen, in der Typen zurückgegeben werden, da diese Reihenfolge unterschiedlich ist. Ab .NET 7 ist die Sortierung jedoch auf der Grundlage der Metadatenbestellung in der Assembly deterministisch.

Die folgenden BindingFlags Filterkennzeichnungen können verwendet werden, um zu definieren, welche geschachtelten Typen in die Suche einbezogen werden sollen:

• Sie müssen entweder angeben BindingFlags.Public oder BindingFlags.NonPublic eine Rückgabe abrufen.

• Geben Sie an BindingFlags.Public , dass öffentliche geschachtelte Typen in die Suche einbezogen werden sollen.

• Geben Sie an BindingFlags.NonPublic , dass nicht öffentliche geschachtelte Typen (d. h. private, interne und geschützte geschachtelte Typen) in die Suche einbezogen werden sollen.

Diese Methode gibt nur die geschachtelten Typen des aktuellen Typs zurück. Die Basisklassen des aktuellen Typs werden nicht durchsucht. Um Typen zu finden, die in Basisklassen geschachtelt sind, müssen Sie die Vererbungshierarchie durchlaufen und auf jeder Ebene aufrufen GetNestedTypes .

BindingFlags.Instance und BindingFlags.Static werden ignoriert.

Wenn Sie diese Methode nur mit der BindingFlags.Public Kennzeichnung oder nur der BindingFlags.NonPublic Kennzeichnung aufrufen, werden die angegebenen geschachtelten Typen zurückgegeben, und es sind keine anderen Flags erforderlich.

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.

Wenn der aktuelle Type Parameter einen Typparameter in der Definition eines generischen Typs oder einer generischen Methode darstellt, durchsucht diese Methode die geschachtelten Typen der Klasseneinschränkung.

Wenn ein geschachtelter Typ generisch ist, gibt diese Methode die generische Typdefinition zurück. Dies gilt auch dann, wenn der eingeschlossene generische Typ ein geschlossener konstruierter Typ ist.

Informationen zu geschachtelten generischen Typen und zum Erstellen geschachtelter generischer Typen aus ihren generischen Typdefinitionen finden Sie unter MakeGenericType.

Weitere Informationen

• BindingFlags
• DefaultBinder
• GetNestedType(String)