Type.GetProperties Methode

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

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

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

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

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

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

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

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

Public Function GetProperties () As PropertyInfo()

Retouren

Een matrix van PropertyInfo objecten die alle openbare eigenschappen van de huidige Typevertegenwoordigen.

– of –

Een lege matrix van het type PropertyInfo, als de huidige Type geen openbare eigenschappen heeft.

Implementeringen

Kenmerken

DynamicallyAccessedMembersAttribute

Voorbeelden

In het volgende voorbeeld ziet u het gebruik van de methode GetProperties.

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

Opmerkingen

Het aanroepen van deze overbelasting is gelijk aan het aanroepen van de GetProperties(BindingFlags) overbelasting met een bindingAttr argument dat gelijk is aan BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public in C# en BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public in Visual Basic. Het retourneert alle openbare exemplaren en statische eigenschappen, zowel de eigenschappen die zijn gedefinieerd door het type dat wordt vertegenwoordigd door het huidige Type object als de eigenschappen die zijn overgenomen van de basistypen.

Een eigenschap wordt voor reflectie als openbaar beschouwd als deze ten minste één toegangsfunctie heeft die openbaar is. Anders wordt de eigenschap als privé beschouwd en moet u (in Visual Basic de waarden combineren met behulp van) gebruiken BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Staticom deze te verkrijgen.Or

In .NET 6 en eerdere versies retourneert de methode GetProperties geen eigenschappen in een bepaalde volgorde, zoals alfabetische of declaratievolgorde. Uw code mag niet afhankelijk zijn van de volgorde waarin eigenschappen worden geretourneerd, omdat die volgorde varieert. Vanaf .NET 7 is de volgorde echter deterministisch op basis van de volgorde van metagegevens in de assembly.

In de volgende tabel ziet u welke leden van een basisklasse worden geretourneerd door de Get methoden bij het weergeven van een type.

Lidmaatschapssoort	Static	Niet-statisch
Constructeur	No	No
Veld	No	Yes. Een veld wordt altijd verborgen op basis van naam en kenmerk.
Gebeurtenis	Niet van toepassing	De algemene regels van het type-systeem zijn dat de overerving hetzelfde is als die van de methoden die de eigenschap implementeren. Weerspiegeling behandelt eigenschappen als hide-by-name-and-signature. Zie opmerking 2 hieronder.
Methode	No	Yes. Een methode (zowel virtueel als niet-virtueel) kan worden verborgen op basis van naam of op basis van naam en handtekening.
Geneste type	No	No
Vastgoed	Niet van toepassing	De algemene regels van het type-systeem zijn dat de overerving hetzelfde is als die van de methoden die de eigenschap implementeren. Weerspiegeling behandelt eigenschappen als hide-by-name-and-signature. Zie opmerking 2 hieronder.

1. Hide-by-name-and-signature beschouwt alle onderdelen van de handtekening, waaronder aangepaste modifiers, retourtypen, parametertypen, sentinels en onbeheerde aanroepconventies. Dit is een binaire vergelijking.

2. Voor reflectie worden eigenschappen en gebeurtenissen verborgen op basis van naam en signatuur. Als u een eigenschap hebt met zowel een get als een set accessor in de basisklasse, maar de afgeleide klasse alleen een get-accessor heeft, verbergt de eigenschap afgeleide klasse de eigenschap basisklasse en hebt u geen toegang tot de setter op de basisklasse.

3. Aangepaste kenmerken maken geen deel uit van het algemene typesysteem.

Als de huidige Type een samengesteld algemeen type vertegenwoordigt, retourneert deze methode de PropertyInfo objecten door de typeparameters vervangen door de juiste typeargumenten.

Als de huidige Type een typeparameter vertegenwoordigt in de definitie van een algemeen type of algemene methode, doorzoekt deze methode de eigenschappen van de klassebeperking.

Zie ook

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

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

Bron:

Type.cs

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

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[]

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

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

Parameters

Retouren

Een matrix van objecten die alle eigenschappen van de huidige Type vertegenwoordigen die overeenkomen met de opgegeven bindingsbeperkingen.

– of –

Een lege matrix van het type PropertyInfo, als de huidige Type geen eigenschappen heeft of als geen van de eigenschappen overeenkomt met de bindingsbeperkingen.

Implementeringen

Kenmerken

DynamicallyAccessedMembersAttribute

Voorbeelden

In het volgende voorbeeld wordt een klasse gedefinieerd met de naam PropertyClass met zes eigenschappen: twee zijn openbaar, één is privé, één is beveiligd, een is intern (Friend in Visual Basic) en één is beveiligd intern (Protected Friend in Visual Basic). Vervolgens worden enkele basisinformatie over eigenschappen (de eigenschapsnaam en het type, of het lezen/schrijven is en de zichtbaarheid van get de eigenschappen en set accessors) weergegeven voor de eigenschappen die overeenkomen met de opgegeven bindingsbeperkingen.

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

Opmerkingen

Voor een GetProperties(BindingFlags) overbelasting om eigenschapsgegevens op te halen, moet het bindingAttr argument ten minste één van en BindingFlags.Instance, samen met ten minste één van BindingFlags.StaticBindingFlags.NonPublic en BindingFlags.Public.

De volgende BindingFlags filtervlagmen kunnen worden gebruikt om te definiëren welke eigenschappen moeten worden opgenomen in de zoekopdracht:

• Geef op BindingFlags.Instance om exemplaarmethoden op te nemen.

• Geef BindingFlags.Static op om statische methoden op te nemen.

• Geef BindingFlags.Public op dat openbare eigenschappen moeten worden opgenomen in de zoekopdracht. Een eigenschap wordt voor reflectie als openbaar beschouwd als deze ten minste één toegangsfunctie heeft die openbaar is.

• Geef BindingFlags.NonPublic op dat u niet-openbare eigenschappen (dat wil gezegd privé-, interne en beveiligde eigenschappen) wilt opnemen in de zoekopdracht. Alleen beveiligde en interne eigenschappen op basisklassen worden geretourneerd; privé-eigenschappen op basisklassen worden niet geretourneerd.

• Geef BindingFlags.FlattenHierarchy op dat u statische leden wilt opnemen public in protected de hiërarchie. private Statische leden in overgenomen klassen zijn niet opgenomen.

• Geef BindingFlags.Default alleen op om een lege PropertyInfo matrix te retourneren.

De volgende BindingFlags wijzigingsvlagmen kunnen worden gebruikt om de werking van de zoekopdracht te wijzigen:

• BindingFlags.DeclaredOnly om alleen de eigenschappen te doorzoeken die zijn gedeclareerd op de Type, niet eigenschappen die gewoon zijn overgenomen.

Zie System.Reflection.BindingFlags voor meer informatie.

In .NET 6 en eerdere versies retourneert de methode GetProperties geen eigenschappen in een bepaalde volgorde, zoals alfabetische of declaratievolgorde. Uw code mag niet afhankelijk zijn van de volgorde waarin eigenschappen worden geretourneerd, omdat die volgorde varieert. Vanaf .NET 7 is de volgorde echter deterministisch op basis van de volgorde van metagegevens in de assembly.

Als de huidige Type een samengesteld algemeen type vertegenwoordigt, retourneert deze methode de PropertyInfo objecten door de typeparameters vervangen door de juiste typeargumenten.

Als de huidige Type een typeparameter vertegenwoordigt in de definitie van een algemeen type of algemene methode, doorzoekt deze methode de eigenschappen van de klassebeperking.

Zie ook

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