C#中能否全局强制异步方法同步执行以保留堆栈跟踪？

问题背景 #

我有如下封装的异步执行方法：

public virtual async Task<TResponse> ExecuteAsync<TResponse>(Func<TServiceClient, Task<TResponse>> func)
{
    var st1 = new System.Diagnostics.StackTrace().ToString();
    try
    {
        return await func(_clientInstance);
    }
    catch (Exception ex)
    {
        ThrowServiceException(ex, st1);
    }
}

private void ThrowServiceException(Exception ex, string st1)
{
    var st2 = new System.Diagnostics.StackTrace().ToString();
    if (st1 != st2)    {    }
// ...
    
}

当内部抛出异常时，捕获前后的堆栈跟踪完全断裂：

异常捕获前堆栈 #

at Common.Autorest.AutorestClientWrapper`1.ExecuteAsync[TResponse](Func`2 func)
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](TStateMachine& stateMachine)
   at Common.Autorest.AutorestClientWrapper`1.ExecuteAsync[TResponse](Func`2 func)
   at Common.Autorest.AutorestClientWrapper`1.Execute[TResponse](Func`2 func)
   at BankingServiceClient.BankApi.GetBufferBalance(CancellationToken cancellationToken)
   at Engine.Services.BalanceWorker.<>c__DisplayClass18_0.<RefreshTreasuryBalance>g__ExecuteTreasuryBalanceRefresh|0(CancellationToken token)
   at Engine.Services.BalanceWorker.ExecuteBalanceRefresh(Action`1 executeRefresh, String loggingName)
   at Engine.Services.BalanceWorker.RefreshTreasuryBalance(Currency currency)
   at Engine.Services.BalanceWorker.<>c__DisplayClass14_2.<.ctor>b__4()
   at Engine.Threading.Runnable.Engine.Threading.IRunnable.RunStep()
   at Engine.Threading.Runner.ExecuteContinously()
   at System.Threading.Thread.StartHelper.Callback(Object state)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.Thread.StartCallback()

异常捕获后堆栈 #

at Common.Autorest.AutorestClientWrapper`1.ThrowServiceException(Exception ex, String st1)
   at Common.Autorest.AutorestClientWrapper`1.ExecuteAsync[TResponse](Func`2 func)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AsyncStateMachineBox`1.ExecutionContextCallback(Object s)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AsyncStateMachineBox`1.MoveNext(Thread threadPoolThread)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AsyncStateMachineBox`1.MoveNext()
   at System.Runtime.CompilerServices.TaskAwaiter.<>c.<OutputWaitEtwEvents>b__12_0(Action innerContinuation, Task innerTask)
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.ContinuationWrapper.Invoke()
   at System.Threading.Tasks.AwaitTaskContinuation.RunOrScheduleAction(Action action, Boolean allowInlining)
   at System.Threading.Tasks.Task.RunContinuations(Object continuationObject)
   at System.Threading.Tasks.Task.FinishContinuations()
   at System.Threading.Tasks.Task.FinishStageThree()
   at System.Threading.Tasks.Task.FinishStageTwo()
   at System.Threading.Tasks.Task.FinishSlow(Boolean userDelegateExecute)
   at System.Threading.Tasks.Task.TrySetException(Object exceptionObject)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetException(Exception exception, Task`1& taskField)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.SetException(Exception exception)
   at Bank.ApiClient.BufferAccountBankAPI.GetAccountBalanceAsync(CancellationToken cancellationToken)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AsyncStateMachineBox`1.ExecutionContextCallback(Object s)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AsyncStateMachineBox`1.MoveNext(Thread threadPoolThread)
   at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1.AsyncStateMachineBox`1.MoveNext()
   at System.Runtime.CompilerServices.TaskAwaiter.<>c.<OutputWaitEtwEvents>b__12_0(Action innerContinuation, Task innerTask)
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.ContinuationWrapper.Invoke()
   at System.Threading.Tasks.AwaitTaskContinuation.System.Threading.IThreadPoolWorkItem.Execute()
   at System.Threading.ThreadPoolWorkQueue.Dispatch()
   at System.Threading.PortableThreadPool.WorkerThread.WorkerThreadStart()
   at System.Threading.Thread.StartCallback()

当前调用场景包括异步直接调用：

public async Task<MarketLimits> GetMarketLimits(CancellationToken cancellationToken)
{
  var response = await _serviceClientWrapper.ExecuteAsync(c => c.GetLimitsAsync(cancellationToken));
  // ...
}

以及同步包装调用：

public virtual TResponse Execute<TResponse>(Func<TServiceClient, Task<TResponse>> func)
{
    return ExecuteAsync(client => func(client)).GetAwaiter().GetResult();
}

核心需求：调试场景下，能否通过全局配置强制所有异步方法同步执行，保留完整的调用堆栈，避免捕获前后堆栈断裂的问题？此前尝试过清理无用堆栈项的方案，但无法解决堆栈完全无关联的问题。

可行解决方案 #

1. 给ExecuteAsync添加调试同步开关 #

在封装类中加入全局静态开关，仅在调试模式下启用同步执行：

public static bool DebugForceSynchronousExecution { get; set; } = Debugger.IsAttached;

public virtual async Task<TResponse> ExecuteAsync<TResponse>(Func<TServiceClient, Task<TResponse>> func)
{
    var st1 = new System.Diagnostics.StackTrace().ToString();
    try
    {
        var task = func(_clientInstance);
        // 调试模式下同步执行任务，避免异步调度导致堆栈断裂
        if (DebugForceSynchronousExecution)
        {
            return task.GetAwaiter().GetResult();
        }
        return await task;
    }
    catch (Exception ex)
    {
        ThrowServiceException(ex, st1);
    }
}

这个方法直接针对封装层修改，无需改动上层业务代码，调试时自动触发同步执行，保证堆栈的连续性。注意：仅在调试环境使用，生产环境保持异步执行避免死锁。

2. 全局配置同步上下文（适用于全项目异步方法） #

自定义一个同步的SynchronizationContext，在调试启动时替换默认上下文：

public class SynchronousSynchronizationContext : SynchronizationContext
{
    public override void Post(SendOrPostCallback d, object state)
    {
        // 同步执行回调，不调度到线程池
        d(state);
    }

    public override void Send(SendOrPostCallback d, object state)
    {
        d(state);
    }
}

// 程序启动时（仅调试模式）
#if DEBUG
SynchronizationContext.SetSynchronizationContext(new SynchronousSynchronizationContext());
#endif

这个方法会让所有异步延续任务同步执行在原线程上，保留完整的调用堆栈。但要注意，部分依赖异步调度的代码可能出现行为变化，仅建议在调试异常堆栈时临时启用。

3. 使用全局开关禁用异步延续 #

.NET中默认异步任务的延续可能会异步调度，你可以通过全局设置强制延续同步执行：

// 调试模式下禁用异步延续
#if DEBUG
AppContext.SetSwitch("System.Threading.Tasks.Task.RunContinuationsAsynchronously", false);
#endif

这个开关会让Task的延续尽可能同步执行在原线程，从而保留堆栈信息。这是全局级别的配置，无需修改业务代码，但同样只建议在调试时使用，避免影响生产环境的异步性能。

内容的提问来源于stack exchange，提问作者Rok