Type.GetProperties Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Geçerli Typeöğesinin özelliklerini alır.

Aşırı Yüklemeler

GetProperties()	Geçerli Typeöğesinin tüm genel özelliklerini döndürür.
GetProperties(BindingFlags)	Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını kullanarak geçerli Typeöğesinin özelliklerini arar.

GetProperties()

Kaynak:

Type.cs

Geçerli Typeöğesinin tüm genel özelliklerini döndürür.

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

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

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

Public Function GetProperties () As PropertyInfo()

Döndürülenler

PropertyInfo[]

Geçerli Typeöğesinin PropertyInfo tüm genel özelliklerini temsil eden bir nesne dizisi.

-veya-

Geçerlinin Type ortak özellikleri yoksa, türünde PropertyInfoboş bir dizi.

Örnekler

Aşağıdaki örnekte yönteminin kullanımı gösterilmektedir 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

Açıklamalar

Bu aşırı yüklemeyi çağırmak, C# içinde ve BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public Visual Basic'te değerine eşit bir bindingAttr bağımsız değişkenle aşırı yüklemeyi çağırmaya GetProperties(BindingFlags)BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public eşdeğerdir. Hem geçerli Type nesne tarafından temsil edilen tür tarafından tanımlanan hem de temel türlerinden devralınan tüm genel örneği ve statik özellikleri döndürür.

Bir özelliğin en az bir genel erişimcisi varsa, o özellik yansıma için genel sayılır. Aksi takdirde özellik özel olarak kabul edilir ve bunu almak için kullanmanız gerekir BindingFlags.NonPublic | | BindingFlags.InstanceBindingFlags.Static (Visual Basic'te kullanarak değerleri Orbirleştirin).

.NET 6 ve önceki sürümlerinde yöntemi, GetProperties alfabetik veya bildirim sırası gibi belirli bir sırada özellik döndürmez. Kodunuz özelliklerin döndürülme sırasına bağlı olmamalıdır, çünkü bu sıra değişir. Ancak.NET 7'den başlayarak sıralama, derlemedeki meta veri sıralamasını temel alarak belirleyicidir.

Aşağıdaki tabloda, bir türe yansıtılırken yöntemler tarafından Get döndürülen temel sınıfın üyeleri gösterilmektedir.

Üye Türü	Statik	Statik Olmayan
Oluşturucu	Hayır	Hayır
Alan	Hayır	Evet. Bir alan her zaman "ada ve imzaya göre gizle" özelliğindedir.
Olay	Uygulanamaz	Ortak tür sistemi kuralı, devralma işleminin özelliği uygulayan yöntemlerinkiyle aynı olmasıdır. Yansıma, özellikleri "ada ve imzaya göre gizle" şeklinde kullanır. Aşağıdaki 2. nota bakın.
Yöntem	Hayır	Evet. Bir yöntem (sanal ve sanal olmayan) "ada göre gizle" veya "ada ve imzaya göre gizle" özelliğinde olabilir.
İç İçe Tür	Hayır	Hayır
Özellik	Uygulanamaz	Ortak tür sistemi kuralı, devralma işleminin özelliği uygulayan yöntemlerinkiyle aynı olmasıdır. Yansıma, özellikleri "ada ve imzaya göre gizle" şeklinde kullanır. Aşağıdaki 2. nota bakın.

1. "Ada ve imzaya göre gizle" özelliği, imzanın tüm parçalarını (özel değiştiriciler, dönüş türleri, parametre türleri, başlangıç/bitiş simgeleri ve yönetilmeyen çağrı kuralları dahil) dikkate alır. Bu ikili bir karşılaştırmadır.

2. Yansıma için, özellikler ve olaylar "ada ve imzaya göre gizle" özelliğindedir. Bu temel sınıfta hem alma hem de ayarlama erişimcisine sahip bir özelliğiniz varsa, ancak türetilen sınıfın yalnızca bir alma erişimcisi varsa, türetilen sınıf özelliği temel sınıf özelliğini gizler ve siz de temel sınıfta ayarlayıcıya erişemezsiniz.

3. Özel öznitelikler ortak tür sisteminin parçası değildir.

Geçerli Type , yapılandırılmış bir genel türü temsil ederse, bu yöntem nesneleri, uygun tür bağımsız değişkenleriyle değiştirilen tür parametreleriyle döndürür PropertyInfo .

Geçerli Type , genel bir türün veya genel yöntemin tanımında tür parametresini temsil ederse, bu yöntem sınıf kısıtlamasının özelliklerini arar.

Ayrıca bkz.

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

GetProperties(BindingFlags)

Kaynak:

Type.cs

Türetilmiş bir sınıfta geçersiz kılındığında, belirtilen bağlama kısıtlamalarını kullanarak geçerli Typeöğesinin özelliklerini arar.

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

Parametreler

bindingAttr

BindingFlags

Aramanın nasıl yürütüleceğini belirten numaralandırma değerlerinin bit düzeyinde birleşimi.

-veya-

Default boş bir dizi döndürmek için.

Döndürülenler

PropertyInfo[]

Geçerlinin belirtilen bağlama kısıtlamalarıyla eşleşen tüm özelliklerini Type temsil eden bir nesne dizisi.

-veya-

Geçerlinin Type özellikleri yoksa veya özelliklerin hiçbiri bağlama kısıtlamalarıyla eşleşmiyorsa, türünde PropertyInfoboş bir dizi.

Uygulamalar

GetProperties(BindingFlags)

Örnekler

Aşağıdaki örnek, altı özellik içeren adlı PropertyClass bir sınıfı tanımlar: ikisi ortak, biri özel, biri korumalı, biri iç (Visual Basic'te) ve biri iç (FriendProtected FriendVisual Basic'te) korumalı. Ardından, belirtilen bağlama kısıtlamalarıyla eşleşen özellikler için bazı temel özellik bilgilerini (özellik adı ve türü, okuma/yazma ve erişimcilerinin getset görünürlüğü) görüntüler.

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

Açıklamalar

Aşırı yüklemenin GetProperties(BindingFlags) özellik bilgilerini başarıyla alabilmesi için, bağımsız değişkeninin bindingAttr ve ile birlikte en az bir BindingFlags.Instance ve BindingFlags.StaticBindingFlags.Publiciçermesi BindingFlags.NonPublic gerekir.

Aramaya hangi özelliklerin dahil edilebileceğini tanımlamak için aşağıdaki BindingFlags filtre bayrakları kullanılabilir:

• Örnek yöntemlerini dahil etmek için belirtin BindingFlags.Instance .

• Statik yöntemleri dahil etmek için belirtin BindingFlags.Static .

• Genel özellikleri aramaya eklemek için belirtin BindingFlags.Public . Bir özelliğin en az bir genel erişimcisi varsa, o özellik yansıma için genel sayılır.

• Genel olmayan özellikleri (özel, iç ve korumalı özellikler) aramaya dahil etmek için belirtin BindingFlags.NonPublic . Yalnızca temel sınıflardaki korumalı ve iç özellikler döndürülür; temel sınıflardaki özel özellikler döndürülmüyor.

• Hiyerarşiye eklenecek public ve protected statik üyeleri belirtinBindingFlags.FlattenHierarchy; private devralınan sınıflardaki statik üyeler dahil değildir.

• Boş PropertyInfo bir dizi döndürmek için tek başına belirtinBindingFlags.Default.

Aramanın çalışma şeklini değiştirmek için aşağıdaki BindingFlags değiştirici bayraklar kullanılabilir:

• BindingFlags.DeclaredOnly yalnızca üzerinde Typebildirilen özellikleri aramak için yalnızca devralınan özellikleri aramaz.

Daha fazla bilgi edinmek için bkz. System.Reflection.BindingFlags.

.NET 6 ve önceki sürümlerinde yöntemi, GetProperties alfabetik veya bildirim sırası gibi belirli bir sırada özellik döndürmez. Kodunuz özelliklerin döndürülme sırasına bağlı olmamalıdır, çünkü bu sıra değişir. Ancak.NET 7'den başlayarak sıralama, derlemedeki meta veri sıralamasını temel alarak belirleyicidir.

Geçerli Type , yapılandırılmış bir genel türü temsil ederse, bu yöntem nesneleri, uygun tür bağımsız değişkenleriyle değiştirilen tür parametreleriyle döndürür PropertyInfo .

Geçerli Type , genel bir türün veya genel yöntemin tanımında tür parametresini temsil ederse, bu yöntem sınıf kısıtlamasının özelliklerini arar.

Ayrıca bkz.

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