C# TaskCompletionSource.TrySetCanceled方法代码示例

        public static Task InvokeAsync([NotNull] this IDispatcherService service, [NotNull] Func<Task> action)
        {
            Guard.NotNull(service, nameof(service));
            Guard.NotNull(action, nameof(action));

            var tcs = new TaskCompletionSource();

            service.InvokeAsync(new Action(() =>
            {
                action().ContinueWith(t =>
                {
                    if (t.Exception != null)
                    {
                        tcs.TrySetException(t.Exception);
                        return;
                    }

                    if (t.IsCanceled)
                    {
                        tcs.TrySetCanceled();
                    }

                    tcs.TrySetResult();
                });
            }));

            return tcs.Task;
        }

 /// <summary>
 /// Returns a <see cref="Task"/> that is canceled when this <see cref="CancellationToken"/> is canceled. This method will leak resources if the cancellation token is long-lived; use <see cref="ToCancellationTokenTaskSource"/> for a similar approach with proper resource management.
 /// </summary>
 /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor.</param>
 /// <returns>A <see cref="Task"/> that is canceled when this <see cref="CancellationToken"/> is canceled.</returns>
 public static Task AsTask(this CancellationToken cancellationToken)
 {
     if (!cancellationToken.CanBeCanceled)
         return TaskConstants.Never;
     if (cancellationToken.IsCancellationRequested)
         return TaskConstants.Canceled;
     var tcs = new TaskCompletionSource();
     cancellationToken.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: false);
     return tcs.Task;
 }

        public static async Task ConfigureTopologyAsync(this Link @this,
            Func<ILinkTopologyConfig, Task> configure, CancellationToken cancellationToken)
        {            
            var completion = new TaskCompletionSource();
            if (cancellationToken.IsCancellationRequested)
            {
                completion.TrySetCanceled();
                await completion.Task;
                return;                
            }

            using (@this.CreateTopologyConfigurator(configure, () =>
            {
                completion.TrySetResultWithBackgroundContinuations();
                return Task.FromResult((object) null);
            }, ex =>
            {
                completion.TrySetExceptionWithBackgroundContinuations(ex);
                return Task.FromResult((object) null);
            }))
            {
                IDisposable registration = null;
                try
                {
                    registration = cancellationToken.Register(() =>
                    {
                        completion.TrySetCanceledWithBackgroundContinuations();                    
                    });
                }
                catch (ObjectDisposedException)
                {
                    // Cancellation source already disposed                  
                }

                if (cancellationToken.IsCancellationRequested)
                {
                    completion.TrySetCanceledWithBackgroundContinuations();
                }

                try
                {
                    await completion.Task
                        .ConfigureAwait(false);
                }
                finally
                {
                    registration?.Dispose();
                }
            }
        }

 /// <summary>
 /// Creates a task for the specified cancellation token, registering with the token if necessary.
 /// </summary>
 /// <param name="cancellationToken">The cancellation token to observe.</param>
 public CancellationTokenTaskSource(CancellationToken cancellationToken)
 {
     if (!cancellationToken.CanBeCanceled)
     {
         Task = TaskConstants.Never;
         return;
     }
     if (cancellationToken.IsCancellationRequested)
     {
         Task = TaskConstants.Canceled;
         return;
     }
     var tcs = new TaskCompletionSource();
     _registration = cancellationToken.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: false);
     Task = tcs.Task;
 }

 private static AsyncCallback Callback(Action<IAsyncResult> endMethod, TaskCompletionSource<object> tcs)
 {
     return asyncResult =>
     {
         try
         {
             endMethod(asyncResult);
             tcs.TrySetResult(null);
         }
         catch (OperationCanceledException)
         {
             tcs.TrySetCanceled();
         }
         catch (Exception ex)
         {
             tcs.TrySetException(ex);
         }
     };
 }

        private static Task<string> DumpWebPageAsync(WebClient client, Uri uri)
        {
            //si utilizza TaskCompletionSource che gestisce un task figlio
            var tcs = new TaskCompletionSource<string>();

            DownloadStringCompletedEventHandler handler = null;

            handler = (sender, args) =>
            {
                client.DownloadStringCompleted -= handler;

                if (args.Cancelled)
                    tcs.TrySetCanceled();
                else if (args.Error != null)
                    tcs.TrySetException(args.Error);
                else
                    tcs.TrySetResult(args.Result);
            };

            client.DownloadStringCompleted += handler;
            client.DownloadStringAsync(uri);

            return tcs.Task;
        }

 public void TrySetCanceled_CancelsTask()
 {
     var tcs = new TaskCompletionSource();
     tcs.TrySetCanceled();
     Assert.IsTrue(tcs.Task.IsCanceled);
 }