리플렉션을 사용하여 값이있는 기본 속성 및 필드를 가져 와서 클래스 계층 구조를 정리하는 방법은 무엇입니까?

Question

리플렉션을 사용하여 기본 클래스 속성과 입력란을 얻는 방법은 없으므로 한 번에 한 수준 씩 클래스 계층 구조를 작동시킬 수 있습니까? 목표는 디버거 지역 창과 마찬가지로 모든 클래스 인스턴스의 값으로 특성 및 필드를 표시하는 트리 표시를 작성하는 것입니다. 나는 "기본"트리 노드가 확장 될 때 값이있는 속성 및 필드가 필요할 때 표시 될 수 있도록 각 기본 인스턴스를 게으른로드 할 수있는 기능이 필요합니다.

Answer 1

다음은 사용자가 지정한 것을 수행하는 간단한 예입니다. 나는 당신이 당신의 특정한 필요에 맞게 수정할 수 있거나 최소한 올바른 방향으로 당신을 가리킬 것이라고 확신합니다.

이 예제를 복사하여 콘솔 응용 프로그램에 붙여 넣고 몇 가지 중단 점을 설정하여 작동 방식을 확인할 수 있습니다. VB.Net

에서

코드

Module Module1 

    Private Class ClassOne 
     Private _One As String 
     Private _Two As Integer 
     Private _three As Double 

     Public Property One() As String 
      Get 
       Return _One 
      End Get 
      Set(ByVal value As String) 
       _One = value 
      End Set 
     End Property 

     Public Property Two() As Integer 
      Get 
       Return _Two 
      End Get 
      Set(ByVal value As Integer) 
       _Two = value 
      End Set 
     End Property 

     Public Property Three() As Double 
      Get 
       Return _three 
      End Get 
      Set(ByVal value As Double) 
       _three = value 
      End Set 
     End Property 
    End Class 

    Private Class ClassAlpha 
     Inherits ClassOne 

     Private _Alpha As String 
     Private _Beta As Long 

     Public Property Alpha() As String 
      Get 
       Return _Alpha 
      End Get 
      Set(ByVal value As String) 
       _Alpha = value 
      End Set 
     End Property 

     Public Property Beta() As Long 
      Get 
       Return _Beta 
      End Get 
      Set(ByVal value As Long) 
       _Beta = value 
      End Set 
     End Property 
    End Class 

    Private Class ClassColor 
     Inherits ClassAlpha 

     Private _Red As String 
     Private _Blue As Long 

     Public Property Red() As String 
      Get 
       Return _Red 
      End Get 
      Set(ByVal value As String) 
       _Red = value 
      End Set 
     End Property 

     Public Property Blue() As Long 
      Get 
       Return _Blue 
      End Get 
      Set(ByVal value As Long) 
       _Blue = value 
      End Set 
     End Property 
    End Class 

    Sub Main() 
     Dim o As New ClassColor() 
     o.Red = "The Color Red" 
     o.Blue = 14 
     o.Alpha = "The First" 
     o.Beta = 202 
     o.One = "One" 
     o.Two = 2 
     o.Three = 3.1415927 

     Dim helper As New ReflectionHelper(o) 

     Dim list1 = helper.ReflectProperties(helper.BaseClasses(0), o) 
     Dim list2 = helper.ReflectProperties(helper.BaseClasses(1), o) 
     Dim list3 = helper.ReflectProperties(helper.BaseClasses(2), o) 
    End Sub 

End Module 

Public Class ReflectionHelper 
    Private _SourceClass As Object 
    Private _BaseClasses As New List(Of Type) 

    Public Sub New() 
    End Sub 

    Public Sub New(source As Object) 
     _SourceClass = source 

     Dim t As Type = _SourceClass.GetType() 
     While (t IsNot Nothing) 
      _BaseClasses.Add(t) 
      t = t.BaseType 
     End While 
    End Sub 

    Public ReadOnly Property BaseClasses As List(Of Type) 
     Get 
      Return _BaseClasses 
     End Get 
    End Property 

    Public Function ReflectProperties(ByVal baseClass As Type, 
             ByVal instance As Object) As List(Of ReflectionHelperProperties) 
     Dim result As New List(Of ReflectionHelperProperties) 
     For Each prop In baseClass.GetProperties(Reflection.BindingFlags.DeclaredOnly Or 
               Reflection.BindingFlags.GetProperty Or 
               Reflection.BindingFlags.Instance Or 
               Reflection.BindingFlags.Public) 
      result.Add(New ReflectionHelperProperties() With {.Name = prop.Name, .InstanceValue = prop.GetValue(instance, Nothing)}) 
     Next 
     Return result 
    End Function 
End Class 

Public Class ReflectionHelperProperties 
    Public Name As String 
    Public InstanceValue As Object 
End Class 

---

예제에 대한 C#에서 동일한 코드가

using System; 
using System.Collections.Generic; 

namespace ConsoleApplication23 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      // create the highest level type 
      ClassColor o = new ClassColor(); 
      o.Red = "The Color Red"; 
      o.Blue = 14; 
      o.Alpha = "The First"; 
      o.Beta = 202; 
      o.One = "One"; 
      o.Two = 2; 
      o.Three = 3.1415927; 

      ReflectionHelper helper = new ReflectionHelper(o); 

      List<ReflectionHelperProperties> list1 = helper.ReflectProperties(helper.BaseClasses[0], o); 
      List<ReflectionHelperProperties> list2 = helper.ReflectProperties(helper.BaseClasses[1], o); 
      List<ReflectionHelperProperties> list3 = helper.ReflectProperties(helper.BaseClasses[2], o); 
     } 
    } 
} 

public class ClassOne 
{ 
    private string _One; 
    private int _Two; 

    private double _three; 
    public string One { 
     get { return _One; } 
     set { _One = value; } 
    } 

    public int Two { 
     get { return _Two; } 
     set { _Two = value; } 
    } 

    public double Three { 
     get { return _three; } 
     set { _three = value; } 
    } 
} 

public class ClassAlpha : ClassOne 
{  
    private string _Alpha;  
    private long _Beta; 

    public string Alpha { 
     get { return _Alpha; } 
     set { _Alpha = value; } 
    } 

    public long Beta { 
     get { return _Beta; } 
     set { _Beta = value; } 
    } 
} 

public class ClassColor : ClassAlpha 
{  
    private string _Red;  
    private long _Blue; 

    public string Red { 
     get { return _Red; } 
     set { _Red = value; } 
    } 

    public long Blue { 
     get { return _Blue; } 
     set { _Blue = value; } 
    } 
} 

public class ReflectionHelper 
{ 
    private List<Type> _BaseClasses = new List<Type>(); 
    public ReflectionHelper() 
    { 
    } 

    public ReflectionHelper(object source) 
    { 
     // build base types list 
     Type t = source.GetType(); 
     while ((t != null)) { 
      _BaseClasses.Add(t); 
      t = t.BaseType; 
     } 
    } 

    public List<Type> BaseClasses { 
     get { return _BaseClasses; } 
    } 

    public List<ReflectionHelperProperties> ReflectProperties(Type baseClass, object instance) 
    { 
     List<ReflectionHelperProperties> result = new List<ReflectionHelperProperties>(); 
     foreach (System.Reflection.PropertyInfo p in baseClass.GetProperties(System.Reflection.BindingFlags.DeclaredOnly | 
                      System.Reflection.BindingFlags.GetProperty | 
                      System.Reflection.BindingFlags.Instance | 
                      System.Reflection.BindingFlags.Public)) { 
      result.Add(new ReflectionHelperProperties { 
       Name = p.Name, 
       InstanceValue = p.GetValue(instance, null) 
      }); 
     } 
     return result; 
    } 
} 

public class ReflectionHelperProperties 
{ 
    public string Name; 
    public object InstanceValue; 
}