Type.GetProperties Type.GetProperties Type.GetProperties Type.GetProperties Method

정의

현재 Type의 속성을 가져옵니다.Gets the properties of the current Type.

오버로드

GetProperties() GetProperties() GetProperties() GetProperties()

현재 Type의 모든 public 속성을 반환합니다.Returns all the public properties of the current Type.

GetProperties(BindingFlags) GetProperties(BindingFlags) GetProperties(BindingFlags) GetProperties(BindingFlags)

파생 클래스에서 재정의되면, 현재 Type의 속성을 지정된 바인딩 제약 조건으로 검색합니다.When overridden in a derived class, searches for the properties of the current Type, using the specified binding constraints.

GetProperties() GetProperties() GetProperties() GetProperties()

현재 Type의 모든 public 속성을 반환합니다.Returns all the public properties of the current Type.

public:
 virtual cli::array <System::Reflection::PropertyInfo ^> ^ GetProperties();
public System.Reflection.PropertyInfo[] GetProperties ();
abstract member GetProperties : unit -> System.Reflection.PropertyInfo[]
override this.GetProperties : unit -> System.Reflection.PropertyInfo[]
Public Function GetProperties () As PropertyInfo()

반환

현재 PropertyInfo의 모든 public 속성을 나타내는 Type 개체의 배열입니다.An array of PropertyInfo objects representing all public properties of the current Type.

또는-or- 현재 PropertyInfo에 public 속성이 없을 경우 Type 형식의 빈 배열입니다.An empty array of type PropertyInfo, if the current Type does not have public properties.

구현

예제

다음 예제에서는 GetProperties 메서드를 사용하는 방법을 보여 줍니다.The following example demonstrates the use of the GetProperties method.

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

설명

이 오버 로드는 호출에 해당 하는 GetProperties(BindingFlags) 오버 로드를 bindingAttr 같음 인수 BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public C# 및 BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public Visual Basic의 합니다.Calling this overload is equivalent to calling the GetProperties(BindingFlags) overload with a bindingAttr argument equal to BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public in C# and BindingFlags.Instance Or BindingFlags.Static Or BindingFlags.Public in Visual Basic. 모든 공용 인스턴스 및 정적 속성을 현재 형식에 의해 정의 된 두 반환 Type 개체 뿐만 아니라 해당 기본 형식에서 상속 합니다.It returns all public instance and static properties, both those defined by the type represented by the current Type object as well as those inherited from its base types.

속성을 공용 접근자가 적어도 하나 있으면 반사를 공용으로 간주 됩니다.A property is considered public to reflection if it has at least one accessor that is public. 그렇지 않은 경우 속성은 개인으로 간주 하 고 사용 해야 합니다 BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (Visual basic에서 사용 하 여 값을 결합 Or) 가져오려고 합니다.Otherwise the property is considered private, and you must use BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static (in Visual Basic, combine the values using Or) to get it.

GetProperties 메서드 반환 하지 않습니다 속성을 특정 순서로 같은 알파벳 또는 선언 순서입니다.The GetProperties method does not return properties in a particular order, such as alphabetical or declaration order. 코드 영향을 받지 않아야 속성 반환 되는 순서 때문에 순서에 따라 달라 지는 합니다.Your code must not depend on the order in which properties are returned, because that order varies.

다음 표에서 메서드에서 반환 되는 기본 클래스의 멤버는 Get 메서드 형식에 반영 하는 경우.The following table shows what members of a base class are returned by the Get methods when reflecting on a type.

멤버 형식Member Type 정적Static Static이 아니고Non-Static
생성자Constructor 아니요No 아니요No
필드Field 아니요No 예.Yes. 필드는 항상 이름 및 서명에서 숨겨집니다.A field is always hide-by-name-and-signature.
이벤트Event 적용할 수 없음Not applicable 공용 형식 시스템 규칙의 상속 속성을 구현 하는 메서드의 것과 동일 된다는 것입니다.The common type system rule is that the inheritance is the same as that of the methods that implement the property. 리플렉션 속성 이름 및 서명으로 숨기기 취급 됩니다.Reflection treats properties as hide-by-name-and-signature. 참고 2 아래를 참조 하세요.See note 2 below.
메서드Method 아니요No 예.Yes. (가상 및 비가상) 메서드 이름에서 숨김 또는 이름 및 서명으로 숨기기 수 있습니다.A method (both virtual and non-virtual) can be hide-by-name or hide-by-name-and-signature.
중첩된 형식Nested Type 아니요No 아니요No
속성Property 적용할 수 없음Not applicable 공용 형식 시스템 규칙의 상속 속성을 구현 하는 메서드의 것과 동일 된다는 것입니다.The common type system rule is that the inheritance is the same as that of the methods that implement the property. 리플렉션 속성 이름 및 서명으로 숨기기 취급 됩니다.Reflection treats properties as hide-by-name-and-signature. 참고 2 아래를 참조 하세요.See note 2 below.
  1. 이름 및 서명으로 숨기기 모든 사용자 지정 한정자를 포함 하 여 서명의 부분 반환 형식, 매개 변수 형식, 센티널, 및 관리 되지 않는 호출 규칙을 고려 합니다.Hide-by-name-and-signature considers all of the parts of the signature, including custom modifiers, return types, parameter types, sentinels, and unmanaged calling conventions. 이것은 이진 비교 합니다.This is a binary comparison.

  2. 리플렉션, 속성 및 이벤트는 이름 및 서명에서 숨겨집니다.For reflection, properties and events are hide-by-name-and-signature. 기본 클래스에서 get 및 set 접근자 모두를 사용 하 여 속성을 갖지만 파생된 클래스에 get 접근자만 하는 경우 파생된 클래스 속성을 기본 클래스 속성 숨기고 기본 클래스의 setter를 액세스할 수 없습니다.If you have a property with both a get and a set accessor in the base class, but the derived class has only a get accessor, the derived class property hides the base class property, and you will not be able to access the setter on the base class.

  3. 사용자 지정 특성의 일부분이 아닌 공용 형식 시스템입니다.Custom attributes are not part of the common type system.

하는 경우 현재 Type 이 메서드는 반환 생성된 된 제네릭 형식을 나타내는 PropertyInfo 따라 적절 한 형식 인수로 대체 형식 매개 변수를 사용 하 여 개체입니다.If the current Type represents a constructed generic type, this method returns the PropertyInfo objects with the type parameters replaced by the appropriate type arguments.

하는 경우 현재 Type 형식 매개 변수는 제네릭 형식 또는 제네릭 메서드 정의에서이 메서드는 클래스 제약 조건의 속성을 검색 합니다.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the properties of the class constraint.

추가 정보

GetProperties(BindingFlags) GetProperties(BindingFlags) GetProperties(BindingFlags) GetProperties(BindingFlags)

파생 클래스에서 재정의되면, 현재 Type의 속성을 지정된 바인딩 제약 조건으로 검색합니다.When overridden in a derived class, searches for the properties of the current Type, using the specified binding constraints.

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

매개 변수

bindingAttr
BindingFlags BindingFlags BindingFlags BindingFlags

검색 방법을 지정하는 열거형 값의 비트 조합입니다.A bitwise combination of the enumeration values that specify how the search is conducted.

또는-or-

빈 배열을 반환하는 Default입니다.Default to return an empty array.

반환

현재 Type의 속성 중 지정된 바인딩 제약 조건과 일치하는 모든 속성을 나타내는 개체의 배열입니다.An array of objects representing all properties of the current Type that match the specified binding constraints.

또는-or- 현재 PropertyInfo에 속성이 없거나 해당 바인딩 제약 조건과 일치하는 속성이 없을 경우 Type 형식의 빈 배열입니다.An empty array of type PropertyInfo, if the current Type does not have properties, or if none of the properties match the binding constraints.

구현

예제

라는 클래스를 정의 하는 다음 예제에서는 PropertyClass 6 개의 속성을 포함 하는: 두는 공용, 개인 것, 보호 되는 하나, 하나는 내부 (Friend Visual basic에서), 내부 보호 되며 하나 (Protected Friend Visual Basic에서).The following example defines a class named PropertyClass that includes six properties: two are public, one is private, one is protected, one is internal (Friend in Visual Basic), and one is protected internal (Protected Friend in Visual Basic). 일부 기본 속성 정보를 표시 합니다 (속성 이름 및 형식을 읽기/쓰기가 가능 하며의 표시 여부는 해당 여부를 해당 getset 접근자) 지정 된 바인딩 제약 조건과 일치 하는 속성에 대 한 합니다.It then displays some basic property information (the property name and type, whether it is read/write, and the visibility of its get and set accessors) for the properties that match the specified binding constraints.

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

설명

BindingFlags.Static BindingFlags.Instance bindingAttr BindingFlags.Public BindingFlags.NonPublic 오버 로드가 속성 정보를 성공적으로 검색 하려면 인수에 및 중 적어도 하나 이상이 포함 되어야 합니다. GetProperties(BindingFlags)For the GetProperties(BindingFlags) overload to successfully retrieve property information, the bindingAttr argument must include at least one of BindingFlags.Instance and BindingFlags.Static, along with at least one of BindingFlags.NonPublic and BindingFlags.Public.

다음 BindingFlags 필터 플래그를 사용 하 여 검색에 포함할 속성을 정의할 수 있습니다.The following BindingFlags filter flags can be used to define which properties to include in the search:

  • 인스턴스 BindingFlags.Instance 메서드를 포함 하도록 지정 합니다.Specify BindingFlags.Instance to include instance methods.

  • 정적 BindingFlags.Static 메서드를 포함 하도록 지정 합니다.Specify BindingFlags.Static to include static methods.

  • 지정 BindingFlags.Public 검색에서 공용 속성을 포함 하도록 합니다.Specify BindingFlags.Public to include public properties in the search. 속성을 공용 접근자가 적어도 하나 있으면 반사를 공용으로 간주 됩니다.A property is considered public to reflection if it has at least one accessor that is public.

  • 지정 BindingFlags.NonPublic 검색에 public이 아닌 속성 (즉, 전용, 내부 및 보호 된 속성)을 포함 하도록 합니다.Specify BindingFlags.NonPublic to include non-public properties (that is, private, internal, and protected properties) in the search. 만 보호 하 고 기본 클래스의 내부 속성이 반환 됩니다. 기본 클래스에서 private 속성 반환 되지 않습니다.Only protected and internal properties on base classes are returned; private properties on base classes are not returned.

  • 지정할 BindingFlags.FlattenHierarchy 하기로 publicprotected 정적 멤버를 계층 구조 private 상속 된 클래스의 정적 멤버가 포함 되지 않습니다.Specify BindingFlags.FlattenHierarchy to include public and protected static members up the hierarchy; private static members in inherited classes are not included.

  • BindingFlags.DefaultPropertyInfo 배열을 반환 하려면만 지정 합니다.Specify BindingFlags.Default alone to return an empty PropertyInfo array.

다음 BindingFlags 한정자 플래그를 사용 하 여 검색의 작동 방식을 변경할 수 있습니다.The following BindingFlags modifier flags can be used to change how the search works:

  • BindingFlags.DeclaredOnly 에 선언 된 속성만 검색할는 Type, 상속 된 속성이 없습니다.BindingFlags.DeclaredOnly to search only the properties declared on the Type, not properties that were simply inherited.

자세한 내용은 System.Reflection.BindingFlags를 참조하세요.See System.Reflection.BindingFlags for more information.

GetProperties 메서드 반환 하지 않습니다 속성을 특정 순서로 같은 알파벳 또는 선언 순서입니다.The GetProperties method does not return properties in a particular order, such as alphabetical or declaration order. 코드 영향을 받지 않아야 속성 반환 되는 순서 때문에 순서에 따라 달라 지는 합니다.Your code must not depend on the order in which properties are returned, because that order varies.

하는 경우 현재 Type 이 메서드는 반환 생성된 된 제네릭 형식을 나타내는 PropertyInfo 따라 적절 한 형식 인수로 대체 형식 매개 변수를 사용 하 여 개체입니다.If the current Type represents a constructed generic type, this method returns the PropertyInfo objects with the type parameters replaced by the appropriate type arguments.

하는 경우 현재 Type 형식 매개 변수는 제네릭 형식 또는 제네릭 메서드 정의에서이 메서드는 클래스 제약 조건의 속성을 검색 합니다.If the current Type represents a type parameter in the definition of a generic type or generic method, this method searches the properties of the class constraint.

추가 정보

적용 대상