Type.GetNestedTypes Método

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

Devoluções

Um array de Type objetos que representam todos os tipos aninhados na corrente Type que correspondem às restrições de ligação especificadas (a pesquisa não é recursiva), ou um array vazio de tipo Type, se não forem encontrados tipos aninhados que correspondam às restrições de ligação.

Implementações

Exemplos

O exemplo seguinte cria duas classes públicas aninhadas e duas classes protegidas aninhadas, e apresenta informações para classes que correspondem às restrições de ligação especificadas.

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.

Observações

A pesquisa por tipos aninhados não é recursiva.

Em versões .NET 6 e anteriores, o método GetNestedTypes não devolve tipos numa ordem específica, como ordem alfabética ou de declaração. O seu código não deve depender da ordem em que os tipos são devolvidos, porque essa ordem varia. No entanto, a partir do .NET 7, a ordenação é determinística com base na ordenação dos metadados na assembleia.

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

• Deve especificar um ou BindingFlags.PublicBindingFlags.NonPublic outro para obter uma declaração.

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

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

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

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

Chamar este método apenas com a BindingFlags.Public flag ou apenas com a BindingFlags.NonPublic flag devolverá os tipos aninhados especificados e não requer outras flags.

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

Se a corrente Type representa um parâmetro de tipo na definição de tipo genérico ou 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 devolve a sua definição de tipo genérica. Isto é verdade mesmo que o tipo genérico que envolve seja um tipo fechado e construído.

Para informações sobre tipos genéricos aninhados e sobre a construção de tipos genéricos aninhados a partir das suas definições de tipos genéricos, veja MakeGenericType.

Ver também

• BindingFlags
• DefaultBinder
• GetNestedType(String)

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

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

public Type[] GetNestedTypes();

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

member this.GetNestedTypes : unit -> Type[]

Public Function GetNestedTypes () As Type()

Devoluções

Um array de Type objetos que representam os tipos públicos aninhados na corrente Type (a pesquisa não é recursiva), ou um array vazio de tipo Type se nenhum tipo público estiver aninhado na corrente Type.

Implementações

Exemplos

O exemplo seguinte define uma classe aninhada e um struct em MyClass, e depois obtém objetos dos tipos aninhados usando o tipo de 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

Observações

Em versões .NET 6 e anteriores, o método GetNestedTypes não devolve tipos numa ordem específica, como ordem alfabética ou de declaração. O seu código não deve depender da ordem em que os tipos são devolvidos, porque essa ordem varia. No entanto, a partir do .NET 7, a ordenação é determinística com base na ordenação dos metadados na assembleia.

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

A tabela a seguir mostra quais membros de uma classe base são retornados pelos Get métodos ao refletir sobre um tipo.

Tipo de Membro	Estático	Não-estático
Construtor	No	No
Campo	No	Yes. Um campo é sempre ocultado com base no nome e assinatura.
Event	Não aplicável	A regra comum do sistema de tipos é que a herança é a mesma dos métodos que implementam a propriedade. A reflexão trata propriedades como esconder pelo nome e assinatura. Veja a nota 2 abaixo.
Método	No	Yes. Um método (virtual e não virtual) pode ser ocultado por nome ou ocultado por nome e assinatura.
Tipo aninhado	No	No
Property	Não aplicável	A regra comum do sistema de tipos é que a herança é a mesma dos métodos que implementam a propriedade. A reflexão trata propriedades como esconder pelo nome e assinatura. Veja a nota 2 abaixo.

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

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

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

Se a corrente Type representa um parâmetro de tipo na definição de tipo genérico ou 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 devolve a sua definição de tipo genérica. Isto é verdade mesmo que o tipo genérico que envolve seja um tipo fechado e construído.

Para informações sobre tipos genéricos aninhados e sobre a construção de tipos genéricos aninhados a partir das suas definições de tipos genéricos, veja MakeGenericType.

Ver também

• GetNestedType(String)