创建属性树的函数？

Question

我正在尝试为对象创建一个属性列表。我可以很好地为基本对象创建一个列表，但是如果我遇到类型对象 A 包含对象 B 类型的属性的情况，该属性包含对象 A 类型的属性......好吧..然后我得到无限递归。 我所做的是向我的所有对象添加一个名为“RecursivePropertyList”的静态属性，它是每个具有递归的属性的List<string>。

所以，例如： 我有一个Person 类，其属性名为Vendor，类型为Vendor。 Vendor 类有一个名为 People 的属性，其类型为 List<Person>。

在Person 类中，我将RecursivePropertyList 的值设置为myList.Add("Vendor.People")。 在Vendor类中，我将RecursivePropertyList的值设置为myList.Add("People.Vendor")。

然后在创建属性列表的函数中，我检查当前的 objectname.propertyName 是否在 RecursivePropertyList 中，如果是，我不会将其添加到我的属性列表中，也不会向下钻取进入它以获取其属性。

这在上述情况下效果很好。

但是，当我遇到以下情况时，它开始失败： 具有List<ApplicationFunction_Application> 类型属性的Application 类。 具有List<ApplicationFunction_Application> 类型属性的ApplicationFunction 类。 一个ApplicationFunction_Application 类，它有两个属性，一个是Application 类型，另一个是ApplicationFunction 类型。 ApplicationFunction_Application 类的目的是定义Application 和ApplicationFunction 之间的多对多关系。

在Application 的RecursivePropertyList 中我放了：

myList.Add("ApplicationFunctions.Application");

在ApplicationFunction 的RecursivePropertyList 中我放了：

myList.Add("Applications.ApplicationFunction");

在ApplicationFunction_Application 的RecursivePropertyList 中我放了：

myList.Add("ApplicationFunction.Applications");

myList.Add("Application.ApplicationFunctions");

但是，我的脚本一直在循环，永远不会停止。

这里是函数使用的代码：

首先，开始整个事情的被调用函数：

public static EquatableList<PropertyState> FillPropertyStateList(System.Type myObjectType, ref EquatableList<PropertyState> myPropertyStateList)
        {
            List<string> myRecursivePropertyList = FillDefaultRecursivePropertyList(myObjectType);
            return FillPropertyStateList(myObjectType, ref myPropertyStateList, string.Empty, string.Empty, myRecursivePropertyList);
        }

然后是完成工作并递归调用自身以生成所有子对象的属性列表的函数。

public static EquatableList<PropertyState> FillPropertyStateList(System.Type myObjectType, ref EquatableList<PropertyState> myPropertyStateList, string myParentPrefix, string myObjectName, List<string> myRecursivePropertyList)
        {
            if (myPropertyStateList == null)
            {
                myPropertyStateList = new EquatableList<PropertyState>();
            }
            if (string.IsNullOrEmpty(myParentPrefix))
            {
                myParentPrefix = string.Empty;
            }
            else if (!myParentPrefix.EndsWith("."))
            {
                myParentPrefix = myParentPrefix + ".";
            }
            if (string.IsNullOrEmpty(myObjectName))
            {
                myObjectName = string.Empty;
            }
            else
            {
                myObjectName = myObjectName + ".";
            }

            foreach (System.Reflection.PropertyInfo info in myObjectType.GetProperties())
            {
                if (info.PropertyType.BaseType == typeof(BOBase))
                {
                    if (!myRecursivePropertyList.Exists(delegate(string x) { return x.Equals(myObjectName + info.Name); }))
                    {
                        myPropertyStateList.Add(new PropertyState(myParentPrefix + myObjectName + info.Name, true, PropertyType.BOBase));
                        List<string> myChildRecursivePropertyList = FillDefaultRecursivePropertyList(info.PropertyType);
                        myChildRecursivePropertyList.AddRange(myRecursivePropertyList.FindAll(delegate(string x) { return Regex.IsMatch(x, info.Name + ".*"); }));
                        FillPropertyStateList(info.PropertyType, ref myPropertyStateList, myParentPrefix + myObjectName, info.Name, myChildRecursivePropertyList);
                    }
                }
                else if (info.PropertyType.IsGenericType
                    && (info.PropertyType.BaseType.GetGenericTypeDefinition() == typeof(List<>) || info.PropertyType.BaseType.GetGenericTypeDefinition() == typeof(Library.EquatableList<>)))
                {
                    if (!myRecursivePropertyList.Exists(delegate(string x) { return x.Equals(myObjectName + info.Name); }))
                    {
                        myPropertyStateList.Add(new PropertyState(myParentPrefix + myObjectName + info.Name, true, PropertyType.BOBaseCollection));
                        List<string> myChildRecursivePropertyList = FillDefaultRecursivePropertyList(info.PropertyType.BaseType.GetGenericArguments()[0]);
                        myChildRecursivePropertyList.AddRange(myRecursivePropertyList.FindAll(delegate(string x) { return Regex.IsMatch(x, info.Name + ".*"); }));
                        FillPropertyStateList(info.PropertyType.BaseType.GetGenericArguments()[0], ref myPropertyStateList, myParentPrefix + myObjectName, info.Name, myChildRecursivePropertyList);
                    }
                }
                else
                {
                    myPropertyStateList.Add(new PropertyState(myParentPrefix + myObjectName + info.Name, true, PropertyType.Standard));
                }

            }
            return myPropertyStateList;
        }

获取默认递归属性列表的辅助函数：

private static List<string> FillDefaultRecursivePropertyList(System.Type myObjectType)
    {
        List<string> myRecursivePropertyList = new List<string>();
        if (myObjectType.BaseType == typeof(BOBase))
        {
            System.Reflection.PropertyInfo pi = myObjectType.GetProperty("RecursivePropertyList", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
            if (pi != null)
            {
                myRecursivePropertyList = (List<string>)pi.GetValue(null, null);
            }
        }
        return myRecursivePropertyList;
    }

关于我做错了什么有什么想法吗？

Answer 1

我还没有深入研究代码，但是您是否考虑过使用 Attribute 来表示哪些属性是递归的？这可能会让您不必担心必须维护单独的静态属性列表。似乎列表方法可能容易出现潜在的困难同步问题。

ETA：示例代码：

如果我理解正确，这样的事情可能适用于属性级属性。它包含一个辅助方法，用于从给定类型中检索标记为递归的属性，这在构建树时可能会有所帮助。

[AttributeUsage(AttributeTargets.Property)]
public class RecursivePropertyAttribute
    : Attribute
{
    private static Dictionary<Type, List<PropertyInfo>> _Cache = new Dictionary<Type, List<PropertyInfo>>();

    public IEnumerable<PropertyInfo> GetRecursiveProperties(Type t)
    {
        // Check the cache for the type
        if (!_Cache.ContainsKey(t))
        { 
            // Create the entry
            _Cache.Add(t, new List<PropertyInfo>());

            // Add properties that have the attribute
            foreach (PropertyInfo p in t.GetProperties())
            {
                if (p.IsDefined(typeof(RecursivePropertyAttribute), true))
                    _Cache[t].Add(p);
            }
        }

        return _Cache[t];
    }
}