等待任务并在取消或失败时静默停止

Question

我想写的是：

async void Foo()
{
    var result = await GetMyTask().IgnoreCancelAndFailure();
    ProcessResult(result);
}

代替：

void Foo()
{
    GetMyTask().ContinueWith(task => ProcessResult(task.Result),
        TaskContinuationOptions.OnlyOnRanToCompletion);
}

但是我不知道如何实现 IgnoreCancelAndFailure 方法，它的签名如下：

//On cancel or failure this task should simply stop and never complete.
Task<T> IgnoreCancelAndFailure<T>(this Task<T> task) 
{
     throw new NotImplementedException(); 
}

如果可能，我应该如何实现 IgnoreCancelAndFailure？

Answer 1

你可以做类似的事情，但你需要知道在失败的情况下你希望方法返回什么，因为返回值是预期的：

public static async Task<T> IgnoreCancelAndFailure<T>(this Task<T> task) 
{
     try
     {
         return await task;
     }
     catch
     {
         return ???; // whatever you want to return in this case
     }
}

如果是 Task 没有结果，只需将 catch 留空（或者可能记录异常...吞下的异常会导致硬调试）

如果你只想在GetMyTask成功时执行ProcessResult，你可以这样做：

async void Foo()
{
    try
    {
        var result = await GetMyTask();
        ProcessResult(result);
    }
    catch(Exception ex)
    {
        // handle the exception somehow, or ignore it (not recommended)
    }
}

Answer 2

在终止线程或进程时，您将永远无法阻止您的代码继续期望。请记住，等待任务可以被认为是一个函数调用，它总是必须返回一个值或抛出一个异常。 缩短代码的最接近的方法是创建一个使用 ProcessResult 方法作为 Action 参数的包装函数。 类似的东西：

public static async Task IgnoreCancelAndFailure<T>(this Task<T> task, Action<T> resultProcessor) 
{
    task.ContinueWith(t => resultProcessor(t.Result),
        TaskContinuationOptions.OnlyOnRanToCompletion);
}

async void Foo()
{
    GetMyTask().IgnoreCancelAndFailure(ProcessResult);
}

Answer 3

我想我找到了答案。以下似乎可以解决问题。它使用等待模式。你们能确认这不是邪恶的吗？

class User
{
    async void Foo()
    {
        var result = await GetMyTask().IgnoreCancelAndFailure();
        ProcessResult(result);
    }
}

public static class TaskExtenstions
{
    public static SilentTask<T> IgnoreCancelAndFailure<T>(this Task<T> task)
    {
        return new SilentTask<T>(task);
    }
}

public class SilentTask<T>
{
    private readonly Task<T> _inner;

    public SilentTask(Task<T> inner)
    {
        _inner = inner;
    }

    public SilentAwaiter GetAwaiter()
    {
        return new SilentAwaiter(_inner);
    }

    public class SilentAwaiter : INotifyCompletion
    {
        private readonly TaskAwaiter<T> _inner;
        private readonly Task<T> _task;

        public SilentAwaiter(Task<T> task)
        {
            _task = task;
            _inner = task.GetAwaiter();
        }

        public bool IsCompleted
        {
            get
            {
                return _task.Status == TaskStatus.RanToCompletion;
            }
        }

        public void OnCompleted(Action continuation)
        {
            _inner.OnCompleted(() =>
            {
                if (IsCompleted)
                {
                    continuation();
                }
            });
        }

        public T GetResult()
        {
            return _inner.GetResult();
        }
    }
}