任务行为不同于 Task<T>抛出 OperationCanceledException 时的行为

If you are waiting on a Task that transitions to the Canceled state, a System.Threading.Tasks.TaskCanceledException exception (wrapped in an AggregateException exception) is thrown. Note that this exception indicates successful cancellation instead of a faulty situation. Therefore, the task's Exception property returns null.

如果令牌的 IsCancellationRequested 属性返回 false 或如果异常的令牌与任务的令牌不匹配，则OperationCanceledException 是视为正常异常，导致转换到 Faulted 状态的任务.还要注意的是其他异常的存在也会导致 Task 转换为Faulted 状态.您可以在状态 财产.

If the token's IsCancellationRequested property returns false or if the exception's token does not match the Task's token, the OperationCanceledException is treated like a normal exception, causing the Task to transition to the Faulted state. Also note that the presence of other exceptions will also cause the Task to transition to the Faulted state. You can get the status of the completed task in the Status property.

所以，在这里我们可以找到这种行为的原因 - 由于令牌不匹配，异常被视为正常异常.这很奇怪，因为令牌是绝对相同(我已经在调试中检查过，哈希码是相等的，Equals 方法和双等号运算符返回 true)，但比较仍然返回 false.因此，针对您的情况的解决方案是显式使用 取消令牌，类似这样(我添加了 Thread.Sleep 以避免竞争条件):

So, here we can find the reason for this behavior - the exception is treated like a normal exception because of the token mismatch. This is strange, because the token is definitely the same (I've checked that in Debug, the hash code is equal, Equals method and double equals operator returns true), but the comparison still returns false. So, the solution for your case is explicit usage of the cancellation tokens, something like this (I've added the Thread.Sleep to avoid the race condition):

var t1TokenSource = new CancellationTokenSource();
var t1 = Task.Run(() =>
{
    Thread.Sleep(1000);
    if (t1TokenSource.Token.IsCancellationRequested)
    {
        t1TokenSource.Token.ThrowIfCancellationRequested();
    }
    //throw new TaskCanceledException();
}, t1TokenSource.Token);
try
{
    t1TokenSource.Cancel();
    t1.Wait();
}
catch (AggregateException e)
{
    Debug.Assert(t1.IsCanceled);
}

var t2TokenSource = new CancellationTokenSource();
var t2 = Task.Run(() =>
{
    Thread.Sleep(1000);
    if (t2TokenSource.Token.IsCancellationRequested)
    {
        t2TokenSource.Token.ThrowIfCancellationRequested();
    }
    //throw new TaskCanceledException();
    return 1;
}, t2TokenSource.Token);
try
{
    t2TokenSource.Cancel();
    t2.Wait();
}
catch (AggregateException e)
{
    Debug.Assert(t2.IsCanceled);
}

来自 MSDN 的另一句话:

您可以使用以下选项之一终止操作:

You can terminate the operation by using one of these options:

如您所见，首选方式可预测地工作，而直接异常抛出则不然.另请注意，如果使用 task 也是使用 DenyChildAttach 创建的，并且没有 Result 属性，因此您遇到的构造函数存在一些差异.
希望这会有所帮助.

As you can see, the preffered way is working predictably, the direct exception throw does not. Please also note that in case of usage task is created with DenyChildAttach too, and doesn't have a Result property, so there is some difference in constructors, which you've faced with.
Hope this helps.

这篇关于任务行为不同于 Task<T>抛出 OperationCanceledException 时的行为的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！