C# TaskCompletionSource.SetCanceled方法代码示例

 public Task ReturnFile(IDictionary<string, object> env)
 {
     var tcs = new TaskCompletionSource<int>();
     if (env.GetPath().ToLower().Equals("/index.html", StringComparison.CurrentCultureIgnoreCase))
     {
         try
         {
             env["owin.ResponseHeaders"] = new Dictionary<string, string[]>
                                               {
                                                   {
                                                       "Content-Type",
                                                       new[] {"text/html"}
                                                   }
                                               };
             HandleRequest(env);
             env["owin.ResponseStatusCode"] = 200;
             tcs.SetResult(0);
         }
         catch (Exception ex)
         {
             Trace.TraceError(ex.Message);
             tcs.SetCanceled();
         }
     }
     else
     {
         tcs.SetCanceled();
     }
     return tcs.Task;
 }

        public Task<IEnumerable<Song>> GetSongs(string query, CancellationToken cancellationToken)
        {
            var result = MemoryCache.Default.Get(query) as IEnumerable<Song>;

            if (result != null)
            {
                return Task.Factory.StartNew(() => result);
            }

            var tcs = new TaskCompletionSource<IEnumerable<Song>>();

            _provider
                .GetSongs(query, cancellationToken)
                .ContinueWith(t =>
                {
                    if (t.IsFaulted)
                    {
                        tcs.SetException(t.Exception);
                    }
                    else if (t.IsCanceled)
                    {
                        tcs.SetCanceled();
                    }
                    else
                    {
                        MemoryCache.Default.Set(query, t.Result, new CacheItemPolicy { SlidingExpiration = SlidingExpiration });
                        tcs.SetResult(t.Result);
                    }
                });

            return tcs.Task;
        }

        public void Should_call_onBulkheadRejected_with_passed_context()
        {
            string executionKey = Guid.NewGuid().ToString();
            Context contextPassedToExecute = new Context(executionKey);

            Context contextPassedToOnRejected = null;
            Func<Context, Task> onRejectedAsync = async ctx => { contextPassedToOnRejected = ctx; await TaskHelper.EmptyTask.ConfigureAwait(false); };

            BulkheadPolicy<int> bulkhead = Policy.BulkheadAsync<int>(1, onRejectedAsync);

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            using (CancellationTokenSource cancellationSource = new CancellationTokenSource())
            {
                Task.Run(() => {
                    bulkhead.ExecuteAsync(async () =>
                    {
                        await tcs.Task.ConfigureAwait(false);
                        return 0;
                    });
                });

                Within(shimTimeSpan, () => bulkhead.BulkheadAvailableCount.Should().Be(0)); // Time for the other thread to kick up and take the bulkhead.

                bulkhead.Awaiting(async b => await b.ExecuteAsync(() => Task.FromResult(1), contextPassedToExecute)).ShouldThrow<BulkheadRejectedException>();

                cancellationSource.Cancel();
                tcs.SetCanceled();
            }

            contextPassedToOnRejected.Should().NotBeNull();
            contextPassedToOnRejected.ExecutionKey.Should().Be(executionKey);
            contextPassedToOnRejected.Should().BeSameAs(contextPassedToExecute);
        }

		public Task<Stream> GetStreamAsync(Uri uri, CancellationToken cancellationToken)
		{
			var tcs = new TaskCompletionSource<Stream>();

			try
			{
				HttpWebRequest request = WebRequest.CreateHttp(uri);
				request.AllowReadStreamBuffering = true;
				request.BeginGetResponse(ar =>
				{
					if (cancellationToken.IsCancellationRequested)
					{
						tcs.SetCanceled();
						return;
					}

					try
					{
						Stream stream = request.EndGetResponse(ar).GetResponseStream();
						tcs.TrySetResult(stream);
					}
					catch (Exception ex)
					{
						tcs.TrySetException(ex);
					}
				}, null);
			}
			catch (Exception ex)
			{
				tcs.TrySetException(ex);
			}

			return tcs.Task;
		}

        Task<ALAsset> GetAsset (AssetDescription description, CancellationToken token)
        {
            var tcs = new TaskCompletionSource<ALAsset> ();

            Task.Factory.StartNew (() => {
                if (token.IsCancellationRequested) {
                    tcs.SetCanceled ();
                    return;
                }

                _library.Value.AssetForUrl (new NSUrl (description.AssetUrl), (asset) => {
                    if (asset == null) {
                        tcs.SetException (new Exception ("No asset found for url"));
                        return;
                    }

                    if (asset.DefaultRepresentation == null) {
                        tcs.SetException (new Exception ("No representation found for the asset"));
                        return;
                    }

                    tcs.SetResult (asset);
                }, error => {
                    tcs.SetException (new Exception (error.ToString ()));
                });
            }, token).RouteExceptions (tcs);

            return tcs.Task;
        }

        /// <summary>
        /// If AutoSaveChanges is set this method will auto commit changes
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        protected virtual Task<int> SaveChanges(CancellationToken cancellationToken)
        {
            var source = new TaskCompletionSource<int>();
            if (AutoSaveChanges) {
                var registration = new CancellationTokenRegistration();
                if (cancellationToken.CanBeCanceled) {
                    if (cancellationToken.IsCancellationRequested) {
                        source.SetCanceled();
                        return source.Task;
                    }
                    registration = cancellationToken.Register(CancelIgnoreFailure);
                }

                try
                {
                    return _uow.SaveChangesAsync(cancellationToken);
                }
                catch (Exception e)
                {
                    source.SetException(e);
                }
                finally
                {
                    registration.Dispose();
                }
            }
            return source.Task;
        }

        /// <summary>
        ///   Executes the action on the UI thread asynchronously.
        /// </summary>
        /// <param name = "action">The action to execute.</param>
        public Task OnUIThreadAsync(Action action)
        {
            var completionSource = new TaskCompletionSource<bool>();

            UIApplication.SharedApplication.InvokeOnMainThread(() =>
            {

                try
                {
                    action();

                    completionSource.SetResult(true);

                }
                catch (TaskCanceledException)
                {
                    completionSource.SetCanceled();
                }
                catch (Exception ex)
                {
                    completionSource.SetException(ex);
                }

            });

            return completionSource.Task;
        }

		public static Task<bool> ConfirmationAsync(string title, string question)
		{
			var dataContext = new ConfirmModel
			{
				Title = title,
				Question = question
			};
			var inputWindow = new ConfirmWindow
			{
				DataContext = dataContext
			};

			var tcs = new TaskCompletionSource<bool>();

			inputWindow.Closed += (sender, args) =>
			{
				if (inputWindow.DialogResult != null)
					tcs.SetResult(inputWindow.DialogResult.Value);
				else
					tcs.SetCanceled();
			};

			inputWindow.Show();

			return tcs.Task;
		}

 private static Task WriteResponse(OwinContext context, IDictionary<string, object> env)
 {
     var tcs = new TaskCompletionSource<int>();
     var cancellationToken = (CancellationToken) env[OwinKeys.CallCancelled];
     if (cancellationToken.IsCancellationRequested)
     {
         tcs.SetCanceled();
     }
     else
     {
         try
         {
             env[OwinKeys.StatusCode] = context.Response.Status.Code;
             env[OwinKeys.ReasonPhrase] = context.Response.Status.Description;
             env[OwinKeys.ResponseHeaders] = context.Response.Headers;
             if (context.Response.WriteFunction != null)
             {
                 return context.Response.WriteFunction((Stream) env[OwinKeys.ResponseBody]);
             }
             tcs.SetResult(0);
         }
         catch (Exception ex)
         {
             tcs.SetException(ex);
         }
     }
     return tcs.Task;
 }

        public Task<Address_Validated> Automatically_Validate_Address(string textAddress)
        {
            var tcs = new TaskCompletionSource<Address_Validated>();

            var geocoding = maps.ServiceHelper.GetGeocodeService();
            geocoding.GeocodeCompleted += (sender, e) =>
            {
                //if (e.Error != null)
                //    tcs.SetCanceled();

                if (e.Error == null && e.Result.Results.GroupBy(f=> f.Address.FormattedAddress).Count() == 1)
                {
                    var validated = new Address_Validated(e.Result.Results.First(), null);
                    //MessageBus.Current.SendMessage(new Address_Validated(e.Result.Results.First(), search_Address));
                    tcs.TrySetResult(validated);
                }
                else
                {
                    tcs.SetCanceled();
                    //MessageBus.Current.SendMessage(search_Address.To_Manual());
                    //var task = Manually_Validate_Address(textAddress);
                    //task.Wait();
                }
            };

            geocoding.GeocodeAsync(new maps.GeocodeService.GeocodeRequest
            {
                Credentials = new Microsoft.Maps.MapControl.Credentials() { Token = maps.ServiceHelper.GeocodeServiceCredentials },
                Culture = System.Threading.Thread.CurrentThread.CurrentUICulture.ToString(),
                Query = textAddress
            });

            return tcs.Task;
        }

        public async Task Should_call_on_error(TransportTransactionMode transactionMode)
        {
            var onErrorCalled = new TaskCompletionSource<ErrorContext>();

            OnTestTimeout(() => onErrorCalled.SetCanceled());

            await StartPump(context =>
            {
                throw new Exception("Simulated exception");
            },
                context =>
                {
                    onErrorCalled.SetResult(context);

                    return Task.FromResult(ErrorHandleResult.Handled);
                }, transactionMode);

            await SendMessage(InputQueueName, new Dictionary<string, string> { { "MyHeader", "MyValue" } });

            var errorContext = await onErrorCalled.Task;

            Assert.AreEqual(errorContext.Exception.Message, "Simulated exception", "Should preserve the exception");
            Assert.AreEqual(1, errorContext.ImmediateProcessingFailures, "Should track the number of delivery attempts");
            Assert.AreEqual("MyValue", errorContext.Message.Headers["MyHeader"], "Should pass the message headers");
        }

        public void Should_call_onBulkheadRejected_with_passed_context()
        {
            string executionKey = Guid.NewGuid().ToString();
            Context contextPassedToExecute = new Context(executionKey);

            Context contextPassedToOnRejected = null;
            Action<Context> onRejected = ctx => { contextPassedToOnRejected = ctx; };

            BulkheadPolicy<int> bulkhead = Policy.Bulkhead<int>(1, onRejected);

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            using (CancellationTokenSource cancellationSource = new CancellationTokenSource())
            {
                Task.Run(() => {
                    bulkhead.Execute(() =>
                    {
                        tcs.Task.Wait();
                        return 0;
                    });
                });

                Within(shimTimeSpan, () => bulkhead.BulkheadAvailableCount.Should().Be(0)); // Time for the other thread to kick up and take the bulkhead.

                bulkhead.Invoking(b => b.Execute(() => 1, contextPassedToExecute)).ShouldThrow<BulkheadRejectedException>();

                cancellationSource.Cancel();
                tcs.SetCanceled();
            }

            contextPassedToOnRejected.Should().NotBeNull();
            contextPassedToOnRejected.ExecutionKey.Should().Be(executionKey);
            contextPassedToOnRejected.Should().BeSameAs(contextPassedToExecute);
        }

        public static Task<Byte[]> DownloadDataTaskAsync(this WebClient client, Uri address)
        {
            var completerionSource = new TaskCompletionSource<byte[]>();
            var token = new object();

            OpenReadCompletedEventHandler handler = null;
            handler = (sender, args) =>
            {
                if (args.UserState != token)
                {
                    return;
                }

                if (args.Error != null)
                {
                    completerionSource.SetException(args.Error);
                }
                else if (args.Cancelled)
                {
                    completerionSource.SetCanceled();
                }
                else
                {
                    completerionSource.SetResult(args.Result.ToArray());
                }

                client.OpenReadCompleted -= handler;
            };

            client.OpenReadCompleted += handler;
            client.OpenReadAsync(address, token);

            return completerionSource.Task;
        }

        public static Task AlertUser(string title, string message)
        {
            var dataContext = new ConfirmModel
			{
				Title = title,
				Message = message,
                AllowCancel = false,
			};
			var inputWindow = new ConfirmWindow()
			{
				DataContext = dataContext
			};

			var tcs = new TaskCompletionSource<bool>();

			inputWindow.Closed += (sender, args) =>
			{
				if (inputWindow.DialogResult == true)
					tcs.SetResult(true);
				else
					tcs.SetCanceled();
			};

			inputWindow.Show();

			return tcs.Task;
        }

		public static Task<string> QuestionAsync(string title, string question, Func<string,string> validator = null, string defaultAnswer = "")
		{
			var dataContext = new InputModel
			{
				Title = title,
				Message = question,
                ValidationCallback = validator,
			};

            dataContext.SetDefaultAnswer(defaultAnswer);

			var inputWindow = new InputWindow
			{
				DataContext = dataContext
			};

			var tcs = new TaskCompletionSource<string>();

			inputWindow.Closed += (sender, args) =>
			{
				if (inputWindow.DialogResult == true)
					tcs.SetResult(dataContext.Answer);
				else
					tcs.SetCanceled();
			};

			inputWindow.Show();

			return tcs.Task;
		}