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.GetProperties (BindingFlags)

 

Data di pubblicazione: ottobre 2016

Quando ne viene eseguito l'override in una classe derivata, cerca le proprietà dell'oggetto Type corrente, usando i vincoli di binding specificati.

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

public abstract PropertyInfo[] GetProperties(
	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.Reflection.PropertyInfo[]

Matrice di oggetti PropertyInfo che rappresenta tutte le proprietà dell'oggetto Type corrente corrispondenti ai vincoli di binding specificati.

-oppure-

Matrice vuota di tipo PropertyInfo, se l'oggetto Type corrente non dispone di proprietà oppure se nessuna delle proprietà corrisponde ai vincoli di binding.

Una proprietà è considerata pubblica per la reflection se dispone di almeno una funzione di accesso pubblico. In caso contrario la proprietà viene considerata privata ed è necessario utilizzare BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (in Visual Basic, combinare i valori utilizzando Or) per ottenerlo.

Il GetProperties metodo non restituisce le proprietà in un ordine specifico, ad esempio in ordine alfabetico o ordine di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituite le proprietà, perché tale ordine varia.

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

  • È necessario specificare BindingFlags.Instance o BindingFlags.Static per ottenere un risultato.

  • Specificare BindingFlags.Public per includere le proprietà pubbliche nella ricerca.

  • Specificare BindingFlags.NonPublic per includere proprietà pubblici (proprietà, private, interne e protette) nella ricerca. Solo protetti e vengono restituite le proprietà interne delle classi di base; le proprietà private delle classi base non vengono restituite.

  • Specificare BindingFlags.FlattenHierarchy includere public e protected membri statici nella gerarchia; private membri statici nelle classi ereditate non sono inclusi.

Le operazioni seguenti BindingFlags flag di modifica consente di modificare le modalità di ricerca:

  • BindingFlags.DeclaredOnlyeseguire la ricerca solo le proprietà dichiarate sul Type, non proprietà quelli ereditati.

Per altre informazioni, vedere System.Reflection.BindingFlags.

Una proprietà è considerata pubblica per la reflection se dispone di almeno una funzione di accesso pubblico. In caso contrario la proprietà viene considerata privata ed è necessario utilizzare BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (in Visual Basic, combinare i valori utilizzando Or) per ottenerlo.

Se l'oggetto T:System.Type corrente rappresenta un tipo generico costruito, questo metodo restituisce il PropertyInfo oggetti con i parametri di tipo sostituiti dagli argomenti di tipo appropriato.

Se l'oggetto corrente Type rappresenta un parametro di tipo nella definizione di un tipo o metodo generico, questo metodo cerca le proprietà del vincolo di classe.

L'esempio seguente definisce una classe denominata PropertyClass che include sei proprietà: due sono pubblici, uno è privato, uno è protetto, uno è interno (Friend in Visual Basic), e uno è protected internal (Protected Friend in Visual Basic). Vengono quindi visualizzate alcune informazioni di proprietà di base (il nome della proprietà e il tipo, se è in lettura/scrittura e la visibilità del relativo get e set le funzioni di accesso) per le proprietà che corrispondono ai vincoli di associazione specificati.

using System;
using System.Reflection;

// Create a class having six properties.
public class PropertyClass
{
    public String Property1
    {
        get { return "hello"; }
    }

    public String Property2
    {
        get { return "hello"; }
    }

    protected String Property3
    {
        get { return "hello"; }
    }

    private Int32 Property4
    {
        get { return 32; }
    }

    internal String Property5
    {
       get { return "value"; }
    }

    protected internal String Property6
    {
       get { return "value"; }
    }
}

public class Example
{
    public static void Main() 
    {
        Type t = typeof(PropertyClass);
        // Get the public properties.
        PropertyInfo[] propInfos = t.GetProperties(BindingFlags.Public|BindingFlags.Instance);
        Console.WriteLine("The number of public properties: {0}.\n",
                          propInfos.Length);
        // Display the public properties.
        DisplayPropertyInfo(propInfos);

        // Get the nonpublic properties.
        PropertyInfo[] propInfos1 = t.GetProperties(BindingFlags.NonPublic|BindingFlags.Instance);
        Console.WriteLine("The number of non-public properties: {0}.\n",
                          propInfos1.Length);
        // Display all the nonpublic properties.
        DisplayPropertyInfo(propInfos1);
    }

    public static void DisplayPropertyInfo(PropertyInfo[] propInfos)
    {
        // Display information for all properties.
        foreach (var propInfo in propInfos) {
            bool readable = propInfo.CanRead;
            bool writable = propInfo.CanWrite;

            Console.WriteLine("   Property name: {0}", propInfo.Name);
            Console.WriteLine("   Property type: {0}", propInfo.PropertyType);
            Console.WriteLine("   Read-Write:    {0}", readable & writable);
            if (readable) {
               MethodInfo getAccessor = propInfo.GetMethod;
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(getAccessor));
            }
            if (writable) {
               MethodInfo setAccessor = propInfo.SetMethod;
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(setAccessor));
            }
            Console.WriteLine();
        }
    }

    public static String GetVisibility(MethodInfo accessor)
    {
       if (accessor.IsPublic)
          return "Public";
       else if (accessor.IsPrivate)
          return "Private";
       else if (accessor.IsFamily)
          return "Protected";
       else if (accessor.IsAssembly)
          return "Internal/Friend";
       else
          return "Protected Internal/Friend";
    }
}
// The example displays the following output:
//       The number of public properties: 2.
//
//          Property name: Property1
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//          Property name: Property2
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//       The number of non-public properties: 4.
//
//          Property name: Property3
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected
//
//          Property name: Property4
//          Property type: System.Int32
//          Read-Write:    False
//          Visibility:    Private
//
//          Property name: Property5
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Internal/Friend
//
//          Property name: Property6
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected Internal/Friend

.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: