Type.GetProperties Metoda

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Získá vlastnosti aktuálního Type.

Přetížení

Name	Description
GetProperties()	Vrátí všechny veřejné vlastnosti aktuálního Typeobjektu .
GetProperties(BindingFlags)	Při přepsání v odvozené třídě vyhledá vlastnosti aktuálního Type, pomocí zadaných vazeb omezení.

GetProperties()

Zdroj:

Type.cs

Vrátí všechny veřejné vlastnosti aktuálního Typeobjektu .

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties)]
public System.Reflection.PropertyInfo[] GetProperties();

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties)>]
member this.GetProperties : unit -> System.Reflection.PropertyInfo[]

Public Function GetProperties () As PropertyInfo()

Návraty

PropertyInfo[]

Pole PropertyInfo objektů představujících všechny veřejné vlastnosti aktuálního Typeobjektu .

nebo

Prázdné pole typu PropertyInfo, pokud aktuální Type nemá veřejné vlastnosti.

Atributy

DynamicallyAccessedMembersAttribute

Příklady

Následující příklad ukazuje použití GetProperties metody.

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

Poznámky

Volání tohoto přetížení je ekvivalentní volání GetProperties(BindingFlags) přetížení s argumentem bindingAttr roven BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public v jazyce C# a BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public v Visual Basic. Vrátí všechny veřejné instance a statické vlastnosti, a to jak ty definované typem reprezentovaným aktuálním Type objektem, tak i ty zděděné z jeho základních typů.

Vlastnost je považována za veřejnou pro reflexi, pokud má alespoň jeden přístup, který je veřejný. V opačném případě je vlastnost považována za soukromou a k jejímu získání je nutné použít BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (v jazyce Visual Basic zkombinovat hodnoty pomocí).Or

V .NET 6 a starších verzích metoda GetProperties nevrací vlastnosti v určitém pořadí, jako je abecední pořadí nebo pořadí deklarací. Váš kód nesmí záviset na pořadí, ve kterém se vrátí vlastnosti, protože se toto pořadí liší. Od .NET 7 je však řazení deterministické na základě pořadí metadat v sestavení.

Následující tabulka ukazuje, jaké členy základní třídy jsou vráceny metodami Get při reflexi typu.

Typ členu	Static	Nestatické
Konstruktor	No	No
Pole	No	Yes. Pole se vždy skryje podle názvu a signatury.
Událost	Není relevantní	Běžné pravidlo systému typů je, že dědičnost je stejná jako u metod, které implementují vlastnost. Reflexe považuje vlastnosti za skrýt podle názvu a podpisu. Viz poznámka 2 níže.
Metoda	No	Yes. Metodu (virtuální i ne virtuální) lze skrýt podle názvu nebo skrýt podle názvu a podpisu.
Vnořený typ	No	No
Vlastnictví	Není relevantní	Běžné pravidlo systému typů je, že dědičnost je stejná jako u metod, které implementují vlastnost. Reflexe považuje vlastnosti za skrýt podle názvu a podpisu. Viz poznámka 2 níže.

1. Funkce skrytí podle jména a podpisu zohledňuje všechny části podpisu, včetně vlastních modifikátorů, návratových typů, typů parametrů, sentinelů a nespravovaných konvencí volání. Jedná se o binární porovnání.

2. Pro reflexi jsou vlastnosti a události skryty podle názvu a podpisu. Pokud máte vlastnost s oběma přístupovými metodami get i set v základní třídě, ale odvozená třída má pouze přístupovou metodu get, odvozená třída překryje vlastnost základní třídy a nebudete mít přístup k nastavovací metodě základní třídy.

3. Vlastní atributy nejsou součástí systému běžných typů.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí PropertyInfo objekty s parametry typu nahrazené příslušnými argumenty typu.

Pokud aktuální Type představuje parametr typu v definici obecného typu nebo obecné metody, tato metoda hledá vlastnosti omezení třídy.

Viz také

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

GetProperties(BindingFlags)

Zdroj:

Type.cs

Při přepsání v odvozené třídě vyhledá vlastnosti aktuálního Type, pomocí zadaných vazeb omezení.

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

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties)]
public abstract System.Reflection.PropertyInfo[] GetProperties(System.Reflection.BindingFlags bindingAttr);

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties)>]
abstract member GetProperties : System.Reflection.BindingFlags -> System.Reflection.PropertyInfo[]

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

Parametry

bindingAttr

BindingFlags

Bitové kombinace hodnot výčtu, které určují způsob provedení hledání.

nebo

Default pro vrácení prázdného pole.

Návraty

PropertyInfo[]

Pole objektů představujících všechny vlastnosti aktuálního Type objektu, které odpovídají zadaným omezením vazby.

nebo

Prázdné pole typu PropertyInfo, pokud aktuální Type nemá vlastnosti nebo pokud žádná z vlastností neodpovídá omezením vazby.

Implementuje

GetProperties(BindingFlags)

Atributy

DynamicallyAccessedMembersAttribute

Příklady

Následující příklad definuje třídu s názvem PropertyClass, která obsahuje šest vlastností: dva jsou veřejné, jedna je soukromá, jedna je chráněná, jedna je interní (Friend v Visual Basic) a jedna je chráněná interní (Protected Friend v Visual Basic). Pak zobrazí některé základní informace o vlastnostech (název a typ vlastnosti, zda se jedná o čtení/zápis a viditelnost jeho get a set přístupových objektů) pro vlastnosti, které odpovídají zadaným omezením vazby.

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

Poznámky

GetProperties(BindingFlags) Aby přetížení úspěšně načetl informace o vlastnosti, bindingAttr musí argument obsahovat alespoň jeden z BindingFlags.Instance aspoň BindingFlags.Staticjednoho z a nejméně jednoho z BindingFlags.NonPublic a BindingFlags.Public.

BindingFlags Následující příznaky filtru lze použít k definování vlastností, které se mají zahrnout do hledání:

• Zadejte BindingFlags.Instance , aby zahrnovaly metody instance.

• Zadejte BindingFlags.Static , aby zahrnovaly statické metody.

• Zadejte BindingFlags.Public , aby se do hledání zahrnuly veřejné vlastnosti. Vlastnost je považována za veřejnou pro reflexi, pokud má alespoň jeden přístup, který je veřejný.

• Zadejte BindingFlags.NonPublic , aby se do hledání zahrnuly neveřejné vlastnosti (tj. soukromé, interní a chráněné vlastnosti). Vrátí se pouze chráněné a interní vlastnosti základních tříd; privátní vlastnosti základních tříd nejsou vráceny.

• Určete BindingFlags.FlattenHierarchy, aby se zahrnuly public a protected statické členy v hierarchii; ale private statické členy v zděděných třídách nejsou zahrnuty.

• Zadejte BindingFlags.Default samostatně, aby se vrátilo prázdné PropertyInfo pole.

Ke změně fungování vyhledávání můžete použít následující BindingFlags modifikační příznaky:

• BindingFlags.DeclaredOnly hledat pouze vlastnosti deklarované v objektu Type, nikoli vlastnosti, které byly jednoduše zděděny.

Další informace naleznete na System.Reflection.BindingFlags.

V .NET 6 a starších verzích metoda GetProperties nevrací vlastnosti v určitém pořadí, jako je abecední pořadí nebo pořadí deklarací. Váš kód nesmí záviset na pořadí, ve kterém se vrátí vlastnosti, protože se toto pořadí liší. Od .NET 7 je však řazení deterministické na základě pořadí metadat v sestavení.

Pokud aktuální Type představuje vytvořený obecný typ, tato metoda vrátí PropertyInfo objekty s parametry typu nahrazené příslušnými argumenty typu.

Pokud aktuální Type představuje parametr typu v definici obecného typu nebo obecné metody, tato metoda hledá vlastnosti omezení třídy.

Viz také

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