Question

I’m attempting to create a recursive routine that will retrieve PropertyInfos for all members under a specified object (in .NET 3.5). Everything for immediate members is working, but it needs to parse nested classes as well (and their nested classes, etc).

I do not understand how to handle the section that parses nested classes. How would you write this part of the code?

public class ObjectWalkerEntity
{
    public object Value { get; set; }
    public PropertyInfo PropertyInfo { get; set; }
}


public static class ObjectWalker
{
    // This will be the returned object
    static List<ObjectWalkerEntity> objectList = new List<ObjectWalkerEntity>();

    public static List<ObjectWalkerEntity> Walk(object o)
    {
        objectList.Clear();
        processObject(o);
        return objectList;
    }

    private static void processObject(object o)
    {
        if (o == null)
        {
            return;
        }

        Type t = o.GetType();

        foreach (PropertyInfo pi in t.GetProperties())
        {
            if (isGeneric(pi.PropertyType))
            {
                // Add generic object
                ObjectWalkerEntity obj = new ObjectWalkerEntity();
                obj.PropertyInfo = pi;
                obj.Value = pi.GetValue(o, null);
                objectList.Add(obj);
            }
            else
            {
                ////// TODO: Find a way to parse the members of the subclass...
                // Parse each member of the non-generic object
                foreach (Object item in pi.PropertyType)
                {
                    processObject(item);
                }
            }
        }

        return;
    }

    private static bool isGeneric(Type type)
    {
        return
            Extensions.IsSubclassOfRawGeneric(type, typeof(bool)) ||
            Extensions.IsSubclassOfRawGeneric(type, typeof(string)) ||
            Extensions.IsSubclassOfRawGeneric(type, typeof(int)) ||
            Extensions.IsSubclassOfRawGeneric(type, typeof(UInt16)) ||
            Extensions.IsSubclassOfRawGeneric(type, typeof(UInt32)) ||
            Extensions.IsSubclassOfRawGeneric(type, typeof(UInt64)) ||
            Extensions.IsSubclassOfRawGeneric(type, typeof(DateTime));
    }

Edit: I’ve used some of Harlam’s suggestions, and came up with a working solution. This handles both nested classes and lists.

I’ve replaced my previous loop through the propertyinfo with the following

foreach (PropertyInfo pi in t.GetProperties())
{
    if (isGeneric(pi.PropertyType))
    {
        // Add generic object
        ObjectWalkerEntity obj = new ObjectWalkerEntity();
        obj.PropertyInfo = pi;
        obj.Value = pi.GetValue(o, null);
        objectList.Add(obj);
    }
    else if (isList(pi.PropertyType))
    {
        // Parse the list
        var list = (IList)pi.GetValue(o, null);
        foreach (object item in list)
        {
            processObject(item);
        }
    }
    else
    {
        // Parse each member of the non-generic object
        object value = pi.GetValue(o, null);
        processObject(value);
    }
}

I’ve also added a new check to see if something is a list.

private static bool isList(Type type)
{
    return
        IsSubclassOfRawGeneric(type, typeof(List<>));
}

Thanks for the help!

Answer 1

I think this will work for you. The idea here is to return an enumerable object from each call to ProcessObject() and then roll those calls up into the callers List<ObjectWalkerEntity>.

public class ObjectWalkerEntity
{
   public object Value { get; set; }
   public PropertyInfo PropertyInfo { get; set; }
}

public static class ObjectWalker
{
   public static List<ObjectWalkerEntity> Walk(object o)
   {
      return ProcessObject(o).ToList();
   }

   private static IEnumerable<ObjectWalkerEntity> ProcessObject(object o)
   {
      if (o == null)
      {
         // nothing here, just return an empty enumerable object
         return new ObjectWalkerEntity[0];
      }

      // create the list to hold values found in this object
      var objectList = new List<ObjectWalkerEntity>();

      Type t = o.GetType();
      foreach (PropertyInfo pi in t.GetProperties())
      {
         if (IsGeneric(pi.PropertyType))
         {
            // Add generic object
            var obj = new ObjectWalkerEntity();
            obj.PropertyInfo = pi;
            obj.Value = pi.GetValue(o, null);
            objectList.Add(obj);
         }
         else
         {
            // not generic, get the property value and make the recursive call
            object value = pi.GetValue(o, null);
            // all values returned from the recursive call get 
            // rolled up into the list created in this call.
            objectList.AddRange(ProcessObject(value));
         }
      } 

      return objectList.AsReadOnly();
   }

   private static bool IsGeneric(Type type)
   {
      return
          IsSubclassOfRawGeneric(type, typeof(bool)) ||
          IsSubclassOfRawGeneric(type, typeof(string)) ||
          IsSubclassOfRawGeneric(type, typeof(int)) ||
          IsSubclassOfRawGeneric(type, typeof(UInt16)) ||
          IsSubclassOfRawGeneric(type, typeof(UInt32)) ||
          IsSubclassOfRawGeneric(type, typeof(UInt64)) ||
          IsSubclassOfRawGeneric(type, typeof(DateTime));
   }

   private static bool IsSubclassOfRawGeneric(Type generic, Type toCheck)
   {
      while (toCheck != typeof(object))
      {
         var cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
         if (generic == cur)
         {
            return true;
         }
         toCheck = toCheck.BaseType;
      }
      return false;
   }
}