Type.GetNestedTypes Methode

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

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

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)]
public Type[] GetNestedTypes();

public Type[] GetNestedTypes();

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)>]
member this.GetNestedTypes : unit -> Type[]

member this.GetNestedTypes : unit -> Type[]

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

Public Function GetNestedTypes () As Type()

Retouren

Een matrix van Type objecten die de openbare typen vertegenwoordigen die zijn genest in de huidige Type (de zoekopdracht is niet recursief) of een lege matrix van het type Type als er geen openbare typen zijn genest in de huidige Type.

Implementeringen

Kenmerken

DynamicallyAccessedMembersAttribute

Voorbeelden

In het volgende voorbeeld wordt een geneste klasse en een struct in MyClassgedefinieerd en worden vervolgens objecten van de geneste typen opgehaald met behulp van MyClasshet type .

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

Opmerkingen

In .NET 6 en eerdere versies retourneert de methode GetNestedTypes geen typen in een bepaalde volgorde, zoals alfabetische of declaratievolgorde. Uw code mag niet afhankelijk zijn van de volgorde waarin typen worden geretourneerd, omdat die volgorde varieert. Vanaf .NET 7 is de volgorde echter deterministisch op basis van de volgorde van metagegevens in de assembly.

Alleen de openbare typen die direct in het huidige type zijn genest, worden geretourneerd; de zoekopdracht is niet recursief.

In de volgende tabel ziet u welke leden van een basisklasse worden geretourneerd door de Get methoden bij het weergeven van een type.

Lidmaatschapssoort	Static	Niet-statisch
Constructeur	No	No
Veld	No	Yes. Een veld wordt altijd verborgen op basis van naam en kenmerk.
Gebeurtenis	Niet van toepassing	De algemene regels van het type-systeem zijn dat de overerving hetzelfde is als die van de methoden die de eigenschap implementeren. Weerspiegeling behandelt eigenschappen als hide-by-name-and-signature. Zie opmerking 2 hieronder.
Methode	No	Yes. Een methode (zowel virtueel als niet-virtueel) kan worden verborgen op basis van naam of op basis van naam en handtekening.
Geneste type	No	No
Vastgoed	Niet van toepassing	De algemene regels van het type-systeem zijn dat de overerving hetzelfde is als die van de methoden die de eigenschap implementeren. Weerspiegeling behandelt eigenschappen als hide-by-name-and-signature. Zie opmerking 2 hieronder.

1. Hide-by-name-and-signature beschouwt alle onderdelen van de handtekening, waaronder aangepaste modifiers, retourtypen, parametertypen, sentinels en onbeheerde aanroepconventies. Dit is een binaire vergelijking.

2. Voor reflectie worden eigenschappen en gebeurtenissen verborgen op basis van naam en signatuur. Als u een eigenschap hebt met zowel een get als een set accessor in de basisklasse, maar de afgeleide klasse alleen een get-accessor heeft, verbergt de eigenschap afgeleide klasse de eigenschap basisklasse en hebt u geen toegang tot de setter op de basisklasse.

3. Aangepaste kenmerken maken geen deel uit van het algemene typesysteem.

Als de huidige Type een typeparameter vertegenwoordigt in de definitie van een algemeen type of algemene methode, doorzoekt deze methode de geneste typen van de klassebeperking.

Als een geneste type algemeen is, retourneert deze methode de algemene typedefinitie. Dit geldt zelfs als het omsluitende algemene type een gesloten samengesteld type is.

Zie voor informatie over geneste algemene typen en over het maken van geneste algemene typen uit hun algemene typedefinities MakeGenericType.

Zie ook

• GetNestedType(String)

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)]
public abstract Type[] GetNestedTypes(System.Reflection.BindingFlags bindingAttr);

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

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)>]
abstract member GetNestedTypes : System.Reflection.BindingFlags -> Type[]

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

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

Parameters

Retouren

Een matrix met Type objecten die alle typen vertegenwoordigen die zijn genest in de huidige Type die overeenkomen met de opgegeven bindingsbeperkingen (de zoekopdracht is niet recursief), of een lege matrix van het type Type, als er geen geneste typen worden gevonden die overeenkomen met de bindingsbeperkingen.

Implementeringen

Kenmerken

DynamicallyAccessedMembersAttribute

Voorbeelden

In het volgende voorbeeld worden twee geneste openbare klassen en twee geneste beveiligde klassen gemaakt en worden gegevens weergegeven voor klassen die overeenkomen met de opgegeven bindingsbeperkingen.

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.

Opmerkingen

De zoekopdracht naar geneste typen is niet recursief.

In .NET 6 en eerdere versies retourneert de methode GetNestedTypes geen typen in een bepaalde volgorde, zoals alfabetische of declaratievolgorde. Uw code mag niet afhankelijk zijn van de volgorde waarin typen worden geretourneerd, omdat die volgorde varieert. Vanaf .NET 7 is de volgorde echter deterministisch op basis van de volgorde van metagegevens in de assembly.

De volgende BindingFlags filtervlagmen kunnen worden gebruikt om te definiëren welke geneste typen moeten worden opgenomen in de zoekopdracht:

• U moet een BindingFlags.Public van beide opgeven of BindingFlags.NonPublic een retour ophalen.

• Geef BindingFlags.Public op dat openbare geneste typen in de zoekopdracht moeten worden opgenomen.

• Geef BindingFlags.NonPublic op dat niet-openbare geneste typen (dat wil gezegd privé-, interne en beveiligde geneste typen) in de zoekopdracht opnemen.

Deze methode retourneert alleen de geneste typen van het huidige type. De basisklassen van het huidige type worden niet doorzocht. Als u wilt zoeken naar typen die zijn genest in basisklassen, moet u de overnamehiërarchie doorlopen, die op elk niveau wordt aangeroepen GetNestedTypes .

BindingFlags.Instance en BindingFlags.Static worden genegeerd.

Als u deze methode aanroept met alleen de BindingFlags.Public vlag of alleen de BindingFlags.NonPublic vlag, worden de opgegeven geneste typen geretourneerd en zijn geen andere vlaggen vereist.

Zie System.Reflection.BindingFlags voor meer informatie.

Als de huidige Type een typeparameter vertegenwoordigt in de definitie van een algemeen type of algemene methode, doorzoekt deze methode de geneste typen van de klassebeperking.

Als een geneste type algemeen is, retourneert deze methode de algemene typedefinitie. Dit geldt zelfs als het omsluitende algemene type een gesloten samengesteld type is.

Zie voor informatie over geneste algemene typen en over het maken van geneste algemene typen uit hun algemene typedefinities MakeGenericType.

Zie ook

• BindingFlags
• DefaultBinder
• GetNestedType(String)