Type.GetProperties Méthode
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 Type actuel.
GetProperties() |
Retourne toutes les propriétés publiques du Type actuel. |
GetProperties(BindingFlags) |
En cas de substitution dans une classe dérivée, recherche les propriétés du Type actuel, à l’aide des contraintes de liaison spécifiées. |
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
Retourne toutes les propriétés publiques du Type actuel.
public:
cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties();
public:
virtual cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties();
public System.Reflection.PropertyInfo[] GetProperties ();
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
Tableau d'objets PropertyInfo représentant toutes les propriétés publiques du Type actuel.
- ou -
Tableau vide du type PropertyInfo si le Type actuel n'a pas de propriétés publiques.
Implémente
Exemples
L'exemple suivant illustre l'utilisation de la méthode 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
Remarques
Appeler cette surcharge revient à appeler la GetProperties(BindingFlags) surcharge avec un bindingAttr
argument égal à BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public
en C# et BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public
en Visual Basic. Elle retourne toutes les propriétés instance 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 à 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.InstanceBindingFlags.Static (en Visual Basic, combiner les valeurs à l’aide Or
de ) pour l’obtenir.
Dans .NET 6 et les versions antérieures, la GetProperties méthode ne retourne pas les propriétés dans un ordre particulier, tel que l’ordre alphabétique ou l’ordre 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, à compter de .NET 7, l’ordre est déterministe en fonction du classement des métadonnées dans l’assembly.
Le tableau suivant montre quels membres d’une classe de base sont retournés par les méthodes lors de la Get
réflexion sur un type.
Type de membre | statique | Non statique |
---|---|---|
Constructeur | Non | Non |
Champ | Non | Oui. Un champ est toujours masqué par nom et signature. |
Événement | Non applicable | La règle système de type courante est que l’héritage est identique à celui des méthodes qui implémentent la propriété . Reflection traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous. |
Méthode | Non | Oui. Une méthode (virtuelle et non virtuelle) peut être hide-by-name ou hide-by-name-and-signature. |
Type imbriqué | Non | Non |
Propriété | Non applicable | La règle système de type courante est que l’héritage est identique à celui des méthodes qui implémentent la propriété . Reflection traite les propriétés comme masquage par nom et signature. Voir la note 2 ci-dessous. |
Masquer par nom et signature prend en compte toutes les parties de la signature, y compris 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 à l’élément setter sur la classe de base.
Les attributs personnalisés ne font pas partie du système de type commun.
Si le actuel Type représente un type générique construit, cette méthode retourne les PropertyInfo objets avec les paramètres de type remplacés par les arguments de type appropriés.
Si le 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 à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
- Source:
- Type.cs
- Source:
- Type.cs
- Source:
- Type.cs
En cas de substitution dans une classe dérivée, recherche les propriétés du Type actuel, à l’aide des contraintes de liaison spécifiées.
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()
Paramètres
- bindingAttr
- BindingFlags
Combinaison de bits de valeurs d’énumération qui spécifie la façon dont est effectuée la recherche.
- ou -
Default pour retourner un tableau vide.
Retours
Tableau d’objets représentant toutes les propriétés du Type actuel qui correspondent aux contraintes de liaison spécifiées.
- ou -
Tableau vide du type PropertyInfo si le Type actuel n’a pas de propriétés ou si aucune des propriétés ne correspond aux contraintes de liaison.
Implémente
Exemples
L’exemple suivant définit une classe nommée PropertyClass
qui inclut six propriétés : deux sont publiques, une est privée, une est protégée, une est interne (Friend
en Visual Basic) et l’autre est protégée interne (Protected Friend
en Visual Basic). Il affiche ensuite des informations de propriété de base (le nom et le type de la propriété, si elle est en lecture/écriture, et la visibilité de ses get
accesseurs et set
) pour les propriétés qui correspondent aux contraintes de liaison spécifiées.
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
Remarques
Pour que la GetProperties(BindingFlags)
surcharge récupère correctement les informations de propriété, l’argument bindingAttr
doit inclure au moins un de BindingFlags.Instance et BindingFlags.Static, ainsi qu’au moins un des BindingFlags.NonPublic 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
pour inclure instance méthodes.Spécifiez
BindingFlags.Static
pour inclure des méthodes statiques.Spécifiez
BindingFlags.Public
pour inclure des propriétés publiques dans la recherche. Une propriété est considérée comme publique à réflexion si elle a au moins un accesseur public.Spécifiez
BindingFlags.NonPublic
pour 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 etprotected
lespublic
membres statiques dans la hiérarchie ;private
les membres statiques dans les classes héritées ne sont pas inclus.Spécifiez
BindingFlags.Default
seul 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.
Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.
Dans .NET 6 et les versions antérieures, la GetProperties méthode ne retourne pas les propriétés dans un ordre particulier, tel que l’ordre alphabétique ou l’ordre 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, à compter de .NET 7, l’ordre est déterministe en fonction du classement des métadonnées dans l’assembly.
Si le actuel Type représente un type générique construit, cette méthode retourne les PropertyInfo objets avec les paramètres de type remplacés par les arguments de type appropriés.
Si le 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
- PropertyInfo
- BindingFlags
- DefaultBinder
- GetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])
S’applique à
.NET 9 et autres versions
Produit | Versions |
---|---|
.NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0, 2.1 |
Commentaires sur .NET
.NET est un projet open source. Sélectionnez un lien pour fournir des commentaires :