C# this.ContinueWith方法代码示例

        public static void ExecuteContinueWithInternal(this Task task,Action successAction,Action exceptionAction,
            Action cancellationAction)
        {
            task.ContinueWith(p => successAction(),
                TaskContinuationOptions.OnlyOnRanToCompletion);

            task.ContinueWith(p => exceptionAction(), TaskContinuationOptions.NotOnFaulted);

            task.ContinueWith(p => cancellationAction(),
                              TaskContinuationOptions.OnlyOnCanceled);
        }

        /// <summary>
        /// A helper method for mocking APM (classic) asynchronous methods with on TAP (modern) asynchronous methods.
        /// </summary>
        /// <remarks>
        /// This is based on <a href="http://blogs.msdn.com/b/pfxteam/archive/2011/06/27/10179452.aspx"/> 
        /// and <a href="http://msdn.microsoft.com/en-us/library/hh873178.aspx"/>.
        /// </remarks>
        public static IAsyncResult AsAsyncResult(this Task task, AsyncCallback callback, object state)
        {
            Debug.Assert(task != null, "task");

            var taskCompletionSource = new TaskCompletionSource<object>(state);
            task.ContinueWith(
                t =>
                {
                    if (t.IsFaulted)
                    {
                        taskCompletionSource.TrySetException(t.Exception.InnerExceptions);
                    }
                    else if (t.IsCanceled)
                    {
                        taskCompletionSource.TrySetCanceled();
                    }
                    else
                    {
                        taskCompletionSource.SetResult(null);
                    }

                    if (callback != null)
                    {
                         callback(taskCompletionSource.Task);
                    }
                },
                TaskScheduler.Default);

            return taskCompletionSource.Task;
        }

		internal static Task ToApm(this Task task, AsyncCallback callback, object state) {
			if (task == null) {
				throw new ArgumentNullException("task");
			}

			var tcs = new TaskCompletionSource<object>(state);
			task.ContinueWith(
				t => {
					if (t.IsFaulted) {
						tcs.TrySetException(t.Exception.InnerExceptions);
					} else if (t.IsCanceled) {
						tcs.TrySetCanceled();
					} else {
						tcs.TrySetResult(null);
					}

					if (callback != null) {
						callback(tcs.Task);
					}
				},
				CancellationToken.None,
				TaskContinuationOptions.None,
				TaskScheduler.Default);

			return tcs.Task;
		}

 // The unobserved task handler extention. simply  observes the exception and do nothing.
 public static Task IgnoreExceptions(this Task task)
 {
     task.ContinueWith(c => { var ignored = c.Exception; },
         TaskContinuationOptions.OnlyOnFaulted |
         TaskContinuationOptions.ExecuteSynchronously);
     return task;
 }

		/// <summary>
		/// A Task extension method that converts this object to an IAsyncResult.
		/// </summary>
		/// <remarks>
		/// Mark, 19/06/2012.
		/// Props to Stephen Toub for this blog post:
		/// http://blogs.msdn.com/b/pfxteam/archive/2011/06/27/10179452.aspx
		/// </remarks>
		/// <param name="task"> The task to act on.</param>
		/// <param name="callback">The callback.</param>
		/// <param name="state">The state.</param>
		/// <returns>
		/// The given data converted to an IAsyncResult-y Task.
		/// </returns>
		public static Task ToApm(this Task task, AsyncCallback callback, object state)
		{
			task = task ?? MakeCompletedTask();
			var tcs = new TaskCompletionSource<object>();
			task.ContinueWith(t =>
			{
				if (t.IsFaulted)
				{
					tcs.TrySetException(t.Exception.InnerExceptions);
				}
				else if (t.IsCanceled)
				{
					tcs.TrySetCanceled();
				}
				else
				{
					tcs.TrySetResult(null);
				}

				if (callback != null)
				{
					callback(tcs.Task);
				}
			}, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);
			return tcs.Task;
		}

 public static void Forget(this Task task)
 {
     task.ContinueWith(t =>
     {
         var e = t.Exception;
     });
 }

 public static void Forget(this Task task)
 {
     task.ContinueWith(t =>
     {
         Debugger.Break();
     }, TaskContinuationOptions.OnlyOnFaulted);
 }

 public static void LogOnException(this Task task)
 {
     task.ContinueWith(t =>
         {
             Log.Error("Exception thrown in task started with LogOnException()", t.Exception);
         },
         TaskContinuationOptions.OnlyOnFaulted);
 }

        public static void Ignore(this Task task)
        {
            Contract.Requires(task != null);

            // ReSharper disable CSharpWarnings::CS4014
            task.ContinueWith(t => t.Exception, TaskContinuationOptions.OnlyOnFaulted);
            // ReSharper restore CSharpWarnings::CS4014
        }

 public static Task Catch(this Task task)
 {
     return task.ContinueWith(t =>
     {
         if (t.Exception != null)
             t.Exception.Handle(OnException);
     }, TaskContinuationOptions.OnlyOnFaulted);
 }

 /// <summary>
 /// Observes any exceptions thrown by a task and performs an Action on them. (ie: logging). This does not occur on task cancellation. Recommended that you iterate over AggregateException.InnerExceptions in this.
 /// </summary>
 /// <param name="task"></param>
 /// <param name="action"></param>
 /// <returns></returns>
 public static Task OnExceptions(this Task task, Action<AggregateException> action)
 {
     task.ContinueWith(t =>
     {
         action(t.Exception.Flatten());
     }, TaskContinuationOptions.OnlyOnFaulted);
     return task;
 }

 public static void WaitWithPumping(this Task task)
 {
     if (task == null) throw new ArgumentNullException("task");
     var nestedFrame = new DispatcherFrame();
     task.ContinueWith(_ => nestedFrame.Continue = false);
     Dispatcher.PushFrame(nestedFrame);
     task.Wait();
 }

        public static void Wait(this Task t)
        {
            var e = new System.Threading.ManualResetEvent(false);

            t.ContinueWith(_ => e.Set());

            e.WaitOne();
        }

 public static Task FailFastOnException(this Task task)
 {
     task.ContinueWith(c =>
         Environment.FailFast(
             "An unhandled exception occurred in a background task",  c.Exception),
         TaskContinuationOptions.OnlyOnFaulted |  TaskContinuationOptions.ExecuteSynchronously);
     return task;
 }

 public static void FireAndForget(this Task task,string taskName,Action<Task> errorHandler=null)
 {
     if (errorHandler == null)
     {
         errorHandler = t => taskName.LogError(t.Exception);
     }
     task.ContinueWith(errorHandler, TaskContinuationOptions.OnlyOnFaulted);
 }