Type.GetNestedTypes Método

Origem:

Type.cs

Origem:

Type.cs

Origem:

Type.cs

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

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

public Type[] GetNestedTypes ();

member this.GetNestedTypes : unit -> Type[]

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

Public Function GetNestedTypes () As Type()

Retornos

Uma matriz de Type objetos que representam os tipos públicos aninhados no Type atual (a pesquisa não é recursiva) ou uma matriz vazia do tipo Type se não há tipos públicos são aninhados no Type atual.

Implementações

Exemplos

O exemplo a seguir define uma classe aninhada e uma struct em e, em MyClassseguida, obtém objetos dos tipos aninhados usando o tipo de MyClass.

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

Comentários

No .NET 6 e em versões anteriores, o GetNestedTypes método não retorna tipos em uma ordem específica, como ordem alfabética ou de declaração. Seu código não deve depender da ordem em que os tipos são retornados, pois essa ordem varia. No entanto, a partir do .NET 7, a ordenação é determinística com base na ordenação de metadados no assembly.

Somente os tipos públicos imediatamente aninhados no tipo atual são retornados; a pesquisa não é recursiva.

A tabela a seguir mostra quais membros de uma classe base são retornados pelos métodos Get durante a reflexão em um tipo.

1. Oculto por nome e assinatura considera todas as partes da assinatura, inclusive modificadores personalizados, tipos de retorno, tipos de parâmetro, sentinelas e convenções de chamada não gerenciadas. Esta é uma comparação binária.

2. Para reflexão, propriedades e eventos permanecem ocultos por nome e assinatura. Se você tiver uma propriedade com um acessador get e set na classe base, mas a classe derivada tiver apenas um acessador get, a propriedade de classe derivada ocultará a propriedade da classe base e você não poderá acessar o setter na classe base.

3. Atributos personalizados não fazem parte do sistema de tipo comum.

Caso o Type atual represente um parâmetro de tipo na definição de um tipo genérico ou um método genérico, este método pesquisa os tipos aninhados da restrição de classe.

Se um tipo aninhado for genérico, este método retornará sua definição de tipo genérico. Isso será verdadeiro mesmo se o tipo genérico delimitador for um tipo construído fechado.

Para obter informações sobre tipos genéricos aninhados e sobre como construir tipos genéricos aninhados das definições de tipo genérico, consulte MakeGenericType.

Confira também

• GetNestedType(String)

Origem:

Type.cs

Origem:

Type.cs

Origem:

Type.cs

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()

Parâmetros

Retornos

Uma matriz de objetos Type que representam todos os tipos aninhados no Type atual que coincidem com as restrições de associação especificadas (a pesquisa não é recursiva) ou uma matriz vazia do tipo Type, se nenhum dos tipos aninhados são encontrados que correspondem às restrições de associação.

Implementações

Exemplos

O exemplo a seguir cria duas classes públicas aninhadas e duas classes protegidas aninhadas e exibe informações para classes que correspondem às restrições de associação especificadas.

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.

Comentários

A pesquisa por tipos aninhados não é recursiva.

No .NET 6 e em versões anteriores, o GetNestedTypes método não retorna tipos em uma ordem específica, como ordem alfabética ou de declaração. Seu código não deve depender da ordem em que os tipos são retornados, pois essa ordem varia. No entanto, a partir do .NET 7, a ordenação é determinística com base na ordenação de metadados no assembly.

Os seguintes BindingFlags sinalizadores de filtro podem ser usados para definir quais tipos aninhados incluir na pesquisa:

• Você deve especificar ou BindingFlags.PublicBindingFlags.NonPublic para obter um retorno.

• Especifique BindingFlags.Public para incluir tipos aninhados públicos na pesquisa.

• Especifique BindingFlags.NonPublic para incluir tipos aninhados não públicos (ou seja, tipos aninhados privados, internos e protegidos) na pesquisa.

Esse método retorna apenas os tipos aninhados do tipo atual. Ele não pesquisa as classes base do tipo atual. Para encontrar tipos aninhados em classes base, você deve percorrer a hierarquia de herança, chamando GetNestedTypes em cada nível.

BindingFlags.Instance e BindingFlags.Static são ignorados.

Chamar esse método apenas com o BindingFlags.Public sinalizador ou apenas o BindingFlags.NonPublic sinalizador retornará os tipos aninhados especificados e não exigirá nenhum outro sinalizador.

Consulte System.Reflection.BindingFlags para obter mais informações.

Caso o Type atual represente um parâmetro de tipo na definição de um tipo genérico ou um método genérico, este método pesquisa os tipos aninhados da restrição de classe.

Se um tipo aninhado for genérico, este método retornará sua definição de tipo genérico. Isso será verdadeiro mesmo se o tipo genérico delimitador for um tipo construído fechado.

Para obter informações sobre tipos genéricos aninhados e sobre como construir tipos genéricos aninhados das definições de tipo genérico, consulte MakeGenericType.

Confira também

• BindingFlags
• DefaultBinder
• GetNestedType(String)