Type.GetProperties Méthode

Définition

Espace de noms:: System

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Obtient les propriétés du fichier actif Type.

Surcharges

Nom	Description
GetProperties()	Retourne toutes les propriétés publiques de la Typeactuelle.
GetProperties(BindingFlags)	En cas de substitution dans une classe dérivée, recherche les propriétés de la Typeactuelle, à l’aide des contraintes de liaison spécifiées.

GetProperties()

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Retourne toutes les propriétés publiques de la Typeactuelle.

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

Retours

PropertyInfo[]

Tableau d’objets PropertyInfo représentant toutes les propriétés publiques de l’objet actif Type.

- ou -

Tableau vide de type PropertyInfo, si le courant Type n’a pas de propriétés publiques.

Implémente

GetProperties()

Attributs: DynamicallyAccessedMembersAttribute

Exemples

L'exemple suivant illustre l'utilisation de la méthode 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

Remarques

L’appel de cette surcharge équivaut à appeler la surcharge GetProperties(BindingFlags) avec un argument bindingAttr égal à BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public en C# et BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public dans Visual Basic. Elle retourne toutes les propriétés publiques et statiques, à la fois celles définies par le type représenté par l’objet actuel Type ainsi que celles héritées de ses types de base.

Une propriété est considérée comme publique pour la réflexion si elle a au moins un accesseur public. Sinon, la propriété est considérée comme privée et vous devez utiliser BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (en Visual Basic, combiner les valeurs à l’aide Orde ) pour l’obtenir.

Dans .NET 6 et versions antérieures, la méthode GetProperties ne retourne pas de propriétés dans un ordre particulier, tel que l’ordre alphabétique ou de déclaration. Votre code ne doit pas dépendre de l’ordre dans lequel les propriétés sont retournées, car cet ordre varie. Toutefois, à partir de .NET 7, l’ordre est déterministe en fonction de l’ordre des métadonnées dans l’assembly.

Le tableau suivant montre quels membres d'une classe de base sont retournés par les Get méthodes lors de la réflexion sur un type.

Type de membre	Static	Non statique
Constructor	Non	Non
Champ	Non	Yes. Un champ est toujours masqué par nom et signature.
Event	Sans objet	La règle du système de type courant est que l'héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.
Méthode	Non	Yes. Une méthode (virtuelle et non virtuelle) peut être masquée par nom ou par nom et signature.
Type imbriqué	Non	Non
Propriété	Sans objet	La règle du système de type courant est que l'héritage est identique à celui des méthodes qui implémentent la propriété. La réflexion traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous.

Hide-by-name-and-signature prend en compte toutes les parties de la signature, notamment les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.
Pour la réflexion, les propriétés et les événements sont masqués par nom et signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder au setter sur la classe de base.
Les attributs personnalisés ne font pas partie du système de type commun.

Si le courant Type représente un type générique construit, cette méthode retourne les objets avec les PropertyInfo paramètres de type remplacés par les arguments de type appropriés.

Si le paramètre actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode recherche les propriétés de la contrainte de classe.

Voir aussi

S’applique à

GetProperties(BindingFlags)

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

Source:: Type.cs

En cas de substitution dans une classe dérivée, recherche les propriétés de la Typeactuelle, à l’aide des contraintes de liaison spécifiées.

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

Paramètres

bindingAttr: BindingFlags

Combinaison de bits des valeurs d’énumération qui spécifient la façon dont la recherche est effectuée.

- ou -

Default pour retourner un tableau vide.

Retours

PropertyInfo[]

Tableau d’objets représentant toutes les propriétés du courant Type qui correspondent aux contraintes de liaison spécifiées.

- ou -

Tableau vide de type PropertyInfo, si le courant Type n’a pas de propriétés ou si aucune des propriétés ne correspond aux contraintes de liaison.

Implémente

GetProperties(BindingFlags) GetProperties(BindingFlags)

Attributs: DynamicallyAccessedMembersAttribute

Exemples

L’exemple suivant définit une classe nommée PropertyClass qui comprend six propriétés : deux sont publiques, l’une est privée, l’autre est protégée ( Friend dans Visual Basic), et l’autre est protégée interne (Protected Friend dans Visual Basic). Il affiche ensuite des informations de propriété de base (nom et type de propriété, qu’il s’agisse de lecture/écriture et de la visibilité de ses get et set accesseurs) pour les propriétés qui correspondent aux contraintes de liaison spécifiées.

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

Remarques

Pour que la GetProperties(BindingFlags) surcharge récupère correctement les informations de propriété, l’argument bindingAttr doit inclure au moins un des BindingFlags.Instance BindingFlags.Static éléments et , ainsi qu’au moins un des BindingFlags.NonPublic éléments et BindingFlags.Public.

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les propriétés à inclure dans la recherche :

Spécifiez BindingFlags.Instance d’inclure des méthodes d’instance.
Spécifiez BindingFlags.Static d’inclure des méthodes statiques.
Spécifiez BindingFlags.Public pour inclure les propriétés publiques dans la recherche. Une propriété est considérée comme publique pour la réflexion si elle a au moins un accesseur public.
Spécifiez BindingFlags.NonPublic d’inclure des propriétés non publiques (c’est-à-dire des propriétés privées, internes et protégées) dans la recherche. Seules les propriétés protégées et internes sur les classes de base sont retournées ; les propriétés privées sur les classes de base ne sont pas retournées.
Spécifiez BindingFlags.FlattenHierarchy pour inclure public et protected les membres statiques de la hiérarchie ; les membres statiques des classes héritées private ne sont pas inclus.
Spécifiez BindingFlags.Default uniquement pour retourner un tableau vide PropertyInfo .

Les indicateurs de modification suivants BindingFlags peuvent être utilisés pour modifier le fonctionnement de la recherche :

BindingFlags.DeclaredOnly pour rechercher uniquement les propriétés déclarées sur le Type, et non les propriétés qui ont été simplement héritées.

Pour plus d’informations, consultez System.Reflection.BindingFlags.

Si le courant Type représente un type générique construit, cette méthode retourne les objets avec les PropertyInfo paramètres de type remplacés par les arguments de type appropriés.

Voir aussi

S’applique à

Commentaires

Cette page a-t-elle été utile ?