Type.GetNestedTypes Methode

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Ruft die im aktuellen Type geschachtelten Typen ab.

Überlädt

GetNestedTypes()	Gibt die im aktuellen Type geschachtelten öffentlichen Typen zurück.
GetNestedTypes(BindingFlags)	Sucht beim Überschreiben in einer abgeleiteten Klasse unter Verwendung der angegebenen Bindungseinschränkungen die im aktuellen Type geschachtelten Typen.

GetNestedTypes()

Source:

Type.cs

Gibt die im aktuellen Type geschachtelten öffentlichen Typen zurück.

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

public Type[] GetNestedTypes ();

member this.GetNestedTypes : unit -> Type[]

Public Function GetNestedTypes () As Type()

Gibt zurück

Type[]

Ein Array von Type-Objekten, das die im aktuellen Type geschachtelten öffentlichen Typen darstellt (die Suche ist nicht rekursiv) oder ein leeres Array vom Typ Type, wenn im aktuellen Type keine öffentlichen Typen geschachtelt sind.

Beispiele

Im folgenden Beispiel werden eine geschachtelte Klasse und eine struct in MyClassdefiniert. Anschließend werden Objekte der geschachtelten Typen mithilfe des Typs von MyClassabgerufen.

using namespace System;
using namespace System::Reflection;
public ref class MyClass
{
public:
   ref class NestClass
   {
      public:
         static int myPublicInt = 0;
   };

   ref struct NestStruct
   {
      public:
         static int myPublicInt = 0;
   };
};

int main()
{
   try
   {
      // Get the Type object corresponding to MyClass.
      Type^ myType = MyClass::typeid;
      
      // Get an array of nested type objects in MyClass.
      array<Type^>^nestType = myType->GetNestedTypes();
      Console::WriteLine( "The number of nested types is {0}.", nestType->Length );
      System::Collections::IEnumerator^ myEnum = nestType->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         Type^ t = safe_cast<Type^>(myEnum->Current);
         Console::WriteLine( "Nested type is {0}.", t );
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Error {0}", e->Message );
   }
}

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 variiert. Ab .NET 7 ist die Reihenfolge jedoch deterministisch, basierend auf der Metadatenreihenfolge in der Assembly.

Nur die öffentlichen Typen, die sofort im aktuellen Typ geschachtelt sind, werden zurückgegeben. die Suche ist nicht rekursiv.

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

Memberart	statischen	Nicht statisch
Konstruktor	Nein	Nein
Feld	Nein	Ja. Ein Feld wird immer nach Name und Signatur ausgeblendet.
Ereignis	Nicht zutreffend	Die allgemeine Typsystemregel ist, dass die Vererbung mit der der Methoden identisch ist, die die -Eigenschaft implementieren. Die Reflektion behandelt Eigenschaften als hide-by-name-and-signature. Siehe Hinweis 2 weiter unten.
Methode	Nein	Ja. Eine Methode (sowohl virtuell als auch nicht virtuell) kann nach Name oder nach Name und Signatur ausblenden sein.
Geschachtelter Typ	Nein	Nein
Eigenschaft	Nicht zutreffend	Die allgemeine Typsystemregel ist, dass die Vererbung mit der der Methoden identisch ist, die die -Eigenschaft implementieren. Die Reflektion behandelt Eigenschaften als hide-by-name-and-signature. Siehe Hinweis 2 weiter unten.

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

2. Für die Reflektion werden Eigenschaften und Ereignisse nach Name und Signatur ausgeblendet. 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 für die Basisklasse zugreifen.

3. Benutzerdefinierte Attribute sind nicht Teil des allgemeinen Typsystems.

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

Wenn ein geschachtelter Typ generisch ist, gibt diese Methode ihre generische Typdefinition zurück. Dies gilt auch, wenn der einschließende generische Typ ein geschlossener konstruierter Typ ist.

Hinweis

Wenn der aktuelle einen generischen Type Typ darstellt, der in C#, Visual Basic oder C++ definiert ist, sind alle geschachtelten Typen generisch, auch wenn sie keine generischen Parameter besitzen. Dies gilt nicht unbedingt für geschachtelte Typen, die in dynamischen Assemblys definiert oder mit dem Ilasm.exe (IL Assembler) kompiliert wurden.

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

Weitere Informationen

• GetNestedType(String)

GetNestedTypes(BindingFlags)

Source:

Type.cs

Sucht beim Überschreiben in einer abgeleiteten Klasse unter Verwendung der angegebenen Bindungseinschränkungen die im aktuellen Type geschachtelten Typen.

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

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

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

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

Parameter

bindingAttr

BindingFlags

Eine bitweise Kombination der Enumerationswerte, die angeben, wie die Suche durchgeführt wird.

- oder -

Default, damit null zurückgegeben wird.

Gibt zurück

Type[]

Ein Array von Type-Objekten, das alle im aktuellen Type geschachtelten Typen darstellt, die mit den angegebenen Bindungseinschränkungen übereinstimmen (die Suche ist nicht rekursiv) oder ein leeres Array vom Typ Type, wenn keine geschachtelten Typen gefunden werden, die mit den Bindungseinschränkungen übereinstimmen.

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 namespace System;
using namespace System::Reflection;

// Create a class with two nested public classes and two nested protected classes.
public ref class MyTypeClass
{
   public:
      ref class Myclass1{};
   
   public:
      ref class Myclass2{};
   
   protected:
      ref class MyClass3{};
   
   protected:
      ref class MyClass4{};
};

void DisplayTypeInfo(array<Type^>^ myArrayType)
{
   // Display the information for all the nested classes.
   for each (Type^ t in myArrayType)
      Console::WriteLine( "The name of the nested class is {0}.", t->FullName);
}

int main()
{
   Type^ myType = MyTypeClass::typeid;
   
   // Get the public nested classes.
   array<Type^>^myTypeArray = myType->GetNestedTypes( static_cast<BindingFlags>(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.
   array<Type^>^myTypeArray1 = myType->GetNestedTypes( static_cast<BindingFlags>(BindingFlags::NonPublic));
   Console::WriteLine( "The number of nested protected classes is {0}.", myTypeArray1->Length );
   
   // Display all the nonpublic nested classes.
   DisplayTypeInfo( myTypeArray1 );
}
// 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.

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 variiert. Ab .NET 7 ist die Reihenfolge jedoch deterministisch, basierend auf der Metadatenreihenfolge in der Assembly.

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

• Sie müssen entweder BindingFlags.Public oder BindingFlags.NonPublic angeben, um eine Rückgabe zu erhalten.

• Geben Sie an BindingFlags.Public , um öffentliche geschachtelte Typen in die Suche einzuschließen.

• Geben Sie an BindingFlags.NonPublic , um nicht öffentliche geschachtelte Typen (d. h. private, interne und geschützte geschachtelte Typen) in die Suche einzuschließen.

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 Diese Methode nur mit dem BindingFlags.Public -Flag oder nur dem BindingFlags.NonPublic -Flag aufgerufen wird, werden die angegebenen geschachtelten Typen zurückgegeben, und es sind keine weiteren Flags erforderlich.

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.

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

Wenn ein geschachtelter Typ generisch ist, gibt diese Methode ihre generische Typdefinition zurück. Dies gilt auch, wenn der einschließende generische Typ ein geschlossener konstruierter Typ ist.

Hinweis

Wenn der aktuelle einen generischen Type Typ darstellt, der in C#, Visual Basic oder C++ definiert ist, sind alle geschachtelten Typen generisch, auch wenn sie keine generischen Parameter besitzen. Dies gilt nicht unbedingt für geschachtelte Typen, die in dynamischen Assemblys definiert oder mit dem Ilasm.exe (IL Assembler) kompiliert wurden.

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)