C# TaskCompletionSource.TrySetResult方法代码示例

        public static Task<bool> SetSwitch(LightSwitch ls, bool on)
        {
            var urlBuilder = new StringBuilder(BaseUrl + "wemo/");
            var action = on ? "on/" : "off/";
            urlBuilder.Append(action);
            urlBuilder.Append(ls.Name);
            urlBuilder.Append("?nocache=" + Environment.TickCount.ToString());

            TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>();

            WebClient wc = new WebClient();
            wc.DownloadStringCompleted += (s, args) =>
            {
                if (args.Error != null)
                {
                    tcs.TrySetResult(false);
                }
                else
                {
                    if (string.Compare(args.Result, "OK", StringComparison.InvariantCultureIgnoreCase) == 0)
                    {
                        tcs.TrySetResult(true);
                    }
                    else
                    {
                        tcs.TrySetResult(false);
                    }
                }
            };
            wc.DownloadStringAsync(new Uri(urlBuilder.ToString(), UriKind.Absolute));

            return tcs.Task;
        }

        public Task<ResponseData> Request(RequestData request, CancellationToken _)
        {
            var cancellation = new CancellationTokenSource(this.timeout);

            var responseTask = this.client.Request(request, cancellation.Token);

            var completion = new TaskCompletionSource<ResponseData>();

            //when the token reaches timeout, tries to set the timeoutResponse as the result
            //if the responseTask already completed, this is ignored
            cancellation.Token.Register(() => completion.TrySetResult(this.timeoutResponse));

            //when the responseTask completes, tries to apply its exception/result properties as long as the timeout isn't reached
            responseTask.ContinueWith(t =>
            {
                if (!cancellation.IsCancellationRequested)
                {
                    if (responseTask.Exception != null)
                    {
                        completion.TrySetException(responseTask.Exception.InnerException);
                    }
                    else
                    {
                        completion.TrySetResult(responseTask.Result);
                    }
                }
            });

            return completion.Task;
        }

 public static TaskAwaiter<bool> GetAwaiter(this IShowableViewModel vmModel)
 {
     var tcs = new TaskCompletionSource<bool>();
     vmModel.Closed += (s, e) => tcs.TrySetResult(false);
     if (vmModel.IsClosed) tcs.TrySetResult(false);
     return tcs.Task.GetAwaiter();
 }

        public static Task<bool> GoToState(this Control control, string state)
        {
            var taskSource = new TaskCompletionSource<bool>();
            var layoutRoot = VisualTreeHelper.GetChild(control, 0) as FrameworkElement;
            var visualStateGroups = VisualStateManager.GetVisualStateGroups(layoutRoot);
            var visualState = visualStateGroups.OfType<VisualStateGroup>().SelectMany(i => i.States.OfType<VisualState>()).FirstOrDefault(i => i.Name == state);

            if (visualState == null)
                throw new ArgumentException("VisualState wasn't found");

            if (visualState.Storyboard == null)
            {
                taskSource.TrySetResult(false);
                return taskSource.Task;
            }

            EventHandler storyboardCompletedHandler = null;
            storyboardCompletedHandler = (s, e) =>
                {
                    visualState.Storyboard.Completed -= storyboardCompletedHandler;
                    taskSource.TrySetResult(true);
                };

            visualState.Storyboard.Completed += storyboardCompletedHandler;
            VisualStateManager.GoToState(control, state, true);
            return taskSource.Task;
        }

        static void Main(string[] args)
        {
            var tcs = new TaskCompletionSource<int>();
            
            var ct = new CancellationTokenSource(7000);
            ct.Token.Register(() =>
            {
                Console.WriteLine("Cancel");
                tcs.TrySetResult(1);
            }, useSynchronizationContext: false);

            Stopwatch sw = new Stopwatch();
            sw.Restart();
            Console.WriteLine("StartNew...");
            Task.Factory.StartNew(() =>
            {
                Task.Delay(5000).Wait();
                Console.WriteLine("StartNew...Over");
                tcs.TrySetResult(DateTime.Now.Second);

            });
            
            var i = tcs.Task.Result;
            sw.Stop();
            Console.WriteLine("over..." + sw.Elapsed.TotalSeconds);

            Console.ReadLine();
        }

		public static Task<WebResponse> GetResponseAsync(this HttpWebRequest request)
		{
			var taskComplete = new TaskCompletionSource<WebResponse>();

			request.AllowReadStreamBuffering = true;
			request.AllowWriteStreamBuffering = true;

			request.BeginGetResponse(asyncResponse =>
			{
				try
				{
					var responseRequest = (HttpWebRequest)asyncResponse.AsyncState;
					var someResponse = responseRequest.EndGetResponse(asyncResponse);

					taskComplete.TrySetResult(someResponse);
				}
				catch (WebException webExc)
				{
					var failedResponse = webExc.Response;
					taskComplete.TrySetResult(failedResponse);
				}
			}, request);

			return taskComplete.Task;
		}

        public static Task<HttpWebResponse> GetResponseStreamAsync(this HttpWebRequest context, object state)
        {
            // this will be our sentry that will know when our async operation is completed
            var tcs = new TaskCompletionSource<HttpWebResponse>();

            try
            {
                context.BeginGetResponse((iar) =>
                {
                    try
                    {
                        var result = context.EndGetResponse(iar as IAsyncResult);
                        tcs.TrySetResult(result as HttpWebResponse);
                    }
                    catch (OperationCanceledException ex)
                    {
                        // if the inner operation was canceled, this task is cancelled too
                        tcs.TrySetCanceled();
                    }
                    catch (Exception ex)
                    {
                        // general exception has been set
                        tcs.TrySetException(ex);
                    }
                }, state);
            }
            catch
            {
                tcs.TrySetResult(default(HttpWebResponse));
                // propagate exceptions to the outside
                throw;
            }

            return tcs.Task;
        }

		public Task<bool> ConfirmAsync(string message, string title = "", string okButton = "OK", string cancelButton = "Cancel", TimeSpan? duration = null)
		{
			var tcs = new TaskCompletionSource<bool>();

			Application.SynchronizationContext.Post(ignored =>
			{
				if (CurrentActivity == null) return;

				var builder = new AlertDialog.Builder(CurrentActivity)
					.SetMessage(message)
					.SetTitle(title)
					.SetPositiveButton(okButton, delegate
					{
						tcs.TrySetResult(true);
					})
					.SetNegativeButton(cancelButton, delegate
					{
						tcs.TrySetResult(false);
					});

				var dialog = this.CustomizeAndCreate(builder);
				dialog.Show();

				if (duration.HasValue)
					Task.Delay(duration.Value).ContinueWith((delayTask) => Application.SynchronizationContext.Post(ignored2 => dialog.SafeDismiss(), null));
			}, null);

			return tcs.Task;
		}

        internal Task WaitForButtonPressAsync()
        {
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();

            RoutedEventHandler okHandler = null;
            KeyEventHandler okKeyHandler = null;

            KeyEventHandler escapeKeyHandler = null;

            Action cleanUpHandlers = null;

            var cancellationTokenRegistration = DialogSettings.CancellationToken.Register(() =>
            {
                cleanUpHandlers();
                tcs.TrySetResult(null);
            });

            cleanUpHandlers = () => {
                KeyDown -= escapeKeyHandler;

                PART_OkButton.Click -= okHandler;

                PART_OkButton.KeyDown -= okKeyHandler;

                cancellationTokenRegistration.Dispose();
            };

            escapeKeyHandler = (sender, e) =>
            {
                if (e.Key != Key.Escape) return;
                cleanUpHandlers();

                tcs.TrySetResult(null);
            };

            okKeyHandler = (sender, e) =>
            {
                if (e.Key != Key.Enter) return;
                cleanUpHandlers();

                tcs.TrySetResult(null);
            };

            okHandler = (sender, e) =>
            {
                cleanUpHandlers();

                tcs.TrySetResult(null);

                e.Handled = true;
            };

            PART_OkButton.KeyDown += okKeyHandler;

            KeyDown += escapeKeyHandler;

            PART_OkButton.Click += okHandler;

            return tcs.Task;
        }

        internal Task<MessageDialogResult> WaitForButtonPressAsync()
        {
            AffirmativeButton.Focus();

            TaskCompletionSource<MessageDialogResult> tcs = new TaskCompletionSource<MessageDialogResult>();

            RoutedEventHandler negativeHandler = null;
            RoutedEventHandler affirmativeHandler = null;

            negativeHandler = new RoutedEventHandler((sender, e) =>
                {
                    NegativeButton.Click -= negativeHandler;
                    AffirmativeButton.Click -= affirmativeHandler;

                    tcs.TrySetResult(MessageDialogResult.Negative);
                });

            affirmativeHandler = new RoutedEventHandler((sender, e) =>
                {
                    NegativeButton.Click -= negativeHandler;
                    AffirmativeButton.Click -= affirmativeHandler;

                    tcs.TrySetResult(MessageDialogResult.Affirmative);
                });

            NegativeButton.Click += negativeHandler;
            AffirmativeButton.Click += affirmativeHandler;

            return tcs.Task;
        }

        /// <summary>
        /// Callback method once the login method is successfull.
        /// </summary>
        /// <param name="uri"></param>
        /// <param name="tcs"></param>
        protected static void OnSuccess(Uri uri, TaskCompletionSource<OAuthResult> tcs)
        {
            var queryParams = uri.Query;
            var parts = queryParams.Split('&');
            var queryMap = parts.Select(t => t.Split('=')).ToDictionary(kv => kv[0], kv => kv[1]);

            string result;
            queryMap.TryGetValue("result", out result);
            if ("success" == result)
            {
                string sessionToken;
                string authRes;
                queryMap.TryGetValue("fh_auth_session", out sessionToken);
                queryMap.TryGetValue("authResponse", out authRes);
                var oauthResult = new OAuthResult(OAuthResult.ResultCode.Ok, sessionToken,
                    Uri.UnescapeDataString(authRes));
                tcs.TrySetResult(oauthResult);
            }
            else
            {
                string errorMessage;
                queryMap.TryGetValue("message", out errorMessage);
                var oauthResult = new OAuthResult(OAuthResult.ResultCode.Failed, new Exception(errorMessage));
                tcs.TrySetResult(oauthResult);
            }
        }

        public async Task<string> WaitForChangeAsync(CancellationToken cancellationToken)
        {
            _watchedFiles = GetProjectFilesClosure(_rootProject);

            foreach (var file in _watchedFiles)
            {
                _fileWatcher.WatchDirectory(Path.GetDirectoryName(file));
            }

            var tcs = new TaskCompletionSource<string>();
            cancellationToken.Register(() => tcs.TrySetResult(null));

            Action<string> callback = path =>
            {
                // If perf becomes a problem, this could be a good starting point
                // because it reparses the project on every change
                // Maybe it could time-buffer the changes in case there are a lot
                // of files changed at the same time
                if (IsFileInTheWatchedSet(path))
                {
                    tcs.TrySetResult(path);
                }
            };

            _fileWatcher.OnFileChange += callback;
            var changedFile = await tcs.Task;
            _fileWatcher.OnFileChange -= callback;

            return changedFile;
        }

		public Task<ConfigurationResponse> GetConfigurationAsync () {
			var tcs = new TaskCompletionSource<ConfigurationResponse> ();
			Task.Factory.StartNew (async () => {
				var urlString = String.Format (SharedConstants.GetConfigurationUriFormatString, SharedConstants.ApiKey);
				var cacheKey = this.getCacheKey (urlString);
				if (this.configuration != null) {
					tcs.TrySetResult (this.configuration);
				} else {
					if (cache.ContainsKey(cacheKey)) {
						var response = cache.Get<ConfigurationResponse>(cacheKey);
						this.configuration = response;
						tcs.TrySetResult (this.configuration);
					} else {
						var client = this.httpClientFactory.Create ();
						var response = await client.GetAsync (urlString);
						var json = await response.Content.ReadAsStringAsync ();
						var result = JsonConvert.DeserializeObject<ConfigurationResponse> (json);
						this.configuration = result;
						cache.Set<ConfigurationResponse> (cacheKey, this.configuration);
						tcs.TrySetResult (this.configuration);
					}
				}
			});
			return tcs.Task;
		}

        public Task<Contact[]> GetAllAsync()
        {
            var taskCompletionSource = new TaskCompletionSource<Contact[]>();

            NSError err;
            var ab = ABAddressBook.Create(out err);
            if (err != null)
            {
                // process error
                return Task.FromResult(new Contact[0]);
            }
            // if the app was not authorized then we need to ask permission
            if (ABAddressBook.GetAuthorizationStatus() != ABAuthorizationStatus.Authorized)
            {
                ab.RequestAccess(delegate(bool granted, NSError error)
                {
                    if (error != null)
                    {
                        taskCompletionSource.TrySetResult(new Contact[0]);
                    }
                    else if (granted)
                    {
                        Task.Run(() => taskCompletionSource.TrySetResult(GetContacts(ab)));
                    }
                });
            }
            else
            {
                Task.Run(() => taskCompletionSource.TrySetResult(GetContacts(ab)));
            } 

            return taskCompletionSource.Task;
        }

        public Task<string> ShowFolderDialogAsync(OpenFolderDialog dialog, IWindowImpl parent)
        {
            var tcs = new TaskCompletionSource<string>();
            var dlg = new global::Gtk.FileChooserDialog(dialog.Title, ((WindowImpl)parent),
                FileChooserAction.SelectFolder,
                "Cancel", ResponseType.Cancel,
                "Select Folder", ResponseType.Accept)
            {

            };

            dlg.Modal = true;

            dlg.Response += (_, args) =>
            {
                if (args.ResponseId == ResponseType.Accept)
                    tcs.TrySetResult(dlg.Filename);

                dlg.Hide();
                dlg.Dispose();
            };

            dlg.Close += delegate
            {
                tcs.TrySetResult(null);
                dlg.Dispose();
            };
            dlg.Show();
            return tcs.Task;
        }