反射，循环抛出类层次结构并按类型查找字段

Question

我有一个大层次结构类，我想循环它的所有属性和子属性等。

示例

public class RootClass
{
   // properties ..
   List<Item> FirstItemsList { get; set;}
   List<Item> SecondItemsList { get; set;}
   SubClass SubClass { get; set;}
}
public class SubClass
{
   // properties ..
   List<Item> ThirdItemsList { get; set;}
}
public class Item
{
   //properties 
}

我想要一个函数，该函数将返回找到的所有项目类型的列表 即

public IList<Item> GetAllItemsInClass(RootClass entity);

谢谢

Answer 1

如果您需要在一般情况下（任何类层次结构）都可以工作的东西，那么您可以执行以下操作：

您将需要一个递归算法（函数）。该算法将循环成员，将它们的类型添加到列表中（如果尚未添加），然后返回该列表，与刚刚添加到列表中的类型的成员类型相结合 - 在这里您进行递归称呼。终止条件为：

1. 成员的类型是原语（要检查这一点，请使用 Type.IsPrimitive）。
2. 所反射的类型是在另一个程序集中定义的。您可以使用Type.Assembly检查定义的程序集。

如果您需要更简单的东西，请使用上面的技术，但只需在循环中使用 if 语句。

让我知道这是否是您想要的，然后我会在有更多时间时为您发布代码示例。

更新：以下是显示代码示例如何处理类型并递归获取其中包含的所有类型。您可以这样调用它： List typesHere = GetTypes(myObject.GetType())

    public static List<Type> GetTypes(Type t)
    {
        List<Type> list = new List<Type>();
        if (t.IsPrimitive)
        {
            if (!list.Contains(t))
                list.Add(t);
            return list;
        }
        else if (!t.Assembly.Equals(System.Reflection.Assembly.GetExecutingAssembly()))
        {
            //if the type is defined in another assembly then we will check its
            //generic parameters. This handles the List<Item> case.
            var genArgs = t.GetGenericArguments();
            if (genArgs != null)
                foreach (Type genericArgumentType in genArgs)
                {
                    if(!list.Contains(genericArgumentType))
                        list.AddRange(GetTypes(genericArgumentType));
                }
            return list;
        }
        else
        {
            //get types of props and gen args
            var types = t.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Select(pi => pi.PropertyType).ToList();
            types.AddRange(t.GetGenericArguments());
            foreach (System.Type innerType in types)
            {
                //get the object represented by the property to traverse the types in it.
                if (!list.Contains(innerType))
                    list.Add(innerType);
                else continue; //because the type has been already added and as thus its child types also has been already added.

                var innerInnerTypes = GetTypes(innerType);
                //add the types filtering duplicates
                foreach (Type t1 in innerInnerTypes) //list.AddRange(innerTypes); //without filtering duplicates.
                    if (!list.Contains(t1))
                        list.Add(t1);
            }
            return list;
        }
    }

因此，当我在您在原始帖子中发布的类上运行此操作时（具有如下两个基本属性的项目），我得到了以下列表：

GetTypes(typeof(List<Item>))
Count = 3
    [0]: {Name = "Item" FullName = "AssemblyNameXYZ.Item"}
    [1]: {Name = "String" FullName = "System.String"}
    [2]: {Name = "Int32" FullName = "System.Int32"}

GetTypes(typeof(Item))
Count = 2
    [0]: {Name = "String" FullName = "System.String"}
    [1]: {Name = "Int32" FullName = "System.Int32"}

Reflection.GetTypes(typeof(RootClass))
Count = 5
    [0]: {Name = "List`1" FullName = "System.Collections.Generic.List`1[[AssemblyNameXYZ.Item, AssemblyNameXYZ, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]"}
    [1]: {Name = "Item" FullName = "AssemblyNameXYZ.Item"}
    [2]: {Name = "String" FullName = "System.String"}
    [3]: {Name = "Int32" FullName = "System.Int32"}
    [4]: {Name = "SubClass" FullName = "AssemblyNameXYZ.SubClass"}

我没有进行全面的测试，但这至少应该为您指明正确的方向。有趣的问题。我很高兴回答。