.NET 4.8 中的异步等待递归导致 StackoverflowException（不在 .Net Core 3.1 中！）

Question

为什么下面的代码在.Net4.8中会导致StackOverflowException，只有17个深度的递归？然而，这在 NetCore 3.1 中不会发生（我可以将计数设置为 10_000，它仍然有效）

class Program
{
  static async Task Main(string[] args)
  {
    try
    {
      await TestAsync(17);
    }
    catch(Exception e)
    {
      Console.WriteLine("Exception caught: " + e);
    }
  }

  static async Task TestAsync(int count)
  {
    await Task.Run(() =>
    {
      if (count <= 0)
        throw new Exception("ex");
    });

    Console.WriteLine(count);
    await TestAsync2(count);
  }

  static async Task TestAsync2(int count) => await TestAsync3(count);
  static async Task TestAsync3(int count) => await TestAsync4(count);
  static async Task TestAsync4(int count) => await TestAsync5(count);
  static async Task TestAsync5(int count) => await TestAsync6(count);
  static async Task TestAsync6(int count) => await TestAsync(count - 1);
}

这是 .Net 4.8 中的已知错误吗？我会在这样的函数中排除超过 17 级的递归......这是否实际上意味着不建议使用 async/await 编写递归？

更新：简化版

class Program
{
  // needs to be compiled as AnyCpu Prefer 64-bit
  static async Task Main(string[] args)
  {
    try
    {
      await TestAsync(97); // 96 still works
    }
    catch(Exception e)
    {
      Console.WriteLine("Exception caught: " + e);
    }
  }

  static async Task TestAsync(int count)
  {
    await Task.Run(() =>
    {
      if (count <= 0)
        throw new Exception("ex");
    });

    Console.WriteLine(count);
    await TestAsync(count-1);
  }
}

只有在选择 Any Cpu 并选择 32 位禁用 时才会如此快速，但在多个 .net 版本的多台机器（Windows 1903 和 1909）上可重现（.Net 4.7.2 和 .Net 4.8）

Answer 1

我怀疑您在 completions 上看到了 Stack Overflow - 即，在 Stack Overflow 消息之前，每个数字都会一直打印到 1。

我的猜测是这种行为是因为await uses synchronous continuations。有supposed to be code that prevents synchronous continuations from overflowing the stack，但它是启发式的，并不总是有效。

我怀疑这种行为不会在 .NET Core 上发生，因为很多优化工作已经投入到 .NET Core 的 async 支持中，这可能意味着该平台上的延续占用更少的堆栈空间，从而使启发式检查工作.启发式本身也可能在 .NET Core 中得到修复。无论哪种方式，我都不会屏住呼吸期待 .NET Framework 获得这些更新。

我会在这样的函数中排除超过 17 级的递归......

实际上不是 17。你有 102 级递归 (17 * 6)。要测量占用的实际堆栈空间，它将是17 * 6 * (number of stacks to resume continuations)。在我的机器上，有 17 个作品；它在超过 200 处失败（1200 次调用深度）。

请记住，这只发生在 tail recursive 异步函数的长序列中 - 即，在它们的await 之后 他们都没有更多的异步工作要做.如果您将任何函数更改为在 它们的递归 await 之后进行一些其他异步工作，这将避免堆栈溢出：

static async Task TestAsync(int count)
{
  await Task.Run(() =>
  {
    if (count <= 0)
      throw new Exception("ex");
  });

  Console.WriteLine(count);
  try
  {
    await TestAsync2(count);
  }
  finally
  {
    await Task.Yield(); // some other async work
  }
}