Reflection - Iterating Class with properties that are classes

Question

I need to iterate through the entire structure of a class. I'm interrogating the objects sent into my WCF methods and I presently have an overload of ToString() in each of my classes that list all properties and their values. This works; but is hardcoded and requires updates each time we add properties to the class.

Current solution is VB but next version will be C# - hence both tags.

The class may be comprised of primitive types only or the class may be comprised of other objects. Iterating through a simple class is not a problem.

I am having trouble identifying when a property is actually another class. So, given the example below, I can iterate through Appointment and Patient and dump the values of each of their properties.

I am stuck trying to iterate through PatientAppointment. I've scoured MSDN and SO, tried countless properties within the type, etc. to no avail.

Public Class PatientAppointment
    Public Property Pat As Patient
    Public Property Appt As Appointment
End Class

Public Class Appointment
    Public Property ApptProp1 As String
    Public Property ApptProp2 As Integer
End Class

Public Class Patient
    Public Property PatProp1 As String
    Public Property PatProp2 As Integer
End Class

Answer 1

It sounds like maybe you are looking for a way to identify your Types with some level of certainty. One way might be to use a custom attribute which will be easy to find and filter using Reflection.

Public Class RealMcCoy
    Inherits Attribute

    Public Property IsReal As Boolean 

    Public Sub New(b as Boolean)
      IsReal = b
    End Sub
End Class

<RealMcCoy(True)>      
Public Class Patient
    ...
End Class

<RealMcCoy(True)>   
Public Class Appointment
   ...
End Class

Now when iterating properties, check if it is the RealMcCoy to see if it is one you want/need to drill into. Since the Attribute will be on the Type, there is an extra step to get each property's Type and poll that

    Dim props As PropertyInfo() = myFoo.GetType.GetProperties
    Dim pt As Type

    For Each pi As PropertyInfo In props
        pt = pi.PropertyType         ' get the property type

        Dim attr() As RealMcCoy =
                DirectCast(pt.GetCustomAttributes(GetType(RealMcCoy), True), RealMcCoy())
        If attr.Length > 0 Then
            ' bingo, baby...optional extra test:
            If attr(0).IsReal Then
                Console.Beep()
            End If
        Else
            ' skip this prop - its not a real mccoy
        End If
    Next
End Sub

It breaks if you add a Type and dont add the Attribute, but it is less breakable than having to update each Types for their constituent properties. A fake interface would be easier to query, but has the same drawback.

I am not sure I understand the issue of "gaming" things - are you afraid that some other Types will get picked up? Attributes would be hard to "game" since they are compiled into the assembly, still the above could be used to return a GUID (maybe one attached to the assembly?) rather than bool to provide some reassurance.

Absolute certainty will be hard to come by.

---

The RealMcCoy attribute would probably not be applied to your top level types (PatientAppointment) just the types (classes) which will be used as properties in other types. The object being a way to identify these easily.

Depending on how it is used, a dictionary or hashtable of TypeName-PropertyName pairs already identified as RealMcCoys might be useful so the whole Reflection process can be short circuited. Rather than adding on the fly, you might be able to build the list in its entirety up front as shown in this answer - see the RangeManager.BuildPropMap procedure.

I am not so sure about the inheritance approach since you might want to actually use inheritance somewhere. An interface might work better: initially, its mere existence could be the trigger at the start, but could also be used to provide a service.

---

Simple test case:

' B and C classes are not tagged
Friend Class FooBar
    Public Property Prop1 As PropA
    Public Property Prop2 As PropB
    Public Property Prop3 As PropC
    Public Property Prop4 As PropD
    Public Property Prop5 As PropE
End Class

Add a line to the for loop:

Dim f As New FooBar
' use instance:
Dim props As PropertyInfo() = f.GetType.GetProperties
Dim pt As Type

For Each pi As PropertyInfo In props
    pt = pi.PropertyType

    Dim attr() As RealMcCoy =
            DirectCast(pt.GetCustomAttributes(GetType(RealMcCoy), True), RealMcCoy())

    Console.WriteLine("Prop Name: {0},  prop type: {1}, IsRealMcCoy? {2}",
            pi.Name, pt.Name, If(attr.Length > 0, "YES!", "no"))
Next

Output:

Prop Name: Prop1  prop type: PropA IsRealMcCoy? YES!  
Prop Name: Prop2  prop type: PropB IsRealMcCoy? no  
Prop Name: Prop3  prop type: PropC IsRealMcCoy? no 
Prop Name: Prop4  prop type: PropD IsRealMcCoy? YES! 
Prop Name: Prop5  prop type: PropE IsRealMcCoy? YES!

Answer 2

Many thanks to Plutonix! Here is my final function. If my answer supercedes Plutonix's answer then I'll need to adjust this as he fully deserves credit for getting me to this point.

I've tested it to 8 levels of nested types. Rudimentary exception handling due to this being a prototype only.

    Function IterateClass(ByVal o As Object, ByVal topLevelFlag As Boolean, ByVal indentLevel As Integer) As String

    Dim retVal As New StringBuilder

    Try

        '' Iterate top level of supplied type ''
        '' Query each property for custom attribute ADMICompositeClassAttribute ''
        '' If exists and set to true then we're dealing with a base class that we need to break down recursively ''
        '' If not then immediately dump this type's properties ''


        '' Build header of output ''
        If topLevelFlag Then

            '' <<EXCERPTED>> ''

        End If


        '' We start walking through the hierarchy here, no matter how much we recurse we still need to do this each time ''
        Dim properties_info As PropertyInfo()
        properties_info = o.GetType().GetProperties()

        For Each p As PropertyInfo In properties_info
            Dim propName As String = p.Name
            Dim propTypeList As List(Of String) = p.PropertyType.ToString().Split(".").ToList()
            Dim propType As String = propTypeList(propTypeList.Count - 1).Replace("[", "").Replace("]", "")
            Dim pValue As Object = Nothing

            '' We check this type for custom attribute ADMICompositeClassAttribute ''
            '' Is this type a composite? ''
            Dim oAttr() As ADMICompositeClassAttribute = p.PropertyType.GetCustomAttributes(GetType(ADMICompositeClassAttribute), False)
            Dim indentString As String = String.Concat(Enumerable.Repeat(" ", indentLevel))
            If oAttr.Length > 0 AndAlso oAttr(0).IsComposite Then

                '' This is a nested type, recurse it ''
                Dim dynType As Type = p.PropertyType()
                Dim dynObj As Object = Activator.CreateInstance(dynType)

                '' <<EXCERPTED ''

            Else

                pValue = p.GetValue(o, Nothing)

            End If

        Next


    Catch ex As Exception
        retVal.AppendLine(ex.ToString())

    End Try
    Return retVal.ToString()


End Function