使用任务并行库翻译 Task<T> 的异常等待

Question

我正在尝试做相当于 dollowing C# 5 伪代码：-

async Task<int> CallAndTranslate()
{
    try 
    {
        return await client.CallAsync();
    } catch(FaultException ex) {
        if (ex.FaultCode ...)
            throw new Exception("translated");
    }
}

Given an arbitrary Task which does not return a result, translating exceptions 当从 C# 5 向后移植很容易时using the technique supplied by @Drew Marsh

这种技术不能简单地推广到Task<T>，因为Task.ContinueWith 的任何重载我可以看到返回一个秃头Task，而不是Task<T>。

有没有办法使用 TPL API 来实现这一点而无需求助于：

• 将其包装在另一个 Task<T> 中
• 导致异常通过异常处理机制被抛出和捕获
• 在初始回答后添加......如果不翻译异常，则应单独保留堆栈跟踪

---

这是我天真的占位符实现：

public class TranslatingExceptions
{
    Task<int> ApiAsync()
    {
        return Task<int>.Factory.StartNew( () => { 
           throw new Exception( "Argument Null" ); } );
    }

    public Task<int> WrapsApiAsync() 
    {
        return ApiAsync().TranslateExceptions(x=>{
            if (x.Message == "Argument Null" )
                throw new ArgumentNullException();
        });
    }

    [Fact]
    public void Works()
    {
        var exception = Record.Exception( () =>
            WrapsApiAsync().Wait() );
        Assert.IsType<ArgumentNullException>( exception.InnerException );
    }
}

以下Task<T> 扩展实现了我的占位符实现：

static class TaskExtensions
{
    public static Task<T> TranslateExceptions<T>( this Task<T> task, Action<Exception> translator )
    {
    // TODO REPLACE NAIVE IMPLEMENTATION HERE
        return Task<T>.Factory.StartNew( () =>
        {
            try
            {
                return task.Result;
            }
            catch ( AggregateException exception )
            {
                translator( exception.InnerException );
                throw;
            }
        } );
    }
}

Answer 1

您可以使用迭代器 (yield) 在 .NET 4.0 中模仿 await，但这并不漂亮。

如果没有状态机，您将错过await 的全部要点，即在工作完成之前将控制权返回给调用者，然后才能继续执行。

嗯，也许我没有抓住重点！如果您只想使用ContinueWith<T>，只需对 Drew Marsh 的代码稍作调整：

public Task<int> ApiAsync() // The inner layer exposes it exactly this way
{
    return Task<int>.Factory.StartNew( () =>
        { throw new Exception( "Argument Null" ); } );
}

// this layer needs to expose it exactly this way
public Task<int> WrapsApiAsync()
{
    // Grab the task that performs the "original" work
    Task<int> apiAsyncTask = ApiAsync();

    // Hook a continuation to that task that will do the exception "translation"
    Task<int> result = apiAsyncTask.ContinueWith( antecedent =>
    {
        // Check if the antecedent faulted
        // If so check what the exception's message was
        if ( antecedent.IsFaulted )
        {
            if ( antecedent.Exception.InnerException.Message == "Argument Null" )
            {
                throw new ArgumentNullException();
            }

            throw antecedent.Exception.InnerException;
        }

        return antecedent.Result;
    },
    TaskContinuationOptions.ExecuteSynchronously );

    // Now we return the continuation Task from the wrapper method
    // so that the caller of the wrapper method waits on that
    return result;
}

更新：使用 TaskCompletionSource 的示例

public static Task<int> WrapsApiAsync()
{
    var tcs = new TaskCompletionSource<int>();

    Task<int> apiAsyncTask = ApiAsync();

    apiAsyncTask.ContinueWith( t =>
        {
            switch ( t.Status )
            {
                case TaskStatus.RanToCompletion:
                    tcs.SetResult( task.Result );
                    break;

                case TaskStatus.Canceled:
                    tcs.SetCanceled();
                    break;

                case TaskStatus.Faulted:

                    if ( t.Exception.InnerException.Message == "Argument Null" )
                    {
                        try
                        {
                            throw new ArgumentNullException();
                        }
                        catch ( ArgumentNullException x )
                        {
                            tcs.SetException( x );
                        }
                    }
                    else
                    {
                        tcs.SetException( t.Exception.InnerException );
                    }

                    break;
            }
        }
    );

    return tcs.Task;
}