5 // Marek Safar <marek.safar@gmail.com>
6 // Jérémie Laval <jeremie dot laval at xamarin dot com>
8 // Copyright (c) 2008 Jérémie "Garuma" Laval
9 // Copyright 2011-2013 Xamarin Inc (http://www.xamarin.com).
11 // Permission is hereby granted, free of charge, to any person obtaining a copy
12 // of this software and associated documentation files (the "Software"), to deal
13 // in the Software without restriction, including without limitation the rights
14 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 // copies of the Software, and to permit persons to whom the Software is
16 // furnished to do so, subject to the following conditions:
18 // The above copyright notice and this permission notice shall be included in
19 // all copies or substantial portions of the Software.
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
34 using System.Threading;
35 using System.Collections.Concurrent;
36 using System.Collections.Generic;
37 using System.Runtime.CompilerServices;
39 namespace System.Threading.Tasks
41 [System.Diagnostics.DebuggerDisplay ("Id = {Id}, Status = {Status}")]
42 [System.Diagnostics.DebuggerTypeProxy (typeof (TaskDebuggerView))]
43 public class Task : IDisposable, IAsyncResult
45 // With this attribute each thread has its own value so that it's correct for our Schedule code
46 // and for Parent property.
50 // parent is the outer task in which this task is created
52 // contAncestor is the Task on which this continuation was setup
53 readonly Task contAncestor;
56 static readonly TaskFactory defaultFactory = new TaskFactory ();
58 CountdownEvent childTasks;
61 TaskCreationOptions creationOptions;
63 internal TaskScheduler scheduler;
65 TaskExceptionSlot exSlot;
66 ManualResetEvent wait_handle;
70 TaskActionInvoker invoker;
72 internal AtomicBooleanValue executing;
74 TaskCompletionQueue<IContinuation> continuations;
76 CancellationToken token;
77 CancellationTokenRegistration? cancellationRegistration;
79 internal const TaskCreationOptions WorkerTaskNotSupportedOptions = TaskCreationOptions.LongRunning | TaskCreationOptions.PreferFairness;
81 const TaskCreationOptions MaxTaskCreationOptions =
83 TaskCreationOptions.DenyChildAttach | TaskCreationOptions.HideScheduler |
85 TaskCreationOptions.PreferFairness | TaskCreationOptions.LongRunning | TaskCreationOptions.AttachedToParent;
87 public Task (Action action)
88 : this (action, TaskCreationOptions.None)
93 public Task (Action action, TaskCreationOptions creationOptions)
94 : this (action, CancellationToken.None, creationOptions)
99 public Task (Action action, CancellationToken cancellationToken)
100 : this (action, cancellationToken, TaskCreationOptions.None)
105 public Task (Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
106 : this (TaskActionInvoker.Create (action), null, cancellationToken, creationOptions, current)
109 throw new ArgumentNullException ("action");
110 if (creationOptions > MaxTaskCreationOptions || creationOptions < TaskCreationOptions.None)
111 throw new ArgumentOutOfRangeException ("creationOptions");
114 public Task (Action<object> action, object state)
115 : this (action, state, TaskCreationOptions.None)
119 public Task (Action<object> action, object state, TaskCreationOptions creationOptions)
120 : this (action, state, CancellationToken.None, creationOptions)
124 public Task (Action<object> action, object state, CancellationToken cancellationToken)
125 : this (action, state, cancellationToken, TaskCreationOptions.None)
129 public Task (Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions)
130 : this (TaskActionInvoker.Create (action), state, cancellationToken, creationOptions, current)
133 throw new ArgumentNullException ("action");
134 if (creationOptions > MaxTaskCreationOptions || creationOptions < TaskCreationOptions.None)
135 throw new ArgumentOutOfRangeException ("creationOptions");
138 internal Task (TaskActionInvoker invoker, object state, CancellationToken cancellationToken,
139 TaskCreationOptions creationOptions, Task parent = null, Task contAncestor = null, bool ignoreCancellation = false)
141 this.invoker = invoker;
142 this.creationOptions = creationOptions;
144 this.taskId = Interlocked.Increment (ref id);
145 this.token = cancellationToken;
146 this.parent = parent = parent == null ? current : parent;
147 this.contAncestor = contAncestor;
148 this.status = cancellationToken.IsCancellationRequested && !ignoreCancellation ? TaskStatus.Canceled : TaskStatus.Created;
150 // Process creationOptions
152 if (parent != null && HasFlag (creationOptions, TaskCreationOptions.AttachedToParent)
153 && !HasFlag (parent.CreationOptions, TaskCreationOptions.DenyChildAttach))
155 if (parent != null && HasFlag (creationOptions, TaskCreationOptions.AttachedToParent))
159 if (token.CanBeCanceled && !ignoreCancellation)
160 cancellationRegistration = token.Register (l => ((Task) l).CancelReal (), this);
163 static bool HasFlag (TaskCreationOptions opt, TaskCreationOptions member)
165 return (opt & member) == member;
171 Start (TaskScheduler.Current);
174 public void Start (TaskScheduler scheduler)
176 if (scheduler == null)
177 throw new ArgumentNullException ("scheduler");
179 if (status >= TaskStatus.WaitingToRun)
180 throw new InvalidOperationException ("The Task is not in a valid state to be started.");
183 throw new InvalidOperationException ("Start may not be called on a continuation task");
185 SetupScheduler (scheduler);
189 internal void SetupScheduler (TaskScheduler scheduler)
191 this.scheduler = scheduler;
192 Status = TaskStatus.WaitingForActivation;
195 public void RunSynchronously ()
197 RunSynchronously (TaskScheduler.Current);
200 public void RunSynchronously (TaskScheduler scheduler)
202 if (scheduler == null)
203 throw new ArgumentNullException ("scheduler");
205 if (Status > TaskStatus.WaitingForActivation)
206 throw new InvalidOperationException ("The task is not in a valid state to be started");
209 throw new InvalidOperationException ("RunSynchronously may not be called on a continuation task");
211 RunSynchronouslyCore (scheduler);
214 internal void RunSynchronouslyCore (TaskScheduler scheduler)
216 SetupScheduler (scheduler);
217 var saveStatus = status;
218 Status = TaskStatus.WaitingToRun;
221 if (scheduler.RunInline (this, false))
223 } catch (Exception inner) {
224 throw new TaskSchedulerException (inner);
234 public Task ContinueWith (Action<Task> continuationAction)
236 return ContinueWith (continuationAction, TaskContinuationOptions.None);
239 public Task ContinueWith (Action<Task> continuationAction, TaskContinuationOptions continuationOptions)
241 return ContinueWith (continuationAction, CancellationToken.None, continuationOptions, TaskScheduler.Current);
244 public Task ContinueWith (Action<Task> continuationAction, CancellationToken cancellationToken)
246 return ContinueWith (continuationAction, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Current);
249 public Task ContinueWith (Action<Task> continuationAction, TaskScheduler scheduler)
251 return ContinueWith (continuationAction, CancellationToken.None, TaskContinuationOptions.None, scheduler);
254 public Task ContinueWith (Action<Task> continuationAction, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
256 if (continuationAction == null)
257 throw new ArgumentNullException ("continuationAction");
258 if (scheduler == null)
259 throw new ArgumentNullException ("scheduler");
261 return ContinueWith (TaskActionInvoker.Create (continuationAction), cancellationToken, continuationOptions, scheduler);
264 internal Task ContinueWith (TaskActionInvoker invoker, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
266 var lazyCancellation = false;
268 lazyCancellation = (continuationOptions & TaskContinuationOptions.LazyCancellation) > 0;
270 var continuation = new Task (invoker, null, cancellationToken, GetCreationOptions (continuationOptions), null, this, lazyCancellation);
271 ContinueWithCore (continuation, continuationOptions, scheduler);
276 public Task<TResult> ContinueWith<TResult> (Func<Task, TResult> continuationFunction)
278 return ContinueWith<TResult> (continuationFunction, TaskContinuationOptions.None);
281 public Task<TResult> ContinueWith<TResult> (Func<Task, TResult> continuationFunction, TaskContinuationOptions continuationOptions)
283 return ContinueWith<TResult> (continuationFunction, CancellationToken.None, continuationOptions, TaskScheduler.Current);
286 public Task<TResult> ContinueWith<TResult> (Func<Task, TResult> continuationFunction, CancellationToken cancellationToken)
288 return ContinueWith<TResult> (continuationFunction, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Current);
291 public Task<TResult> ContinueWith<TResult> (Func<Task, TResult> continuationFunction, TaskScheduler scheduler)
293 return ContinueWith<TResult> (continuationFunction, CancellationToken.None, TaskContinuationOptions.None, scheduler);
296 public Task<TResult> ContinueWith<TResult> (Func<Task, TResult> continuationFunction, CancellationToken cancellationToken,
297 TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
299 if (continuationFunction == null)
300 throw new ArgumentNullException ("continuationFunction");
301 if (scheduler == null)
302 throw new ArgumentNullException ("scheduler");
304 return ContinueWith<TResult> (TaskActionInvoker.Create (continuationFunction), cancellationToken, continuationOptions, scheduler);
307 internal Task<TResult> ContinueWith<TResult> (TaskActionInvoker invoker, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
309 var lazyCancellation = false;
311 lazyCancellation = (continuationOptions & TaskContinuationOptions.LazyCancellation) > 0;
313 var continuation = new Task<TResult> (invoker, null, cancellationToken, GetCreationOptions (continuationOptions), parent, this, lazyCancellation);
314 ContinueWithCore (continuation, continuationOptions, scheduler);
319 internal void ContinueWithCore (Task continuation, TaskContinuationOptions options, TaskScheduler scheduler)
321 const TaskContinuationOptions wrongRan = TaskContinuationOptions.NotOnRanToCompletion | TaskContinuationOptions.OnlyOnRanToCompletion;
322 const TaskContinuationOptions wrongCanceled = TaskContinuationOptions.NotOnCanceled | TaskContinuationOptions.OnlyOnCanceled;
323 const TaskContinuationOptions wrongFaulted = TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.OnlyOnFaulted;
325 if (((options & wrongRan) == wrongRan) || ((options & wrongCanceled) == wrongCanceled) || ((options & wrongFaulted) == wrongFaulted))
326 throw new ArgumentException ("continuationOptions", "Some options are mutually exclusive");
328 // Already set the scheduler so that user can call Wait and that sort of stuff
329 continuation.scheduler = scheduler;
330 continuation.Status = TaskStatus.WaitingForActivation;
332 ContinueWith (new TaskContinuation (continuation, options));
335 internal void ContinueWith (IContinuation continuation)
338 continuation.Execute ();
342 continuations.Add (continuation);
344 // Retry in case completion was achieved but event adding was too late
345 if (IsCompleted && continuations.Remove (continuation))
346 continuation.Execute ();
349 internal void RemoveContinuation (IContinuation continuation)
351 continuations.Remove (continuation);
354 static internal TaskCreationOptions GetCreationOptions (TaskContinuationOptions kind)
356 TaskCreationOptions options = TaskCreationOptions.None;
357 if ((kind & TaskContinuationOptions.AttachedToParent) > 0)
358 options |= TaskCreationOptions.AttachedToParent;
359 if ((kind & TaskContinuationOptions.PreferFairness) > 0)
360 options |= TaskCreationOptions.PreferFairness;
361 if ((kind & TaskContinuationOptions.LongRunning) > 0)
362 options |= TaskCreationOptions.LongRunning;
368 #region Internal and protected thingies
369 internal void Schedule ()
371 Status = TaskStatus.WaitingToRun;
372 scheduler.QueueTask (this);
377 /* Allow scheduler to break fairness of deque ordering without
378 * breaking its semantic (the task can be executed twice but the
379 * second time it will return immediately
381 if (!executing.TryRelaxedSet ())
384 // Disable CancellationToken direct cancellation
385 if (cancellationRegistration != null) {
386 cancellationRegistration.Value.Dispose ();
387 cancellationRegistration = null;
390 // If Task are ran inline on the same thread we might trash these values
391 var saveCurrent = current;
392 var saveScheduler = TaskScheduler.Current;
396 TaskScheduler.Current = HasFlag (creationOptions, TaskCreationOptions.HideScheduler) ? TaskScheduler.Default : scheduler;
398 TaskScheduler.Current = scheduler;
401 if (!token.IsCancellationRequested) {
403 status = TaskStatus.Running;
407 } catch (OperationCanceledException oce) {
408 if (token != CancellationToken.None && oce.CancellationToken == token)
411 HandleGenericException (oce);
412 } catch (Exception e) {
413 HandleGenericException (e);
419 if (saveCurrent != null)
420 current = saveCurrent;
421 if (saveScheduler != null)
422 TaskScheduler.Current = saveScheduler;
426 internal bool TrySetCanceled ()
431 if (!executing.TryRelaxedSet ()) {
432 var sw = new SpinWait ();
443 internal bool TrySetException (AggregateException aggregate)
448 if (!executing.TryRelaxedSet ()) {
449 var sw = new SpinWait ();
456 HandleGenericException (aggregate);
460 internal bool TrySetExceptionObserved ()
462 if (exSlot != null) {
463 exSlot.Observed = true;
469 internal void Execute ()
474 internal void AddChild ()
476 if (childTasks == null)
477 Interlocked.CompareExchange (ref childTasks, new CountdownEvent (1), null);
478 childTasks.AddCount ();
481 internal void ChildCompleted (AggregateException childEx)
483 if (childEx != null) {
484 if (ExceptionSlot.ChildExceptions == null)
485 Interlocked.CompareExchange (ref ExceptionSlot.ChildExceptions, new ConcurrentQueue<AggregateException> (), null);
486 ExceptionSlot.ChildExceptions.Enqueue (childEx);
489 if (childTasks.Signal () && status == TaskStatus.WaitingForChildrenToComplete) {
490 ProcessChildExceptions ();
491 Status = exSlot == null ? TaskStatus.RanToCompletion : TaskStatus.Faulted;
492 ProcessCompleteDelegates ();
493 if (parent != null &&
495 !HasFlag (parent.CreationOptions, TaskCreationOptions.DenyChildAttach) &&
497 HasFlag (creationOptions, TaskCreationOptions.AttachedToParent))
498 parent.ChildCompleted (this.Exception);
504 if (IsContinuation) {
505 invoker.Invoke (contAncestor, state, this);
507 invoker.Invoke (this, state, this);
511 internal void Finish ()
513 // If there was children created and they all finished, we set the countdown
514 if (childTasks != null) {
515 if (childTasks.Signal ())
516 ProcessChildExceptions (true);
519 // Don't override Canceled or Faulted
520 if (status == TaskStatus.Running) {
521 if (childTasks == null || childTasks.IsSet)
522 Status = TaskStatus.RanToCompletion;
524 Status = TaskStatus.WaitingForChildrenToComplete;
527 if (wait_handle != null)
530 // Tell parent that we are finished
531 if (parent != null && HasFlag (creationOptions, TaskCreationOptions.AttachedToParent) &&
533 !HasFlag (parent.CreationOptions, TaskCreationOptions.DenyChildAttach) &&
535 status != TaskStatus.WaitingForChildrenToComplete) {
536 parent.ChildCompleted (this.Exception);
539 // Completions are already processed when task is canceled or faulted
540 if (status == TaskStatus.RanToCompletion)
541 ProcessCompleteDelegates ();
543 // Reset the current thingies
546 if (TaskScheduler.Current == scheduler)
547 TaskScheduler.Current = null;
549 if (cancellationRegistration.HasValue)
550 cancellationRegistration.Value.Dispose ();
553 void ProcessCompleteDelegates ()
555 if (continuations.HasElements) {
556 IContinuation continuation;
557 while (continuations.TryGetNextCompletion (out continuation))
558 continuation.Execute ();
562 void ProcessChildExceptions (bool isParent = false)
564 if (exSlot == null || exSlot.ChildExceptions == null)
567 if (ExceptionSlot.Exception == null)
568 exSlot.Exception = new AggregateException ();
570 AggregateException childEx;
571 while (exSlot.ChildExceptions.TryDequeue (out childEx))
572 exSlot.Exception.AddChildException (childEx);
575 Status = TaskStatus.Faulted;
576 ProcessCompleteDelegates ();
581 #region Cancel and Wait related method
583 internal void CancelReal ()
585 Status = TaskStatus.Canceled;
587 if (wait_handle != null)
590 ProcessCompleteDelegates ();
593 void HandleGenericException (Exception e)
595 HandleGenericException (new AggregateException (e));
598 void HandleGenericException (AggregateException e)
600 ExceptionSlot.Exception = e;
601 Thread.MemoryBarrier ();
602 Status = TaskStatus.Faulted;
604 if (wait_handle != null)
607 ProcessCompleteDelegates ();
610 internal bool WaitOnChildren ()
612 if (Status == TaskStatus.WaitingForChildrenToComplete && childTasks != null) {
621 Wait (Timeout.Infinite, CancellationToken.None);
624 public void Wait (CancellationToken cancellationToken)
626 Wait (Timeout.Infinite, cancellationToken);
629 public bool Wait (TimeSpan timeout)
631 return Wait (CheckTimeout (timeout), CancellationToken.None);
634 public bool Wait (int millisecondsTimeout)
636 return Wait (millisecondsTimeout, CancellationToken.None);
639 public bool Wait (int millisecondsTimeout, CancellationToken cancellationToken)
641 if (millisecondsTimeout < -1)
642 throw new ArgumentOutOfRangeException ("millisecondsTimeout");
644 bool result = WaitCore (millisecondsTimeout, cancellationToken);
647 throw new AggregateException (new TaskCanceledException (this));
649 var exception = Exception;
650 if (exception != null)
656 internal bool WaitCore (int millisecondsTimeout, CancellationToken cancellationToken)
661 // If the task is ready to be run and we were supposed to wait on it indefinitely without cancellation, just run it
662 if (Status == TaskStatus.WaitingToRun && millisecondsTimeout == Timeout.Infinite && scheduler != null && !cancellationToken.CanBeCanceled)
663 scheduler.RunInline (this, true);
668 var continuation = new ManualResetContinuation ();
670 ContinueWith (continuation);
671 result = continuation.Event.Wait (millisecondsTimeout, cancellationToken);
674 RemoveContinuation (continuation);
675 continuation.Dispose ();
682 public static void WaitAll (params Task[] tasks)
684 WaitAll (tasks, Timeout.Infinite, CancellationToken.None);
687 public static void WaitAll (Task[] tasks, CancellationToken cancellationToken)
689 WaitAll (tasks, Timeout.Infinite, cancellationToken);
692 public static bool WaitAll (Task[] tasks, TimeSpan timeout)
694 return WaitAll (tasks, CheckTimeout (timeout), CancellationToken.None);
697 public static bool WaitAll (Task[] tasks, int millisecondsTimeout)
699 return WaitAll (tasks, millisecondsTimeout, CancellationToken.None);
702 public static bool WaitAll (Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
705 throw new ArgumentNullException ("tasks");
708 foreach (var t in tasks) {
710 throw new ArgumentException ("tasks", "the tasks argument contains a null element");
712 result &= t.Status == TaskStatus.RanToCompletion;
716 var continuation = new CountdownContinuation (tasks.Length);
718 foreach (var t in tasks)
719 t.ContinueWith (continuation);
721 result = continuation.Event.Wait (millisecondsTimeout, cancellationToken);
723 List<Exception> exceptions = null;
725 foreach (var t in tasks) {
727 if (t.Status == TaskStatus.RanToCompletion)
729 if (exceptions == null)
730 exceptions = new List<Exception> ();
731 if (t.Exception != null)
732 exceptions.AddRange (t.Exception.InnerExceptions);
734 exceptions.Add (new TaskCanceledException (t));
736 t.RemoveContinuation (continuation);
740 continuation.Dispose ();
742 if (exceptions != null)
743 throw new AggregateException (exceptions);
750 public static int WaitAny (params Task[] tasks)
752 return WaitAny (tasks, Timeout.Infinite, CancellationToken.None);
755 public static int WaitAny (Task[] tasks, TimeSpan timeout)
757 return WaitAny (tasks, CheckTimeout (timeout));
760 public static int WaitAny (Task[] tasks, int millisecondsTimeout)
762 return WaitAny (tasks, millisecondsTimeout, CancellationToken.None);
765 public static int WaitAny (Task[] tasks, CancellationToken cancellationToken)
767 return WaitAny (tasks, Timeout.Infinite, cancellationToken);
770 public static int WaitAny (Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
773 throw new ArgumentNullException ("tasks");
774 if (millisecondsTimeout < -1)
775 throw new ArgumentOutOfRangeException ("millisecondsTimeout");
776 CheckForNullTasks (tasks);
778 if (tasks.Length > 0) {
779 var continuation = new ManualResetContinuation ();
782 for (int i = 0; i < tasks.Length; i++) {
786 t.ContinueWith (continuation);
789 if (!(result = continuation.Event.Wait (millisecondsTimeout, cancellationToken)))
793 foreach (var t in tasks)
794 t.RemoveContinuation (continuation);
795 continuation.Dispose ();
799 int firstFinished = -1;
800 for (int i = 0; i < tasks.Length; i++) {
808 return firstFinished;
811 static int CheckTimeout (TimeSpan timeout)
814 return checked ((int)timeout.TotalMilliseconds);
815 } catch (System.OverflowException) {
816 throw new ArgumentOutOfRangeException ("timeout");
820 static void CheckForNullTasks (Task[] tasks)
822 foreach (var t in tasks)
824 throw new ArgumentException ("tasks", "the tasks argument contains a null element");
829 public void Dispose ()
834 protected virtual void Dispose (bool disposing)
837 throw new InvalidOperationException ("A task may only be disposed if it is in a completion state");
839 // Set action to null so that the GC can collect the delegate and thus
840 // any big object references that the user might have captured in a anonymous method
844 if (cancellationRegistration != null)
845 cancellationRegistration.Value.Dispose ();
846 if (wait_handle != null)
847 wait_handle.Dispose ();
857 Task ContinueWith (Action<Task, object> continuationAction, object state, CancellationToken cancellationToken,
858 TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
860 if (continuationAction == null)
861 throw new ArgumentNullException ("continuationAction");
862 if (scheduler == null)
863 throw new ArgumentNullException ("scheduler");
865 Task continuation = new Task (TaskActionInvoker.Create (continuationAction),
866 state, cancellationToken,
867 GetCreationOptions (continuationOptions),
870 ContinueWithCore (continuation, continuationOptions, scheduler);
877 public ConfiguredTaskAwaitable ConfigureAwait (bool continueOnCapturedContext)
879 return new ConfiguredTaskAwaitable (this, continueOnCapturedContext);
882 public Task ContinueWith (Action<Task, object> continuationAction, object state)
884 return ContinueWith (continuationAction, state, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Current);
887 public Task ContinueWith (Action<Task, object> continuationAction, object state, CancellationToken cancellationToken)
889 return ContinueWith (continuationAction, state, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Current);
892 public Task ContinueWith (Action<Task, object> continuationAction, object state, TaskContinuationOptions continuationOptions)
894 return ContinueWith (continuationAction, state, CancellationToken.None, continuationOptions, TaskScheduler.Current);
897 public Task ContinueWith (Action<Task, object> continuationAction, object state, TaskScheduler scheduler)
899 return ContinueWith (continuationAction, state, CancellationToken.None, TaskContinuationOptions.None, scheduler);
902 public Task<TResult> ContinueWith<TResult> (Func<Task, object, TResult> continuationFunction, object state)
904 return ContinueWith<TResult> (continuationFunction, state, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Current);
907 public Task<TResult> ContinueWith<TResult> (Func<Task, object, TResult> continuationFunction, object state, TaskContinuationOptions continuationOptions)
909 return ContinueWith<TResult> (continuationFunction, state, CancellationToken.None, continuationOptions, TaskScheduler.Current);
912 public Task<TResult> ContinueWith<TResult> (Func<Task, object, TResult> continuationFunction, object state, CancellationToken cancellationToken)
914 return ContinueWith<TResult> (continuationFunction, state, cancellationToken, TaskContinuationOptions.None, TaskScheduler.Current);
917 public Task<TResult> ContinueWith<TResult> (Func<Task, object, TResult> continuationFunction, object state, TaskScheduler scheduler)
919 return ContinueWith<TResult> (continuationFunction, state, CancellationToken.None, TaskContinuationOptions.None, scheduler);
922 public Task<TResult> ContinueWith<TResult> (Func<Task, object, TResult> continuationFunction, object state, CancellationToken cancellationToken,
923 TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
925 if (continuationFunction == null)
926 throw new ArgumentNullException ("continuationFunction");
927 if (scheduler == null)
928 throw new ArgumentNullException ("scheduler");
930 var t = new Task<TResult> (TaskActionInvoker.Create (continuationFunction),
933 GetCreationOptions (continuationOptions),
937 ContinueWithCore (t, continuationOptions, scheduler);
942 public static Task Delay (int millisecondsDelay)
944 return Delay (millisecondsDelay, CancellationToken.None);
947 public static Task Delay (TimeSpan delay)
949 return Delay (CheckTimeout (delay), CancellationToken.None);
952 public static Task Delay (TimeSpan delay, CancellationToken cancellationToken)
954 return Delay (CheckTimeout (delay), cancellationToken);
957 public static Task Delay (int millisecondsDelay, CancellationToken cancellationToken)
959 if (millisecondsDelay < -1)
960 throw new ArgumentOutOfRangeException ("millisecondsDelay");
962 var task = new Task (TaskActionInvoker.Delay, millisecondsDelay, cancellationToken, TaskCreationOptions.None, null, TaskConstants.Finished);
963 task.SetupScheduler (TaskScheduler.Current);
965 if (millisecondsDelay != Timeout.Infinite)
966 task.scheduler.QueueTask (task);
971 public static Task<TResult> FromResult<TResult> (TResult result)
973 var tcs = new TaskCompletionSource<TResult> ();
974 tcs.SetResult (result);
978 public TaskAwaiter GetAwaiter ()
980 return new TaskAwaiter (this);
983 public static Task Run (Action action)
985 return Run (action, CancellationToken.None);
988 public static Task Run (Action action, CancellationToken cancellationToken)
990 if (cancellationToken.IsCancellationRequested)
991 return TaskConstants.Canceled;
993 return Task.Factory.StartNew (action, cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
996 public static Task Run (Func<Task> function)
998 return Run (function, CancellationToken.None);
1001 public static Task Run (Func<Task> function, CancellationToken cancellationToken)
1003 if (cancellationToken.IsCancellationRequested)
1004 return TaskConstants.Canceled;
1006 return TaskExtensionsImpl.Unwrap (Task.Factory.StartNew (function, cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
1009 public static Task<TResult> Run<TResult> (Func<TResult> function)
1011 return Run (function, CancellationToken.None);
1014 public static Task<TResult> Run<TResult> (Func<TResult> function, CancellationToken cancellationToken)
1016 if (cancellationToken.IsCancellationRequested)
1017 return TaskConstants<TResult>.Canceled;
1019 return Task.Factory.StartNew (function, cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
1022 public static Task<TResult> Run<TResult> (Func<Task<TResult>> function)
1024 return Run (function, CancellationToken.None);
1027 public static Task<TResult> Run<TResult> (Func<Task<TResult>> function, CancellationToken cancellationToken)
1029 if (cancellationToken.IsCancellationRequested)
1030 return TaskConstants<TResult>.Canceled;
1032 return TaskExtensionsImpl.Unwrap (Task.Factory.StartNew (function, cancellationToken, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default));
1035 public static Task WhenAll (params Task[] tasks)
1038 throw new ArgumentNullException ("tasks");
1040 return WhenAllCore (tasks);
1043 public static Task WhenAll (IEnumerable<Task> tasks)
1046 throw new ArgumentNullException ("tasks");
1048 // Call ToList on input enumeration or we end up
1049 // enumerating it more than once
1050 return WhenAllCore (new List<Task> (tasks));
1053 public static Task<TResult[]> WhenAll<TResult> (params Task<TResult>[] tasks)
1056 throw new ArgumentNullException ("tasks");
1058 return WhenAllCore<TResult> (tasks);
1061 public static Task<TResult[]> WhenAll<TResult> (IEnumerable<Task<TResult>> tasks)
1064 throw new ArgumentNullException ("tasks");
1066 // Call ToList on input enumeration or we end up
1067 // enumerating it more than once
1068 return WhenAllCore<TResult> (new List<Task<TResult>> (tasks));
1071 internal static Task<TResult[]> WhenAllCore<TResult> (IList<Task<TResult>> tasks)
1073 foreach (var t in tasks) {
1075 throw new ArgumentException ("tasks", "the tasks argument contains a null element");
1078 var task = new Task<TResult[]> (TaskActionInvoker.Empty, null, CancellationToken.None, TaskCreationOptions.None, null, TaskConstants.Finished);
1079 task.SetupScheduler (TaskScheduler.Current);
1081 var continuation = new WhenAllContinuation<TResult> (task, tasks);
1082 foreach (var t in tasks)
1083 t.ContinueWith (continuation);
1088 public static Task<Task> WhenAny (params Task[] tasks)
1091 throw new ArgumentNullException ("tasks");
1093 return WhenAnyCore (tasks);
1096 public static Task<Task> WhenAny (IEnumerable<Task> tasks)
1099 throw new ArgumentNullException ("tasks");
1101 return WhenAnyCore (new List<Task> (tasks));
1104 public static Task<Task<TResult>> WhenAny<TResult> (params Task<TResult>[] tasks)
1107 throw new ArgumentNullException ("tasks");
1109 return WhenAnyCore<TResult> (tasks);
1112 public static Task<Task<TResult>> WhenAny<TResult> (IEnumerable<Task<TResult>> tasks)
1115 throw new ArgumentNullException ("tasks");
1117 return WhenAnyCore<TResult> (new List<Task<TResult>> (tasks));
1120 static Task<Task<TResult>> WhenAnyCore<TResult> (IList<Task<TResult>> tasks)
1122 if (tasks.Count == 0)
1123 throw new ArgumentException ("The tasks argument contains no tasks", "tasks");
1125 int completed_index = -1;
1126 for (int i = 0; i < tasks.Count; ++i) {
1129 throw new ArgumentException ("tasks", "the tasks argument contains a null element");
1131 if (t.IsCompleted && completed_index < 0)
1132 completed_index = i;
1135 var task = new Task<Task<TResult>> (TaskActionInvoker.Empty, null, CancellationToken.None, TaskCreationOptions.None, null, TaskConstants.Finished);
1137 if (completed_index > 0) {
1138 task.TrySetResult (tasks[completed_index]);
1142 task.SetupScheduler (TaskScheduler.Current);
1144 var continuation = new WhenAnyContinuation<Task<TResult>> (task, tasks);
1145 foreach (var t in tasks)
1146 t.ContinueWith (continuation);
1151 public static YieldAwaitable Yield ()
1153 return new YieldAwaitable ();
1157 internal static Task WhenAllCore (IList<Task> tasks)
1159 bool all_completed = true;
1160 foreach (var t in tasks) {
1162 throw new ArgumentException ("tasks", "the tasks argument contains a null element");
1164 all_completed &= t.Status == TaskStatus.RanToCompletion;
1168 return TaskConstants.Finished;
1170 var task = new Task (TaskActionInvoker.Empty, null, CancellationToken.None, TaskCreationOptions.None, null, TaskConstants.Finished);
1171 task.SetupScheduler (TaskScheduler.Current);
1173 var continuation = new WhenAllContinuation (task, tasks);
1174 foreach (var t in tasks)
1175 t.ContinueWith (continuation);
1180 internal static Task<Task> WhenAnyCore (IList<Task> tasks)
1182 if (tasks.Count == 0)
1183 throw new ArgumentException ("The tasks argument contains no tasks", "tasks");
1185 int completed_index = -1;
1186 for (int i = 0; i < tasks.Count; ++i) {
1189 throw new ArgumentException ("tasks", "the tasks argument contains a null element");
1191 if (t.IsCompleted && completed_index < 0)
1192 completed_index = i;
1195 var task = new Task<Task> (TaskActionInvoker.Empty, null, CancellationToken.None, TaskCreationOptions.None, null, TaskConstants.Finished);
1197 if (completed_index > 0) {
1198 task.TrySetResult (tasks[completed_index]);
1202 task.SetupScheduler (TaskScheduler.Current);
1204 var continuation = new WhenAnyContinuation<Task> (task, tasks);
1205 foreach (var t in tasks)
1206 t.ContinueWith (continuation);
1212 internal CancellationToken CancellationToken {
1218 public static TaskFactory Factory {
1220 return defaultFactory;
1224 public static int? CurrentId {
1227 return t == null ? (int?)null : t.Id;
1231 public AggregateException Exception {
1235 exSlot.Observed = true;
1236 return exSlot.Exception;
1240 public bool IsCanceled {
1242 return status == TaskStatus.Canceled;
1246 public bool IsCompleted {
1248 return status >= TaskStatus.RanToCompletion;
1252 public bool IsFaulted {
1254 return status == TaskStatus.Faulted;
1258 public TaskCreationOptions CreationOptions {
1260 return creationOptions & MaxTaskCreationOptions;
1264 public TaskStatus Status {
1270 Thread.MemoryBarrier ();
1274 TaskExceptionSlot ExceptionSlot {
1278 Interlocked.CompareExchange (ref exSlot, new TaskExceptionSlot (this), null);
1283 public object AsyncState {
1289 bool IAsyncResult.CompletedSynchronously {
1295 WaitHandle IAsyncResult.AsyncWaitHandle {
1297 if (invoker == null)
1298 throw new ObjectDisposedException (GetType ().ToString ());
1300 if (wait_handle == null)
1301 Interlocked.CompareExchange (ref wait_handle, new ManualResetEvent (IsCompleted), null);
1313 bool IsContinuation {
1315 return contAncestor != null;
1319 internal Task ContinuationAncestor {
1321 return contAncestor;
1325 internal string DisplayActionMethod {
1327 Delegate d = invoker.Action;
1328 return d == null ? "<none>" : d.Method.ToString ();