Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Type.GetNestedTypes (BindingFlags)

 

Quando ne viene eseguito l'override in una classe derivata, cerca i tipi annidati nell'oggetto Type corrente, usando i vincoli di binding specificati.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public abstract Type[] GetNestedTypes(
	BindingFlags bindingAttr
)

Parametri

bindingAttr
Type: System.Reflection.BindingFlags

Maschera di bit costituita da uno o più BindingFlags che consente di specificare le modalità di esecuzione della ricerca.

-oppure-

Zero, per restituire null.

Valore restituito

Type: System.Type[]

Matrice di oggetti Type che rappresenta tutti i tipi annidati nell'oggetto Type corrente che corrispondono ai vincoli di binding specificati (la ricerca non è ricorsiva), oppure matrice vuota di tipo Type, se non viene trovato alcun tipo annidato che corrisponde ai vincoli di binding.

La ricerca per i tipi annidati non è ricorsiva.

Il GetNestedTypes metodo non restituisce i tipi in un ordine specifico, ad esempio in ordine alfabetico o ordine di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituiti tipi perché tale ordine varia.

Le operazioni seguenti BindingFlags filtro flag possono essere utilizzati per definire annidati di tipi da includere nella ricerca:

Questo metodo restituisce solo i tipi annidati del tipo corrente. Non esegue la ricerca di classi di base del tipo corrente. Per individuare i tipi nidificati nelle classi di base, è necessario seguire la gerarchia di ereditarietà, la chiamata GetNestedTypes a ogni livello.

BindingFlags.Instancee BindingFlags.Static vengono ignorati.

Chiamare questo metodo solo con il BindingFlags.Public flag o solo il BindingFlags.NonPublic flag restituirà tipi annidati specificati e non richiede altri flag di qualsiasi.

Per altre informazioni, vedere System.Reflection.BindingFlags.

Se l'oggetto corrente Type rappresenta un parametro di tipo nella definizione di un tipo o metodo generico, questo metodo cerca i tipi annidati del vincolo di classe.

Se un tipo annidato è generico, questo metodo restituisce la definizione di tipo generico. Questo vale anche se il tipo generico contenitore è un tipo costruito chiuso.

System_CAPS_noteNota

Se l'oggetto corrente Type rappresenta un tipo generico definito in c#, Visual Basic o C++, i relativi tipi annidati sono tutti generici, anche se non dispongono di propri parametri generici. Ciò non avviene necessariamente di tipi annidati definiti in assembly dinamici o compilati con il Ilasm.exe (IL Assembler).

Per informazioni sui tipi generici annidati e sulla costruzione di tipi generici annidati dalle definizioni di tipo generico, vedere MakeGenericType.

Nell'esempio seguente crea due classi pubbliche annidate e due classi nidificate protette e visualizza le informazioni per le classi che corrisponde ai vincoli di associazione specificati.

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.

.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Torna all'inizio
Mostra: