/// <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; }
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); }
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); }
public static Task ChainFailureHandler(this Task task, string message) { // create a handler that will raise an exception if an operation fails... return task.ContinueWith((t) => { }, TaskContinuationOptions.OnlyOnFaulted); }
public static Task IgnoreExceptions(this Task task) { task.ContinueWith( t => { var ignored = t.Exception; }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); return task; }
/// <summary> /// Logs the and then ignores the exceptions thrown from the task if any. /// </summary> /// <param name="self">The task itself</param> /// <param name="logger">Logger to log against</param> /// <param name="msg">Optional message to be included</param> /// <param name="logLevel">Optional parameter to set log level</param> public static void LogAndIgnoreExceptionIfAny(this Task self, Logger logger, string msg = "", Level logLevel = Level.Error) { self.ContinueWith(t => { // ReSharper disable once PossibleNullReferenceException ; We know the task is Faulted logger.Log(logLevel, "{0} Exception:{1}", t.Exception.GetBaseException()); }, TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously); }
public static void LogAggregateExceptions(this Task task) { task.ContinueWith(t => { var aggregateException = t.Exception.Flatten(); foreach (var ex in aggregateException.InnerExceptions) Trace.TraceError(ex.ToString()); }, TaskContinuationOptions.OnlyOnFaulted); }
public static Task<IEnumerable<User>> FromEntitiesAsync(this Task<List<UserEntity>> userEntities) { return userEntities.ContinueWith(task => { task.ThrowIfFaulted(); var entities = task.Result; return entities.FromEntity(); }, TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.ExecuteSynchronously); }
public static void LogExceptions(this Task task, Action<Exception> logException) { task.ContinueWith(t => { var aggException = t.Exception.Flatten(); foreach (var exception in aggException.InnerExceptions) logException(exception); }, TaskContinuationOptions.OnlyOnFaulted); }
public static Task ContinueFaultWith(this Task task, Action<Task> continuationAction) { return task.ContinueWith(_ => { if(_.IsFaulted) { continuationAction(_); } }); }
public static void LogOnFaulure(this Task task) { task.ContinueWith( t => { // todo: log Console.WriteLine(t.Exception); }, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted); }
public static void LogExceptions(this Task task) { task.ContinueWith(t => { var aggException = t.Exception.Flatten(); foreach (var exception in aggException.InnerExceptions) Logger.WriteLog(exception, "Task异常"); }, TaskContinuationOptions.OnlyOnFaulted); }
// adapted from http://blogs.planetsoftware.com.au/paul/archive/2010/12/05/waiting-for-a-task-donrsquot-block-the-main-ui-thread.aspx public static void WaitWithPumping(this Task task) { if (task == null) return; var nestedFrame = new DispatcherFrame(); task.ContinueWith(_ => nestedFrame.Continue = false); Dispatcher.PushFrame(nestedFrame); task.Wait(); }
public static Task<User> FromEntityAsync(this Task<UserEntity> userTask) { return userTask.ContinueWith(task => { task.ThrowIfFaulted(); var entity = task.Result; return FromEntity(entity); }, TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.ExecuteSynchronously); }
/// <summary> /// Rethrows exceptions thrown during task execution in thespecified dispatcher thread. /// </summary> /// <param name="task">The task.</param> /// <param name="dispatcher">The dispatcher.</param> /// <returns></returns> public static Task WithExceptionThrowingInDispatcher(this Task task, Dispatcher dispatcher) { return task.ContinueWith(t => { dispatcher.BeginInvoke(() => { throw t.Exception; }, DispatcherPriority.Send); }, TaskContinuationOptions.OnlyOnFaulted); }
public static Task HandleExceptions(this Task task, Action<Exception> onException = null) { return task.ContinueWith(t => { var exception = t.Exception.Flatten(); onException = onException ?? (exc => Trace.WriteLine(exc, "Task.HandleExceptions")); foreach (var ex in exception.InnerExceptions) onException(ex); }, TaskContinuationOptions.OnlyOnFaulted); }
public static void HandleExceptions(this Task task, Action<Exception> Handler) { task.ContinueWith(t => { if (t != null && t.Exception != null) { AggregateException aggException = t.Exception.Flatten(); foreach (Exception exception in aggException.InnerExceptions) { Handler(exception); } } }, TaskContinuationOptions.OnlyOnFaulted); }
public static void FireAndForget(this Task task) { task.ContinueWith(t => { if (t.IsFaulted) { var aggException = t.Exception.Flatten(); foreach(var exception in aggException.InnerExceptions) System.Diagnostics.Debug.WriteLine("Fire and Forget failed: " + exception.Message + " - " + exception.StackTrace); } }); }