使用任务重新尝试异步函数——哪种方法更有效?

我想知道哪种方法在内存和资源使用方面更有效。

特别是方法#1，我很难想象任务对象将如何创建和线程旋转?有谁能详细解释一下被子下面发生了什么吗?

如果两者之间没有区别，我想使用#1(想避免冒泡异步)。对于#2，我理解编译器将在下面生成一个状态机并产生返回。OTOH， #1在概念上似乎是递归的，但它在传统意义上是递归的吗?一个堆栈框架等待另一个堆栈框架?

方法# 1:

internal static Task ExecuteAsyncWithRetry(Func<Task> methodToExecute, Func<bool> shouldRetry)
    {
        var tcs = new TaskCompletionSource<object>();
        try
        {
            return methodToExecute().ContinueWith<Task>((t) =>
            {
                if (t.IsFaulted || t.IsCanceled)
                {
                    if (shouldRetry())
                    {
                        return ExecuteAsyncWithRetry(methodToExecute, shouldRetry);
                    }
                    else
                    {
                        tcs.SetException(t.Exception);
                    }
                }
                else
                {
                    tcs.SetResult(null);
                }
                return tcs.Task;
            }, TaskContinuationOptions.ExecuteSynchronously).Unwrap();
        }
        catch(Exception ex)
        {
            tcs.SetException(ex);
        }
        return tcs.Task;
    }

方法#2(忽略两者之间异常传播的差异):

internal static async Task ExecuteWithRetry(Func<Task> methodToExecute, Func<bool> shouldRetry)
    {
        while (true)
        {
            try
            {
                await methodToExecute();
            }
            catch(Exception ex)
            {
                if(!shouldRetry())
                {
                    throw;
                }
            }
        }
    }