我在 WebApi 应用程序中设置了以下示例代码:

[HttpGet]
public double GetValueAction()
{
    return this.GetValue().Result;
}

public async Task<double> GetValue()
{
    return await this.GetValue2().ConfigureAwait(false);
}

public async Task<double> GetValue2()
{
    throw new InvalidOperationException("Couldn't get value!");
}

遗憾的是，当 GetValueAction 被命中时，返回的堆栈跟踪是:

    " at MyProject.Controllers.ValuesController.<GetValue2>d__3.MoveNext() in c:\dev\MyProject\MyProject\Controllers\ValuesController.cs:line 61 --- End of stack trace from previous location where exception was thrown --- 
at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task) 
at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task) 
at System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1.ConfiguredTaskAwaiter.GetResult()
at MyProject.Controllers.ValuesController.<GetValue>d__0.MoveNext() in c:\dev\MyProject\MyProject\Controllers\ValuesController.cs:line 56"

因此，我在跟踪中得到(损坏的)GetValue2 和 GetValue，但没有提到 GetValueAction。难道我做错了什么？是否有另一种模式可以让我获得更完整的堆栈跟踪？

编辑:我的目标不是编写依赖堆栈跟踪的代码，而是让异步方法中的失败更易于调试。

最佳答案

首先，堆栈跟踪并不像大多数人认为的那样。它们在调试期间很有用，但不适用于运行时使用，尤其是在 ASP.NET 上。

此外，堆栈跟踪在技术上是关于代码返回到哪里，而不是代码来自哪里。对于简单(同步)代码，两者是相同的:代码总是返回调用它的任何方法。但是，对于异步代码，这两者是不同的。同样，堆栈跟踪会告诉您接下来 会发生什么，但您对过去 发生的事情感兴趣。

因此，栈帧不是满足您需求的正确答案。 Eric Lippert explains this well in his answer here .

MSDN article @ColeCampbell 链接到描述了一种使用 async 代码跟踪“意外链”(代码来自 from 的地方)的方法。不幸的是，这种方法是有限的(例如，它不处理 fork/join 场景)；但是，据我所知，这是唯一在 Windows 应用商店应用程序中有效的方法。

由于您在 ASP.NET 上使用完整的 .NET 4.5 运行时，您可以访问更强大的解决方案来跟踪事故链:逻辑调用上下文。但是，您的 async 方法必须“选择加入”，因此您不会像使用堆栈跟踪那样免费获得它。我刚刚在尚未发布的博客文章中写下了这一点，因此您可以获得预览。 :)

您可以围绕逻辑调用上下文自己构建调用“堆栈”:

public static class MyStack
{
  // (Part A) Provide strongly-typed access to the current stack
  private static readonly string slotName = Guid.NewGuid().ToString("N");
  private static ImmutableStack<string> CurrentStack
  {
    get
    {
      var ret = CallContext.LogicalGetData(name) as ImmutableStack<string>;
      return ret ?? ImmutableStack.Create<string>();
    }
    set { CallContext.LogicalSetData(name, value); }
  }

  // (Part B) Provide an API appropriate for pushing and popping the stack
  public static IDisposable Push([CallerMemberName] string context = "")
  {
    CurrentStack = CurrentStack.Push(context);
    return new PopWhenDisposed();
  }
  private static void Pop() { CurrentContext = CurrentContext.Pop(); }
  private sealed class PopWhenDisposed : IDisposable
  {
    private bool disposed;
    public void Dispose()
    {
      if (disposed) return;
      Pop();
      disposed = true;
    }
  }

  // (Part C) Provide an API to read the current stack.
  public static string CurrentStackString
  {
    get { return string.Join(" ", CurrentStack.Reverse()); }
  }
}

(ImmutableStack 可用 here )。然后你可以像这样使用它:

static async Task SomeWork()
{
  using (MyStack.Push())
  {
    ...
    Console.WriteLine(MyStack.CurrentStackAsString + ": Hi!");
  }
}

这种方法的好处在于它适用于所有 async 代码:fork/join、自定义等待、ConfigureAwait(false)等。缺点是你增加了一些开销。此外，此方法仅适用于 .NET 4.5； .NET 4.0 上的逻辑调用上下文不是异步感知的，并且不会正常工作。

更新:我发布了一个 NuGet package (described on my blog)它使用 PostSharp 自动注入(inject)推送和弹出。因此，现在获得良好的跟踪应该简单得多。

关于c# - 是否可以使用 .NET 异步方法获得良好的堆栈跟踪？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15410661/