Type.GetProperties Metodo

Definizione

Spazio dei nomi:

System

Assembly:

netstandard.dll, System.Runtime.dll

Ottiene le proprietà dell'oggetto Type corrente.

Overload

GetProperties()	Restituisce tutte le proprietà pubbliche dell'oggetto Type corrente.
GetProperties(BindingFlags)	Quando ne viene eseguito l'override in una classe derivata, cerca le proprietà dell'oggetto Type corrente, usando i vincoli di binding specificati.

GetProperties()

Origine:

Type.cs

Restituisce tutte le proprietà pubbliche dell'oggetto Type corrente.

C#

public System.Reflection.PropertyInfo[] GetProperties();

Restituisce

PropertyInfo[]

Matrice di oggetti PropertyInfo che rappresentano tutte le proprietà pubbliche dell'oggetto Type corrente.

-oppure-

Matrice vuota di tipo PropertyInfo, se l'oggetto Type corrente non possiede delle proprietà pubbliche.

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo GetProperties.

C#

PropertyInfo[] myPropertyInfo;
// Get the properties of 'Type' class object.
myPropertyInfo = Type.GetType("System.Type").GetProperties();
Console.WriteLine("Properties of System.Type are:");
for (int i = 0; i < myPropertyInfo.Length; i++)
{
    Console.WriteLine(myPropertyInfo[i].ToString());
}

Commenti

La chiamata di questo overload equivale a chiamare l'overload GetProperties(BindingFlags) con un bindingAttr argomento uguale a BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public in C# e BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public in Visual Basic. Restituisce tutte le proprietà di istanza pubblica e statiche, entrambe definite dal tipo rappresentato dall'oggetto corrente Type e quelle ereditate dai relativi tipi di base.

Una proprietà viene considerata pubblica per la reflection se ha almeno una funzione di accesso pubblica. In caso contrario, la proprietà viene considerata privata e è necessario usare BindingFlags.NonPublic | | BindingFlags.InstanceBindingFlags.Static (in Visual Basic, combinare i valori usando Or) per ottenerla.

Nelle versioni precedenti e .NET 6 il GetProperties metodo non restituisce proprietà in un determinato ordine, ad esempio alfabetico o ordine di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituite le proprietà, perché tale ordine varia. Tuttavia, a partire da .NET 7, l'ordinamento è deterministico in base all'ordinamento dei metadati nell'assembly.

Nella tabella seguente vengono illustrati i membri di una classe base restituiti dai Get metodi quando si riflette su un tipo.

Tipo di membro	Static	Non statico
Costruttore	No	No
Campo	No	Sì. Un campo è sempre hide-by-name-and-signature.
Evento	Non applicabile	La regola di sistema dei tipi comune è che l'ereditarietà è uguale a quella dei metodi che implementano la proprietà. Reflection tratta le proprietà come hide-by-name-and-signature. Vedere la nota 2 seguente.
Metodo	No	Sì. Un metodo (sia virtuale che non virtuale) può essere hide-by-name o hide-by-name-and-signature.
Tipo annidato	No	No
Proprietà	Non applicabile	La regola di sistema dei tipi comune è che l'ereditarietà è uguale a quella dei metodi che implementano la proprietà. Reflection tratta le proprietà come hide-by-name-and-signature. Vedere la nota 2 seguente.

1. Hide-by-name-and-signature considera tutte le parti della firma, inclusi modificatori personalizzati, tipi restituiti, tipi di parametri, sentinelle e convenzioni di chiamata non gestite. Si tratta di un confronto binario.

2. Per la reflection, le proprietà e gli eventi sono nascondi per nome e firma. Se si dispone di una proprietà con una funzione di accesso get e un set nella classe base, ma la classe derivata ha solo una funzione di accesso get, la proprietà classe derivata nasconde la proprietà della classe base e non sarà possibile accedere al setter nella classe base.

3. Gli attributi personalizzati non fanno parte del sistema di tipi comuni.

Se l'oggetto corrente Type rappresenta un tipo generico costruito, questo metodo restituisce gli oggetti con i PropertyInfo parametri di tipo sostituiti dagli argomenti di tipo appropriati.

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

Vedi anche

• PropertyInfo
• GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])

GetProperties(BindingFlags)

Origine:

Type.cs

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

C#

public abstract System.Reflection.PropertyInfo[] GetProperties(System.Reflection.BindingFlags bindingAttr);

Parametri

bindingAttr

BindingFlags

Combinazione bit per bit di valori di enumerazione che specifica il modo in cui viene eseguita la ricerca.

-oppure-

Default per restituire una matrice vuota.

Restituisce

PropertyInfo[]

Matrice di oggetti che rappresenta tutte le proprietà dell'oggetto Type corrente corrispondenti ai vincoli di associazione 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.

Implementazioni

GetProperties(BindingFlags)

Esempio

L'esempio seguente definisce una classe denominata PropertyClass che include sei proprietà: due sono pubbliche, una è privata, una è protetta, una è interna ( in Visual Basic) e una è protetta interna (FriendProtected Friend in Visual Basic). Visualizza quindi alcune informazioni di base sulla proprietà (il nome della proprietà e il tipo, se è di lettura/scrittura e la visibilità delle get relative funzioni di accesso e set ) per le proprietà che corrispondono ai vincoli di associazione specificati.

C#

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

Commenti

Per recuperare correttamente le informazioni sulla proprietà, l'argomento GetProperties(BindingFlags)bindingAttr deve includere almeno uno di e , insieme a almeno uno di BindingFlags.NonPublicBindingFlags.Instance e BindingFlags.StaticBindingFlags.Public.

I flag di filtro seguenti BindingFlags possono essere usati per definire le proprietà da includere nella ricerca:

• Specificare BindingFlags.Instance per includere i metodi di istanza.

• Specificare BindingFlags.Static per includere metodi statici.

• Specificare BindingFlags.Public per includere le proprietà pubbliche nella ricerca. Una proprietà viene considerata pubblica per la reflection se ha almeno una funzione di accesso pubblica.

• Specificare per includere proprietà non pubbliche , ovvero proprietà private, interne e protette BindingFlags.NonPublic , nella ricerca. Vengono restituite solo proprietà protette e interne nelle classi di base; le proprietà private sulle classi di base non vengono restituite.

• Specificare di includere public e protected membri statici fino alla gerarchia. private I BindingFlags.FlattenHierarchy membri statici nelle classi ereditate non sono inclusi.

• Specificare BindingFlags.Default da solo per restituire una matrice vuota PropertyInfo .

I flag di modifica seguenti BindingFlags possono essere usati per modificare il funzionamento della ricerca:

• BindingFlags.DeclaredOnly per cercare solo le proprietà dichiarate nelle Typeproprietà , non semplicemente ereditate.

Per altre informazioni, vedere System.Reflection.BindingFlags.

Nelle versioni precedenti e .NET 6 il GetProperties metodo non restituisce proprietà in un determinato ordine, ad esempio alfabetico o ordine di dichiarazione. Il codice non deve dipendere dall'ordine in cui vengono restituite le proprietà, perché tale ordine varia. Tuttavia, a partire da .NET 7, l'ordinamento è deterministico in base all'ordinamento dei metadati nell'assembly.

Se l'oggetto corrente Type rappresenta un tipo generico costruito, questo metodo restituisce gli oggetti con i PropertyInfo parametri di tipo sostituiti dagli argomenti di tipo appropriati.

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

Vedi anche

• PropertyInfo
• BindingFlags
• DefaultBinder
• GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])