反射：递归地搜索对象的字符串值，然后报告路径

Question

我正在尝试在复杂对象中寻找值。有谁知道是否有一个辅助类已经可以做到这一点？

希望能够搜索一个对象，同时观察无限循环保护以找到包含“foo”的 tostring 值，然后返回在其中找到 foo 的属性路径。或者在其中找到 foo 的路径数组。

所以如果在我自己进行此操作之前，有人已经有了方便的现有代码；我将不胜感激。

Answer 1

关键是您希望在递归搜索要查找的值时保留当前属性的 Stack 以及访问对象的 HashSet 并跳过它们。您还需要小心异常处理，以便中间的异常不会弄乱堆栈。

    public static string[] FindPathToProperty(object item, string propertyValueToFind)
    {
        var pathToProperty = new Stack<string>();
        var visitedObjects = new HashSet<object> {item};

        FindPathToProperty(item, propertyValueToFind, pathToProperty, visitedObjects);

        var finalPath = pathToProperty.ToArray();
        Array.Reverse(finalPath);
        return finalPath;
    }

    private static bool FindPathToProperty(object item, string propertyValueToFind, Stack<string> pathToProperty, HashSet<object> visitedObjects)
    {
        foreach (var property in item.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
        {
            try
            {
                var value = property.GetValue(item, null);

                if (visitedObjects.Contains(value))
                {
                    continue;                       
                }

                visitedObjects.Add(value);

                pathToProperty.Push(property.Name);

                bool found = false;
                try
                {
                    found = propertyValueToFind.Equals(value) ||
                            FindPathToProperty(value, propertyValueToFind, pathToProperty, visitedObjects);
                }
                finally
                {
                    if (!found)
                    {
                        pathToProperty.Pop();
                    }
                }
                if (found)
                {
                    return true;
                }
            }
            catch
            {
                continue;
            }
        }

        return false;
    }

    public static void Test()
    {
        Test(new { X = "find" }, "X");
        Test(new { X = "no", Y = "find" }, "Y");
        Test(new { A = new { X = "no", Y = "find" } }, "A.Y");
    }

    private static void Test(object item, string expected)
    {
        string actual = string.Join(".", FindPathToProperty(item, "find"));
        Console.WriteLine("{0} : {1}\r\n      {2}",
                          actual == expected ? "ok " : "BAD",
                          expected,
                          actual);
    }