OperationCanceledException VS TaskCanceledException quando l'attività viene annullata

Question

Il codice seguente crea un'attività che viene annullata. L'espressione await (caso 1) genera System.OperationCanceledException mentre sincrono Wait() (caso 2) genera System.Threading.Tasks.TaskCanceledException (inserito in System.AggregateException).

using System; 
using System.Threading; 
using System.Threading.Tasks; 

public class Program 
{ 
    public static void Main() 
    { 
     Program.MainAsync().Wait(); 
    } 

    private static async Task MainAsync() 
    { 
     using(var cancellationTokenSource = new CancellationTokenSource()) 
     { 
      var token = cancellationTokenSource.Token; 
      const int cancelationCheckTimeout = 100; 

      var task = Task.Run(
       async() => 
       { 
        for (var i = 0; i < 100; i++) 
        { 
         token.ThrowIfCancellationRequested(); 
         Console.Write("."); 
         await Task.Delay(cancelationCheckTimeout); 
        } 
       }, 
       cancellationTokenSource.Token 
      ); 

      var cancelationDelay = 10 * cancelationCheckTimeout; 
      cancellationTokenSource.CancelAfter(cancelationDelay); 

      try 
      { 
       await task; // (1) 
       //task.Wait(); // (2) 
      } 
      catch(Exception ex) 
      { 
       Console.WriteLine(ex.ToString()); 
       Console.WriteLine($"Task.IsCanceled: {task.IsCanceled}"); 
       Console.WriteLine($"Task.IsFaulted: {task.IsFaulted}"); 
       Console.WriteLine($"Task.Exception: {((task.Exception == null) ? "null" : task.Exception.ToString())}"); 
      } 
     } 
    } 
} 

Caso 1 uscita:

..........System.OperationCanceledException: The operation was canceled. 
    at System.Threading.CancellationToken.ThrowIfCancellationRequested() 
    at Program.<>c__DisplayClass1_0.<<MainAsync>b__0>d.MoveNext() 
--- End of stack trace from previous location where exception was thrown --- 
    at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw() 
    at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task) 
    at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task) 
    at Program.<MainAsync>d__1.MoveNext() 
Task.IsCanceled: True 
Task.IsFaulted: False 
Task.Exception: null 

Caso 2 uscita:

..........System.AggregateException: One or more errors occurred. ---> System.Threading.Tasks.TaskCanceledException: A task was canceled. 
    --- End of inner exception stack trace --- 
    at System.Threading.Tasks.Task.Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken) 
    at System.Threading.Tasks.Task.Wait() 
    at Program.<MainAsync>d__1.MoveNext() 
---> (Inner Exception #0) System.Threading.Tasks.TaskCanceledException: A task was canceled.<--- 

Task.IsCanceled: True 
Task.IsFaulted: False 
Task.Exception: null 

Perché System.AggregateException nel secondo caso non contiene System.OperationCanceledException come eccezione interna?

so che ThrowIfCancellationRequested() tiri OperationCanceledException e possiamo vedere che in entrambi i casi Task arriva a stato annullato (non guasta).

Questo mi lascia perplesso perché la cancellazione di un metodo da API .NET produce un comportamento coerente in entrambi i casi - attività annullata getta solo TaskCanceledException:

using System; 
using System.Threading; 
using System.Threading.Tasks; 

public class Program 
{ 
    public static void Main() 
    { 
     Program.MainAsync().Wait(); 
    } 

    private static async Task MainAsync() 
    { 
     using(var cancellationTokenSource = new CancellationTokenSource()) 
     { 
      var token = cancellationTokenSource.Token; 

      var task = Task.Delay(1000, token); 
      cancellationTokenSource.CancelAfter(100); 

      try 
      { 
       await task; // (1) 
       //task.Wait(); // (2) 
      } 
      catch(Exception ex) 
      { 
       Console.WriteLine(ex.ToString()); 
       Console.WriteLine($"Task.IsCanceled: {task.IsCanceled}"); 
       Console.WriteLine($"Task.IsFaulted: {task.IsFaulted}"); 
       Console.WriteLine($"Task.Exception: {((task.Exception == null) ? "null" : task.Exception.ToString())}"); 
      } 
     } 
    } 
} 

Caso 1 uscita:

System.Threading.Tasks.TaskCanceledException: A task was canceled. 
    at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task) 
    at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task) 
    at Program.<MainAsync>d__1.MoveNext() 
Task.IsCanceled: True 
Task.IsFaulted: False 
Task.Exception: null 

Caso 2 uscita:

System.AggregateException: One or more errors occurred. ---> System.Threading.Tasks.TaskCanceledException: A task was canceled. 
    --- End of inner exception stack trace --- 
    at System.Threading.Tasks.Task.Wait(Int32 millisecondsTimeout, CancellationToken cancellationToken) 
    at System.Threading.Tasks.Task.Wait() 
    at Program.<MainAsync>d__1.MoveNext() 
---> (Inner Exception #0) System.Threading.Tasks.TaskCanceledException: A task was canceled.<--- 

Task.IsCanceled: True 
Task.IsFaulted: False 
Task.Exception: null 

Answer 1

La differenza deriva dall'utilizzo di token.ThrowIfCancellationRequested(). Questo metodo controlla la cancellazione e, se richiesto, genera OperationCanceledException in modo specifico e non TaskCanceledException (comprensibile come CancellationToken non è esclusivo per il TPL). Potete guardare il reference source e vedere che chiama questo metodo:

private void ThrowOperationCanceledException() 
{ 
    throw new OperationCanceledException(Environment.GetResourceString("OperationCanceled"), this); 
} 

cancellazione "regolare", anche se sarà davvero generare un TaskCanceledException. Si può vedere che cancellando il token prima che il compito avuto la possibilità di iniziare a correre:

cancellationTokenSource.Cancel(); 
var task = Task.Run(() => { }, cancellationTokenSource.Token); 
try 
{ 
    await task; 
} 
catch (Exception ex) 
{ 
    Console.WriteLine(ex.ToString()); 
    Console.WriteLine($"Task.IsCanceled: {task.IsCanceled}"); 
    Console.WriteLine($"Task.IsFaulted: {task.IsFaulted}"); 
    Console.WriteLine($"Task.Exception: {((task.Exception == null) ? "null" : task.Exception.ToString())}"); 
} 

uscita:

System.Threading.Tasks.TaskCanceledException: A task was canceled. 
    at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task) 
    at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task) 
    at System.Runtime.CompilerServices.TaskAwaiter.GetResult() 
    at Sandbox.Program.<MainAsync>d__1.MoveNext() 
Task.IsCanceled: True 
Task.IsFaulted: False 
Task.Exception: null 

metodi tradizionali .Net di solito non utilizzare CancellationToken.ThrowIfCancellationRequested per l'API asincrona come è appropriato quando si scarica il lavoro su un altro thread. Questi metodi sono per le operazioni intrinsecamente asincrone, quindi la cancellazione viene monitorata utilizzando CancellationToken.Register (o lo InternalRegisterWithoutEC interno).