Type.GetNestedTypes Método

Definição

Obtém os tipos aninhados no Type atual.Gets the types nested within the current Type.

Sobrecargas

GetNestedTypes()

Retorna os tipos públicos aninhados no Type atual.Returns the public types nested in the current Type.

GetNestedTypes(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa as propriedades do Type atual, usando as restrições de associação especificadas.When overridden in a derived class, searches for the types nested in the current Type, using the specified binding constraints.

GetNestedTypes()

Retorna os tipos públicos aninhados no Type atual.Returns the public types nested in the current Type.

public:
 virtual cli::array <Type ^> ^ GetNestedTypes();
public Type[] GetNestedTypes ();
abstract member GetNestedTypes : unit -> Type[]
override this.GetNestedTypes : unit -> Type[]
Public Function GetNestedTypes () As Type()

Retornos

Type[]

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.An array of Type objects representing the public types nested in the current Type (the search is not recursive), or an empty array of type Type if no public types are nested in the current Type.

Implementações

Exemplos

O exemplo a seguir define uma classe aninhada struct e MyClassum no e, em seguida, obtém objetos dos tipos aninhados usando MyClasso tipo de.The following example defines a nested class and a struct in MyClass, and then obtains objects of the nested types using the type of 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

O GetNestedTypes método não retorna tipos em uma ordem específica, como ordem alfabética ou declaração.The GetNestedTypes method does not return types in a particular order, such as alphabetical or declaration order. Seu código não deve depender da ordem na qual os tipos são retornados, pois essa ordem varia.Your code must not depend on the order in which types are returned, because that order varies.

Somente os tipos públicos aninhados imediatamente no tipo atual são retornados; a pesquisa não é recursiva.Only the public types immediately nested in the current type are returned; the search is not recursive.

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.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

Tipo do membroMember Type EstáticoStatic Não estáticoNon-Static
ConstrutorConstructor NãoNo NãoNo
CampoField NãoNo Sim.Yes. Um campo permanece sempre oculto por nome e assinatura.A field is always hide-by-name-and-signature.
eventoEvent Não aplicávelNot applicable A regra de sistema do tipo comum é que a herança é a mesma dos métodos que implementam a propriedade.The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflexão trata propriedades como ocultas por nome e assinatura.Reflection treats properties as hide-by-name-and-signature. Consulte a observação 2 abaixo.See note 2 below.
MétodoMethod NãoNo Sim.Yes. Um método (virtual e não virtual) pode permanecer oculto por nome ou por nome e assinatura.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
Tipo aninhadoNested Type NãoNo NãoNo
PropriedadeProperty Não aplicávelNot applicable A regra de sistema do tipo comum é que a herança é a mesma dos métodos que implementam a propriedade.The common type system rule is that the inheritance is the same as that of the methods that implement the property. Reflexão trata propriedades como ocultas por nome e assinatura.Reflection treats properties as hide-by-name-and-signature. Consulte a observação 2 abaixo.See note 2 below.
  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.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. Esta é uma comparação binária.This is a binary comparison.

  2. Para reflexão, propriedades e eventos permanecem ocultos por nome e assinatura.For reflection, properties and events are hide-by-name-and-signature. 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.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. Atributos personalizados não fazem parte do sistema de tipo comum.Custom attributes are not part of the common type system.

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.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the nested types of the class constraint.

Se um tipo aninhado for genérico, este método retornará sua definição de tipo genérico.If a nested type is generic, this method returns its generic type definition. Isso será verdadeiro mesmo se o tipo genérico delimitador for um tipo construído fechado.This is true even if the enclosing generic type is a closed constructed type.

Observação

Caso o Type atual represente um tipo genérico definido no C#, no Visual Basic ou no C++, seus tipos aninhados são todos genéricos mesmo que não tenham parâmetros genéricos próprios.If the current Type represents a generic type defined in C#, Visual Basic, or C++, its nested types are all generic even if they have no generic parameters of their own. Isso não é necessariamente verdadeiro para tipos aninhados definidos em assemblies dinâmicos ou compilados com o Ilasm. exe (assembler Il).This is not necessarily true of nested types defined in dynamic assemblies or compiled with the Ilasm.exe (IL Assembler).

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.For information on nested generic types, and on constructing nested generic types from their generic type definitions, see MakeGenericType.

Veja também

GetNestedTypes(BindingFlags)

Quando é substituído em uma classe derivada, pesquisa as propriedades do Type atual, usando as restrições de associação especificadas.When overridden in a derived class, searches for the types nested in the current Type, using the specified binding constraints.

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

bindingAttr
BindingFlags

Uma combinação bit a bit dos valores de enumeração que especificam como a pesquisa é realizada.A bitwise combination of the enumeration values that specify how the search is conducted.

- ou --or- Default para retornar null.Default to return null.

Retornos

Type[]

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.An array of Type objects representing all the types nested in the current Type that match the specified binding constraints (the search is not recursive), or an empty array of type Type, if no nested types are found that match the binding constraints.

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.The following example creates two nested public classes and two nested protected classes, and displays information for classes that match the specified binding constraints.

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.The search for nested types is not recursive.

O GetNestedTypes método não retorna tipos em uma ordem específica, como ordem alfabética ou declaração.The GetNestedTypes method does not return types in a particular order, such as alphabetical or declaration order. Seu código não deve depender da ordem na qual os tipos são retornados, pois essa ordem varia.Your code must not depend on the order in which types are returned, because that order varies.

Os seguintes BindingFlags sinalizadores de filtro podem ser usados para definir quais tipos aninhados serão incluídos na pesquisa:The following BindingFlags filter flags can be used to define which nested types to include in the search:

Esse método retorna apenas os tipos aninhados do tipo atual.This method returns only the nested types of the current type. Ele não pesquisa as classes base do tipo atual.It does not search the base classes of the current type. Para localizar tipos que são aninhados em classes base, você deve percorrer a hierarquia de herança GetNestedTypes , chamando em cada nível.To find types that are nested in base classes, you must walk the inheritance hierarchy, calling GetNestedTypes at each level.

BindingFlags.Instancee BindingFlags.Static são ignorados.BindingFlags.Instance and BindingFlags.Static are ignored.

Chamar esse método somente com o BindingFlags.Public sinalizador ou apenas o BindingFlags.NonPublic sinalizador retornará os tipos aninhados especificados e não exigirá nenhum outro sinalizador.Calling this method with only the BindingFlags.Public flag or only the BindingFlags.NonPublic flag will return the specified nested types and does not require any other flags.

Consulte System.Reflection.BindingFlags para obter mais informações.See System.Reflection.BindingFlags for more information.

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.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the nested types of the class constraint.

Se um tipo aninhado for genérico, este método retornará sua definição de tipo genérico.If a nested type is generic, this method returns its generic type definition. Isso será verdadeiro mesmo se o tipo genérico delimitador for um tipo construído fechado.This is true even if the enclosing generic type is a closed constructed type.

Observação

Caso o Type atual represente um tipo genérico definido no C#, no Visual Basic ou no C++, seus tipos aninhados são todos genéricos mesmo que não tenham parâmetros genéricos próprios.If the current Type represents a generic type defined in C#, Visual Basic, or C++, its nested types are all generic even if they have no generic parameters of their own. Isso não é necessariamente verdadeiro para tipos aninhados definidos em assemblies dinâmicos ou compilados com o Ilasm. exe (assembler Il).This is not necessarily true of nested types defined in dynamic assemblies or compiled with the Ilasm.exe (IL Assembler).

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.For information on nested generic types, and on constructing nested generic types from their generic type definitions, see MakeGenericType.

Veja também

Aplica-se a