我怎样才能捕获递归代码上的 stackoverflow 异常的根源

Question

我有以下递归代码，并且收到堆栈溢出异常。我无法找出根本原因，因为一旦出现异常，我就无法在 Visual Studio 中获得完整的调用堆栈。

这个想法是，组织团队可以合并成更大的“主要”团队。

有没有人发现下面这段代码中的缺陷可能是罪魁祸首？

    private Unit GetUnit(Unit organisationalUnit)
    {
        if (organisationalUnit.IsMainUnit)
        {
            return organisationalUnit;                
        }

        if (organisationalUnit.Parent == null)
            return null;

        return GetUnit(organisationalUnit.Parent);
    }

Answer 1

1. 您可能有一个单元是其自己的父单元，或者除非您可能有一个父单元循环（例如 ABCA）。也就是说，问题可能出在数据上，而不是代码本身。
2. 验证 IsMainUnit 和 Parent 的 getter 不会调用 GetUnit。

Answer 2

根总是有 Parent == null 吗？
尝试检查

if (organisationalUnit.Parent == organisationalUnit)
    return null;

？

Answer 3

你可以尝试这个来更好地调试它。它不会影响您的生产代码。

using System.Diagnostics;

private Unit GetUnit(Unit organisationalUnit, int depth)
{
    debug.assert(depth < 10, "Reached an unexpected high recursion depth"); 

    if (organisationalUnit.IsMainUnit)
    {
        return organisationalUnit;                
    }

    if (organisationalUnit.Parent == null)
        return null;

    return GetUnit(organisationalUnit.Parent, depth + 1);
}

private Unit GetUnit(Unit organisationalUnit)
{
    return GetUnit(organisationalUnit.Parent, 0);
}

再想一想...

很可能您在某个地方有循环引用。

A.parent = B;
B.parent = C;
C.parent = A;

您可以尝试传递一组以前访问过的节点并检查您之前是否访问过该节点。

递归的问题在于，您必须确保它会结束，而未经检查的循环引用是一种不会结束的情况。

Answer 4

有什么理由不将其重新编码为迭代吗？这样，就可以更轻松地对组织树的深度设置硬性限制，以捕获不良（循环）数据。

递归很有趣，尾部优化甚至可以使其变得高效，但在这里，它看起来就像是解决小问题的大锤子。

Answer 5

我对视觉工作室了解不多。
但你应该检查是否复发。例如

private Unit GetUnit(Unit organisationalUnit)
{
      GetUnit(organisationalUnit, new vector());
}

private Unit GetUnit(Unit organisationalUnit,vector x)
{
    if (organisationalUnit.IsMainUnit)
    {
        return organisationalUnit;                
    }

    if (organisationalUnit.Parent == null)
        return null;

    x.add(this);
    if(x.contains(organisationalUnit.Parent)) throw new Exception("recurrent parent");
    return GetUnit(organisationalUnit.Parent,x);
}

Answer 6

一种方法是减少堆栈大小，这样它就可以尽早崩溃。

您可以通过在程序开始时浪费帧来实现这一点，即获得如下堆栈跟踪：f_n，f_（n-1），...，f_1，waste，waste，.. .,waste，如（在 C 伪代码中）

int wasted = 1;

浪费（int n，无效（* f）（））
{ if (n > 0) 浪费(n - 1,f) else f ();
浪费+=1； }

main () { 浪费(N,mainprime);其中

mainprime 是旧的 main，N 足够大以达到您想要的 f_1。

Answer 7

代码看起来不错，也许单元树中有一些闭环？尝试添加带有organizationalUnit.GetHashCode值的跟踪行，跟踪输出不受限制，可以帮助检测堆栈溢出原因。

Answer 8

我想你可以通过重写这个来避免递归，

while(organisationalUnit!=null && !organisationalUnit.IsMainUnit)
  organisationalUnit=organisationalUnit.Parent;

return organisationalUnit;

希望有帮助。

编辑：我刚刚意识到，如果你有某种循环依赖，这仍然会失败。

Answer 9

您的图表中可能有一个循环（请注意，它不是一棵树）。

您可以使用这样的代码来检测它：

private Unit GetUnit(Unit organisationalUnit) {
  return GetUnit(organisationalUnit, new HashSet<Unit>());
}

private Unit GetUnit(Unit organisationalUnit, HashSet<Unit> visited) {
  if (visited.Contains(organisationalUnit)) {
    throw new Exception("Cycle detected!"); // or just return null if you prefer
  }
  visited.Add(organisationalUnit);

  if (organisationalUnit.IsMainUnit) {
    return organisationalUnit;
  }

  if (organisationalUnit.Parent == null)
    return null;

  return GetUnit(organisationalUnit.Parent, visited);
}