Type.GetProperties Metodo

Definizione

Spazio dei nomi:

System

Assembly:

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

Source:

Type.cs

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

public:
 cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties();

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

member this.GetProperties : unit -> System.Reflection.PropertyInfo[]

Public Function GetProperties () As PropertyInfo()

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.

array<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 ] );

}

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

// Get the properties of 'Type' class object.
let myPropertyInfo = Type.GetType("System.Type").GetProperties()
printfn "Properties of System.Type are:"
for pi in myPropertyInfo do
    printfn $"{pi}"

Dim myPropertyInfo() As PropertyInfo
' Get the properties of 'Type' class object.
myPropertyInfo = Type.GetType("System.Type").GetProperties()
Console.WriteLine("Properties of System.Type are:")
Dim i As Integer
For i = 0 To myPropertyInfo.Length - 1
   Console.WriteLine(myPropertyInfo(i).ToString())
Next i

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)

Source:

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.

public:
 abstract cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties(System::Reflection::BindingFlags bindingAttr);

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

abstract member GetProperties : System.Reflection.BindingFlags -> System.Reflection.PropertyInfo[]

Public MustOverride Function GetProperties (bindingAttr As BindingFlags) As PropertyInfo()

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.

using namespace System;
using namespace System::Reflection;

// Create a class having three properties.
public ref class PropertyClass
{

public:
   property String^ Property1
   {
      String^ get()
      {
         return "hello";
      }
   }

   property String^ Property2 
   {
      String^ get()
      {
         return "hello";
      }
   }

protected:
   property String^ Property3
   {
      String^ get()
      {
         return "hello";
      }
   }

private:
   property int Property4
   {
      int get()
      {
         return 32;
      }
   }

internal:
   property String^ Property5
   {
      String^ get()
      {
         return "value";
      }
   }
   
public protected:
   property String^ Property6
   {
      String^ get()
      {
         return "value";
      }
   }
};

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";
}

void DisplayPropertyInfo(array<PropertyInfo^>^ propInfos )
{
   // Display information for all properties.
   for each(PropertyInfo^ 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();
   }
}

void main()
{
   Type^ myType = PropertyClass::typeid;
   
   // Get the public properties.
   array<PropertyInfo^>^propInfos = myType->GetProperties( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance) );
   Console::WriteLine("The number of public properties: {0}.\n",
                      propInfos->Length);
   // Display the public properties.
   DisplayPropertyInfo( propInfos );
   
   // Get the non-public properties.
   array<PropertyInfo^>^propInfos1 = myType->GetProperties( static_cast<BindingFlags>(BindingFlags::NonPublic | BindingFlags::Instance) );
   Console::WriteLine("The number of non-public properties: {0}.\n",
                      propInfos1->Length);
   // Display all the non-public properties.
   DisplayPropertyInfo(propInfos1);
}
// The example displays the following output:
//       The number of public properties: 2.
//
//          Property name: Property2
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//          Property name: Property1
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Public
//
//       The number of non-public properties: 4.
//
//          Property name: Property6
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected Internal/Friend
//
//          Property name: Property5
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Internal/Friend
//
//          Property name: Property4
//          Property type: System.Int32
//          Read-Write:    False
//          Visibility:    Private
//
//          Property name: Property3
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Protected

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

open System.Reflection

// Create a class having four properties.
type PropertyClass() =
    member _.Property1 = 
        "hello"

    member _.Property2 = 
        "hello"

    member private _.Property3 = 
        32

    member internal _.Property4 =
       "value"

let getVisibility (accessor: MethodInfo) =
    if accessor.IsPublic then
        "Public"
    elif accessor.IsPrivate then
        "Private"
    elif accessor.IsFamily then
        "Protected"
    elif accessor.IsAssembly then
        "Internal/Friend"
    else
        "Protected Internal/Friend"

let displayPropertyInfo (propInfos: #seq<PropertyInfo>) = 
    // Display information for all properties.
    for propInfo in propInfos do
        let readable = propInfo.CanRead
        let writable = propInfo.CanWrite

        printfn $"   Property name: {propInfo.Name}"
        printfn $"   Property type: {propInfo.PropertyType}"
        printfn $"   Read-Write:    {readable && writable}"
        if readable then
            let getAccessor = propInfo.GetMethod
            printfn $"   Visibility:    {getVisibility getAccessor}"
        if writable then
            let setAccessor = propInfo.SetMethod
            printfn $"   Visibility:    {getVisibility setAccessor}"
        printfn ""

let t = typeof<PropertyClass>
// Get the public properties.
let propInfos = t.GetProperties(BindingFlags.Public ||| BindingFlags.Instance)
printfn $"The number of public properties: {propInfos.Length}.\n"
// Display the public properties.
displayPropertyInfo propInfos

// Get the nonpublic properties.
let propInfos1 = t.GetProperties(BindingFlags.NonPublic ||| BindingFlags.Instance)
printfn $"The number of non-public properties: {propInfos1.Length}.\n"
// Display all the nonpublic properties.
displayPropertyInfo propInfos1

// 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: 2.
//
//          Property name: Property3
//          Property type: System.Int32
//          Read-Write:    False
//          Visibility:    Private
//
//          Property name: Property4
//          Property type: System.String
//          Read-Write:    False
//          Visibility:    Internal/Friend

Imports System.Reflection

' Create a class having six properties.
Public Class PropertyClass
    Public ReadOnly Property Property1() As String
        Get
            Return "hello"
        End Get
    End Property

    Public ReadOnly Property Property2() As String
        Get
            Return "hello"
        End Get
    End Property

    Protected ReadOnly Property Property3() As String
        Get
            Return "hello"
        End Get
    End Property

    Private ReadOnly Property Property4 As Integer
        Get
           Return 32
        End Get
    End Property

    Friend ReadOnly Property Property5 As String
       Get
          Return "value"
       End Get
    End Property

    Protected Friend ReadOnly Property Property6 As String
       Get
          Return "value"
       End Get
    End Property
End Class

Public Module Example
    Public Sub Main()
        Dim t As Type = GetType(PropertyClass)
        ' Get the public properties.
        Dim propInfos As PropertyInfo() = t.GetProperties(BindingFlags.Public Or BindingFlags.Instance)
        Console.WriteLine("The number of public properties: {0}",
                          propInfos.Length)
        Console.WriteLine()
        ' Display the public properties.
        DisplayPropertyInfo(propInfos)

        ' Get the non-public properties.
        Dim propInfos1 As PropertyInfo() = t.GetProperties(BindingFlags.NonPublic Or BindingFlags.Instance)
        Console.WriteLine("The number of non-public properties: {0}",
                          propInfos1.Length)
        Console.WriteLine()
        ' Display all the non-public properties.
        DisplayPropertyInfo(propInfos1)
    End Sub

    Public Sub DisplayPropertyInfo(ByVal propInfos() As PropertyInfo)
        ' Display information for all properties.
        For Each propInfo In propInfos
            Dim readable As Boolean = propInfo.CanRead
            Dim writable As Boolean = propInfo.CanWrite
            
            Console.WriteLine("   Property name: {0}", propInfo.Name)
            Console.WriteLine("   Property type: {0}", propInfo.PropertyType)
            Console.WriteLine("   Read-Write:    {0}", readable And writable)
            If readable Then
               Dim getAccessor As MethodInfo = propInfo.GetMethod
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(getAccessor))
            End If
            If writable Then
               Dim setAccessor As MethodInfo = propInfo.SetMethod
               Console.WriteLine("   Visibility:    {0}",
                                 GetVisibility(setAccessor))
            End If
            Console.WriteLine()
        Next
    End Sub
    
    Public Function GetVisibility(accessor As MethodInfo) As String
       If accessor.IsPublic Then
          Return "Public"
       ElseIf accessor.IsPrivate Then
          Return "Private"
       Else If accessor.IsFamily Then
          Return "Protected"
       Else If accessor.IsAssembly Then
          Return "Internal/Friend"
       Else
          Return "Protected Internal/Friend"
       End If
    End Function
End Module
' 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[])