Type.GetNestedTypes Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Obtient les types imbriqués dans le Type actuel.

Surcharges

GetNestedTypes()	Retourne les types publics imbriqués dans le Type actuel.
GetNestedTypes(BindingFlags)	En cas de substitution dans une classe dérivée, recherche les types imbriqués dans le Type actuel, à l'aide des contraintes de liaison spécifiées.

GetNestedTypes()

Source:

Type.cs

Retourne les types publics imbriqués dans le Type actuel.

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

public Type[] GetNestedTypes ();

member this.GetNestedTypes : unit -> Type[]

Public Function GetNestedTypes () As Type()

Retours

Type[]

Tableau d'objets Type représentant les types publics imbriqués dans le Type actuel (la recherche n'est pas récursive), ou tableau vide de type Type si aucun type public n'est imbriqué dans le Type actuel.

Exemples

L’exemple suivant définit une classe imbriquée et un struct dans MyClass, puis obtient des objets des types imbriqués à l’aide du type 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

Remarques

Dans .NET 6 et les versions antérieures, la GetNestedTypes méthode ne retourne pas les types dans un ordre particulier, tel que l’ordre alphabétique ou l’ordre de déclaration. Votre code ne doit pas dépendre de l’ordre dans lequel les types sont retournés, car cet ordre varie. Toutefois, à compter de .NET 7, l’ordre est déterministe en fonction du classement des métadonnées dans l’assembly.

Seuls les types publics immédiatement imbriqués dans le type actuel sont retournés ; la recherche n’est pas récursive.

Le tableau suivant montre quels membres d’une classe de base sont retournés par les méthodes lors de la Get réflexion sur un type.

Type de membre	statique	Non statique
Constructeur	Non	Non
Champ	Non	Oui. Un champ est toujours masqué par nom et signature.
Événement	Non applicable	La règle système de type courante est que l’héritage est identique à celui des méthodes qui implémentent la propriété . Reflection traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.
Méthode	Non	Oui. Une méthode (virtuelle et non virtuelle) peut être hide-by-name ou hide-by-name-and-signature.
Type imbriqué	Non	Non
Propriété	Non applicable	La règle système de type courante est que l’héritage est identique à celui des méthodes qui implémentent la propriété . Reflection traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.

1. Masquer par nom et signature prend en compte toutes les parties de la signature, y compris les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.

2. Pour la réflexion, les propriétés et les événements sont masqués par nom et signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder à l’élément setter sur la classe de base.

3. Les attributs personnalisés ne font pas partie du système de type commun.

Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode recherche les types imbriqués de la contrainte de classe.

Si un type imbriqué est générique, cette méthode retourne sa définition de type générique. Cela est vrai même si le type générique englobant est un type construit fermé.

Notes

Si le actuel Type représente un type générique défini en C#, Visual Basic ou C++, ses types imbriqués sont tous génériques même s’ils n’ont pas de paramètres génériques. Cela n’est pas nécessairement vrai pour les types imbriqués définis dans des assemblys dynamiques ou compilés avec le Ilasm.exe (assembleur IL).

Pour plus d’informations sur les types génériques imbriqués et sur la construction de types génériques imbriqués à partir de leurs définitions de types génériques, consultez MakeGenericType.

Voir aussi

• GetNestedType(String)

GetNestedTypes(BindingFlags)

Source:

Type.cs

En cas de substitution dans une classe dérivée, recherche les types imbriqués dans le Type actuel, à l'aide des contraintes de liaison spécifiées.

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

Paramètres

bindingAttr

BindingFlags

Combinaison de bits de valeurs d’énumération qui spécifie la façon dont est effectuée la recherche.

- ou -

Default pour retourner null.

Retours

Type[]

Tableau d'objets Type représentant tous les types imbriqués dans le Type actuel qui correspondent aux contraintes de liaison spécifiées (la recherche n'est pas récursive), ou tableau vide de type Type si aucun type imbriqué correspondant aux contraintes de liaison n'est trouvé.

Exemples

L’exemple suivant crée deux classes publiques imbriquées et deux classes protégées imbriquées, et affiche des informations pour les classes qui correspondent aux contraintes de liaison spécifiées.

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.

Remarques

La recherche de types imbriqués n’est pas récursive.

Dans .NET 6 et les versions antérieures, la GetNestedTypes méthode ne retourne pas les types dans un ordre particulier, tel que l’ordre alphabétique ou l’ordre de déclaration. Votre code ne doit pas dépendre de l’ordre dans lequel les types sont retournés, car cet ordre varie. Toutefois, à compter de .NET 7, l’ordre est déterministe en fonction du classement des métadonnées dans l’assembly.

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les types imbriqués à inclure dans la recherche :

• Vous devez spécifier ou BindingFlags.PublicBindingFlags.NonPublic pour obtenir un retour.

• Spécifiez BindingFlags.Public pour inclure les types imbriqués publics dans la recherche.

• Spécifiez BindingFlags.NonPublic pour inclure des types imbriqués non publics (c’est-à-dire des types imbriqués privés, internes et protégés) dans la recherche.

Cette méthode retourne uniquement les types imbriqués du type actuel. Il ne recherche pas les classes de base du type actuel. Pour rechercher des types imbriqués dans des classes de base, vous devez parcourir la hiérarchie d’héritage, en appelant GetNestedTypes à chaque niveau.

BindingFlags.Instance et BindingFlags.Static sont ignorés.

L’appel de cette méthode avec uniquement l’indicateur BindingFlags.Public ou uniquement l’indicateur BindingFlags.NonPublic renvoie les types imbriqués spécifiés et ne nécessite aucun autre indicateur.

Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.

Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode recherche les types imbriqués de la contrainte de classe.

Si un type imbriqué est générique, cette méthode retourne sa définition de type générique. Cela est vrai même si le type générique englobant est un type construit fermé.

Notes

Si le actuel Type représente un type générique défini en C#, Visual Basic ou C++, ses types imbriqués sont tous génériques même s’ils n’ont pas de paramètres génériques. Cela n’est pas nécessairement vrai pour les types imbriqués définis dans des assemblys dynamiques ou compilés avec le Ilasm.exe (assembleur IL).

Pour plus d’informations sur les types génériques imbriqués et sur la construction de types génériques imbriqués à partir de leurs définitions de types génériques, consultez MakeGenericType.

Voir aussi

• BindingFlags
• DefaultBinder
• GetNestedType(String)