Task.cs System::Threading::Tasks::Task System System::Threading System::Threading::Tasks // //Task.cs // //Authors: //MarekSafar<marek.safar@gmail.com> //JérémieLaval<jeremiedotlavalatxamarindotcom> // //Copyright(c)2008Jérémie"Garuma"Laval //Copyright2011XamarinInc(http://www.xamarin.com). // //Permissionisherebygranted,freeofcharge,toanypersonobtainingacopy //ofthissoftwareandassociateddocumentationfiles(the"Software"),todeal //intheSoftwarewithoutrestriction,includingwithoutlimitationtherights //touse,copy,modify,merge,publish,distribute,sublicense,and/orsell //copiesoftheSoftware,andtopermitpersonstowhomtheSoftwareis //furnishedtodoso,subjecttothefollowingconditions: // //Theabovecopyrightnoticeandthispermissionnoticeshallbeincludedin //allcopiesorsubstantialportionsoftheSoftware. // //THESOFTWAREISPROVIDED"ASIS",WITHOUTWARRANTYOFANYKIND,EXPRESSOR //IMPLIED,INCLUDINGBUTNOTLIMITEDTOTHEWARRANTIESOFMERCHANTABILITY, //FITNESSFORAPARTICULARPURPOSEANDNONINFRINGEMENT.INNOEVENTSHALLTHE //AUTHORSORCOPYRIGHTHOLDERSBELIABLEFORANYCLAIM,DAMAGESOROTHER //LIABILITY,WHETHERINANACTIONOFCONTRACT,TORTOROTHERWISE,ARISINGFROM, //OUTOFORINCONNECTIONWITHTHESOFTWAREORTHEUSEOROTHERDEALINGSIN //THESOFTWARE. // // #ifNET_4_0||UNITY_5_3_OR_NEWER usingSystem; usingSystem.Threading; usingSystem.Collections.Concurrent; usingSystem.Collections.Generic; usingSystem.Runtime.CompilerServices; namespaceSystem.Threading.Tasks { [System.Diagnostics.DebuggerDisplay("Id={Id},Status={Status}")] [System.Diagnostics.DebuggerTypeProxy(typeof(TaskDebuggerView))] publicclassTask:IDisposable,IAsyncResult { //Withthisattributeeachthreadhasitsownvaluesothatit'scorrectforourSchedulecode //andforParentproperty. [System.ThreadStatic] staticTaskcurrent; [System.ThreadStatic] staticAction<Task>childWorkAdder=null; //parentistheoutertaskinwhichthistaskiscreated readonlyTaskparent; //contAncestoristheTaskonwhichthiscontinuationwassetup readonlyTaskcontAncestor; staticintid=-1; staticreadonlyTaskFactorydefaultFactory=newTaskFactory(); CountdownEventchildTasks; inttaskId; TaskCreationOptionscreationOptions; internalTaskSchedulerscheduler; TaskExceptionSlotexSlot; TaskStatusstatus; TaskActionInvokerinvoker; objectstate; internalAtomicBooleanValueexecuting; TaskCompletionQueue<IContinuation>continuations; CancellationTokentoken; CancellationTokenRegistration?cancellationRegistration; internalconstTaskCreationOptionsWorkerTaskNotSupportedOptions=TaskCreationOptions.LongRunning|TaskCreationOptions.PreferFairness; constTaskCreationOptionsMaxTaskCreationOptions= #ifNET_4_5||UNITY_5_3_OR_NEWER TaskCreationOptions.DenyChildAttach|TaskCreationOptions.HideScheduler| #endif TaskCreationOptions.PreferFairness|TaskCreationOptions.LongRunning|TaskCreationOptions.AttachedToParent; publicTask(Actionaction) :this(action,TaskCreationOptions.None) { } publicTask(Actionaction,TaskCreationOptionscreationOptions) :this(action,CancellationToken.None,creationOptions) { } publicTask(Actionaction,CancellationTokencancellationToken) :this(action,cancellationToken,TaskCreationOptions.None) { } publicTask(Actionaction,CancellationTokencancellationToken,TaskCreationOptionscreationOptions) :this(TaskActionInvoker.Create(action),null,cancellationToken,creationOptions,current) { if(action==null) thrownewArgumentNullException("action"); if(creationOptions>MaxTaskCreationOptions||creationOptions<TaskCreationOptions.None) thrownewArgumentOutOfRangeException("creationOptions"); } publicTask(Action<object>action,objectstate) :this(action,state,TaskCreationOptions.None) { } publicTask(Action<object>action,objectstate,TaskCreationOptionscreationOptions) :this(action,state,CancellationToken.None,creationOptions) { } publicTask(Action<object>action,objectstate,CancellationTokencancellationToken) :this(action,state,cancellationToken,TaskCreationOptions.None) { } publicTask(Action<object>action,objectstate,CancellationTokencancellationToken,TaskCreationOptionscreationOptions) :this(TaskActionInvoker.Create(action),state,cancellationToken,creationOptions,current) { if(action==null) thrownewArgumentNullException("action"); if(creationOptions>MaxTaskCreationOptions||creationOptions<TaskCreationOptions.None) thrownewArgumentOutOfRangeException("creationOptions"); } //SpicyPixel:Recentcompilerchangesdonotallowdelegatespassedtobase()toaccess'this'. //Soweaddprotectedmemberstoupdatethetaskactionlater. protectedvoidSetAction(Actionaction) { this.invoker=TaskActionInvoker.Create(action); } protectedvoidSetAction(Action<object>action) { this.invoker=TaskActionInvoker.Create(action); } internalTask(TaskActionInvokerinvoker,objectstate,CancellationTokencancellationToken, TaskCreationOptionscreationOptions,Taskparent=null,TaskcontAncestor=null,boolignoreCancellation=false) { this.invoker=invoker; this.creationOptions=creationOptions; this.state=state; this.taskId=Interlocked.Increment(refid); this.token=cancellationToken; this.parent=parent=parent==null?current:parent; this.contAncestor=contAncestor; this.status=cancellationToken.IsCancellationRequested&&!ignoreCancellation?TaskStatus.Canceled:TaskStatus.Created; //ProcesscreationOptions #ifNET_4_5||UNITY_5_3_OR_NEWER if(parent!=null&&HasFlag(creationOptions,TaskCreationOptions.AttachedToParent) &&!HasFlag(parent.CreationOptions,TaskCreationOptions.DenyChildAttach)) #else if(parent!=null&&HasFlag(creationOptions,TaskCreationOptions.AttachedToParent)) #endif parent.AddChild(); if(token.CanBeCanceled&&!ignoreCancellation) cancellationRegistration=token.Register(l=>((Task)l).CancelReal(),this); } staticboolHasFlag(TaskCreationOptionsopt,TaskCreationOptionsmember) { return(opt&member)==member; } #regionStart publicvoidStart() { Start(TaskScheduler.Current); } publicvoidStart(TaskSchedulerscheduler) { if(scheduler==null) thrownewArgumentNullException("scheduler"); if(status>=TaskStatus.WaitingToRun) thrownewInvalidOperationException("TheTaskisnotinavalidstatetobestarted."); if(IsContinuation) thrownewInvalidOperationException("Startmaynotbecalledonacontinuationtask"); SetupScheduler(scheduler); Schedule(); } internalvoidSetupScheduler(TaskSchedulerscheduler) { this.scheduler=scheduler; Status=TaskStatus.WaitingForActivation; } publicvoidRunSynchronously() { RunSynchronously(TaskScheduler.Current); } publicvoidRunSynchronously(TaskSchedulerscheduler) { if(scheduler==null) thrownewArgumentNullException("scheduler"); if(Status>TaskStatus.WaitingForActivation) thrownewInvalidOperationException("Thetaskisnotinavalidstatetobestarted"); if(IsContinuation) thrownewInvalidOperationException("RunSynchronouslymaynotbecalledonacontinuationtask"); RunSynchronouslyCore(scheduler); } internalvoidRunSynchronouslyCore(TaskSchedulerscheduler) { SetupScheduler(scheduler); varsaveStatus=status; Status=TaskStatus.WaitingToRun; try{ if(scheduler.RunInline(this,false)) return; }catch(Exceptioninner){ thrownewTaskSchedulerException(inner); } Status=saveStatus; Start(scheduler); Wait(); } #endregion #regionContinueWith publicTaskContinueWith(Action<Task>continuationAction) { returnContinueWith(continuationAction,TaskContinuationOptions.None); } publicTaskContinueWith(Action<Task>continuationAction,TaskContinuationOptionscontinuationOptions) { returnContinueWith(continuationAction,CancellationToken.None,continuationOptions,TaskScheduler.Current); } publicTaskContinueWith(Action<Task>continuationAction,CancellationTokencancellationToken) { returnContinueWith(continuationAction,cancellationToken,TaskContinuationOptions.None,TaskScheduler.Current); } publicTaskContinueWith(Action<Task>continuationAction,TaskSchedulerscheduler) { returnContinueWith(continuationAction,CancellationToken.None,TaskContinuationOptions.None,scheduler); } publicTaskContinueWith(Action<Task>continuationAction,CancellationTokencancellationToken,TaskContinuationOptionscontinuationOptions,TaskSchedulerscheduler) { if(continuationAction==null) thrownewArgumentNullException("continuationAction"); if(scheduler==null) thrownewArgumentNullException("scheduler"); returnContinueWith(TaskActionInvoker.Create(continuationAction),cancellationToken,continuationOptions,scheduler); } internalTaskContinueWith(TaskActionInvokerinvoker,CancellationTokencancellationToken,TaskContinuationOptionscontinuationOptions,TaskSchedulerscheduler) { varlazyCancellation=false; #ifNET_4_5||UNITY_5_3_OR_NEWER lazyCancellation=(continuationOptions&TaskContinuationOptions.LazyCancellation)>0; #endif varcontinuation=newTask(invoker,null,cancellationToken,GetCreationOptions(continuationOptions),null,this,lazyCancellation); ContinueWithCore(continuation,continuationOptions,scheduler); returncontinuation; } publicTask<TResult>ContinueWith<TResult>(Func<Task,TResult>continuationFunction) { returnContinueWith<TResult>(continuationFunction,TaskContinuationOptions.None); } publicTask<TResult>ContinueWith<TResult>(Func<Task,TResult>continuationFunction,TaskContinuationOptionscontinuationOptions) { returnContinueWith<TResult>(continuationFunction,CancellationToken.None,continuationOptions,TaskScheduler.Current); } publicTask<TResult>ContinueWith<TResult>(Func<Task,TResult>continuationFunction,CancellationTokencancellationToken) { returnContinueWith<TResult>(continuationFunction,cancellationToken,TaskContinuationOptions.None,TaskScheduler.Current); } publicTask<TResult>ContinueWith<TResult>(Func<Task,TResult>continuationFunction,TaskSchedulerscheduler) { returnContinueWith<TResult>(continuationFunction,CancellationToken.None,TaskContinuationOptions.None,scheduler); } publicTask<TResult>ContinueWith<TResult>(Func<Task,TResult>continuationFunction,CancellationTokencancellationToken, TaskContinuationOptionscontinuationOptions,TaskSchedulerscheduler) { if(continuationFunction==null) thrownewArgumentNullException("continuationFunction"); if(scheduler==null) thrownewArgumentNullException("scheduler"); returnContinueWith<TResult>(TaskActionInvoker.Create(continuationFunction),cancellationToken,continuationOptions,scheduler); } internalTask<TResult>ContinueWith<TResult>(TaskActionInvokerinvoker,CancellationTokencancellationToken,TaskContinuationOptionscontinuationOptions,TaskSchedulerscheduler) { varlazyCancellation=false; #ifNET_4_5||UNITY_5_3_OR_NEWER lazyCancellation=(continuationOptions&TaskContinuationOptions.LazyCancellation)>0; #endif varcontinuation=newTask<TResult>(invoker,null,cancellationToken,GetCreationOptions(continuationOptions),parent,this,lazyCancellation); ContinueWithCore(continuation,continuationOptions,scheduler); returncontinuation; } internalvoidContinueWithCore(Taskcontinuation,TaskContinuationOptionsoptions,TaskSchedulerscheduler) { constTaskContinuationOptionswrongRan=TaskContinuationOptions.NotOnRanToCompletion|TaskContinuationOptions.OnlyOnRanToCompletion; constTaskContinuationOptionswrongCanceled=TaskContinuationOptions.NotOnCanceled|TaskContinuationOptions.OnlyOnCanceled; constTaskContinuationOptionswrongFaulted=TaskContinuationOptions.NotOnFaulted|TaskContinuationOptions.OnlyOnFaulted; if(((options&wrongRan)==wrongRan)||((options&wrongCanceled)==wrongCanceled)||((options&wrongFaulted)==wrongFaulted)) thrownewArgumentException("continuationOptions","Someoptionsaremutuallyexclusive"); //AlreadysettheschedulersothatusercancallWaitandthatsortofstuff continuation.scheduler=scheduler; continuation.Status=TaskStatus.WaitingForActivation; ContinueWith(newTaskContinuation(continuation,options)); } internalvoidContinueWith(IContinuationcontinuation) { if(IsCompleted){ continuation.Execute(); return; } continuations.Add(continuation); //Retryincasecompletionwasachievedbuteventaddingwastoolate if(IsCompleted&&continuations.Remove(continuation)) continuation.Execute(); } internalvoidRemoveContinuation(IContinuationcontinuation) { continuations.Remove(continuation); } staticinternalTaskCreationOptionsGetCreationOptions(TaskContinuationOptionskind) { TaskCreationOptionsoptions=TaskCreationOptions.None; if((kind&TaskContinuationOptions.AttachedToParent)>0) options|=TaskCreationOptions.AttachedToParent; if((kind&TaskContinuationOptions.PreferFairness)>0) options|=TaskCreationOptions.PreferFairness; if((kind&TaskContinuationOptions.LongRunning)>0) options|=TaskCreationOptions.LongRunning; returnoptions; } #endregion #regionInternalandprotectedthingies internalvoidSchedule() { Status=TaskStatus.WaitingToRun; //Ifworkerisnullitmeansitisalocalone,reverttotheoldbehavior //IfTaskScheduler.Currentisnotbeingused,theschedulerwasexplicitlyprovided,sowemustusethat if(scheduler!=TaskScheduler.Current||childWorkAdder==null||HasFlag(creationOptions,TaskCreationOptions.PreferFairness)){ scheduler.QueueTask(this); }else{ /*LikethesemanticoftheABPpaperdescribeit,weaddourselvestothebottom *ofourParentTask'sThreadWorkerdeque.It'soktodothatsincewearein *thecorrectThreadduringthecreation */ childWorkAdder(this); } } voidThreadStart() { /*Allowschedulertobreakfairnessofdequeorderingwithout *breakingitssemantic(thetaskcanbeexecutedtwicebutthe *secondtimeitwillreturnimmediately */ if(!executing.TryRelaxedSet()) return; //DisableCancellationTokendirectcancellation if(cancellationRegistration!=null){ cancellationRegistration.Value.Dispose(); cancellationRegistration=null; } //IfTaskareraninlineonthesamethreadwemighttrashthesevalues varsaveCurrent=current; varsaveScheduler=TaskScheduler.Current; current=this; #ifNET_4_5||UNITY_5_3_OR_NEWER TaskScheduler.Current=HasFlag(creationOptions,TaskCreationOptions.HideScheduler)?TaskScheduler.Default:scheduler; #else TaskScheduler.Current=scheduler; #endif if(!token.IsCancellationRequested){ status=TaskStatus.Running; try{ InnerInvoke(); }catch(Threading.OperationCanceledExceptionoce){ if(token!=CancellationToken.None&&oce.CancellationToken==token) CancelReal(); else HandleGenericException(oce); }catch(Exceptione){ HandleGenericException(e); } }else{ CancelReal(); } if(saveCurrent!=null) current=saveCurrent; if(saveScheduler!=null) TaskScheduler.Current=saveScheduler; Finish(); } internalboolTrySetCanceled() { if(IsCompleted) returnfalse; if(!executing.TryRelaxedSet()){ varsw=newSpinWait(); while(!IsCompleted) sw.SpinOnce(); returnfalse; } CancelReal(); returntrue; } internalboolTrySetException(AggregateExceptionaggregate) { if(IsCompleted) returnfalse; if(!executing.TryRelaxedSet()){ varsw=newSpinWait(); while(!IsCompleted) sw.SpinOnce(); returnfalse; } HandleGenericException(aggregate); returntrue; } internalboolTrySetExceptionObserved() { if(exSlot!=null){ exSlot.Observed=true; returntrue; } returnfalse; } internalvoidExecute() { ThreadStart(); } internalvoidAddChild() { if(childTasks==null) AotInterlocked.CompareExchange(refchildTasks,newCountdownEvent(1),null); childTasks.AddCount(); } internalvoidChildCompleted(AggregateExceptionchildEx) { if(childEx!=null){ if(ExceptionSlot.ChildExceptions==null) AotInterlocked.CompareExchange(refExceptionSlot.ChildExceptions,newConcurrentQueue<AggregateException>(),null); ExceptionSlot.ChildExceptions.Enqueue(childEx); } if(childTasks.Signal()&&status==TaskStatus.WaitingForChildrenToComplete){ ProcessChildExceptions(); Status=exSlot==null?TaskStatus.RanToCompletion:TaskStatus.Faulted; ProcessCompleteDelegates(); if(parent!=null&& #ifNET_4_5||UNITY_5_3_OR_NEWER !HasFlag(parent.CreationOptions,TaskCreationOptions.DenyChildAttach)&& #endif HasFlag(creationOptions,TaskCreationOptions.AttachedToParent)) parent.ChildCompleted(this.Exception); } } voidInnerInvoke() { if(IsContinuation){ invoker.Invoke(contAncestor,state,this); }else{ invoker.Invoke(this,state,this); } } internalvoidFinish() { //Iftherewaschildrencreatedandtheyallfinished,wesetthecountdown if(childTasks!=null){ if(childTasks.Signal()) ProcessChildExceptions(true); } //Don'toverrideCanceledorFaulted if(status==TaskStatus.Running){ if(childTasks==null||childTasks.IsSet) Status=TaskStatus.RanToCompletion; else Status=TaskStatus.WaitingForChildrenToComplete; } //Tellparentthatwearefinished if(parent!=null&&HasFlag(creationOptions,TaskCreationOptions.AttachedToParent)&& #ifNET_4_5||UNITY_5_3_OR_NEWER !HasFlag(parent.CreationOptions,TaskCreationOptions.DenyChildAttach)&& #endif status!=TaskStatus.WaitingForChildrenToComplete){ parent.ChildCompleted(this.Exception); } //Completionsarealreadyprocessedwhentaskiscanceledorfaulted if(status==TaskStatus.RanToCompletion) ProcessCompleteDelegates(); //Resetthecurrentthingies if(current==this) current=null; if(TaskScheduler.Current==scheduler) TaskScheduler.Current=null; if(cancellationRegistration.HasValue) cancellationRegistration.Value.Dispose(); } voidProcessCompleteDelegates() { if(continuations.HasElements){ IContinuationcontinuation; while(continuations.TryGetNextCompletion(outcontinuation)) continuation.Execute(); } } voidProcessChildExceptions(boolisParent=false) { if(exSlot==null||exSlot.ChildExceptions==null) return; if(ExceptionSlot.Exception==null) exSlot.Exception=newAggregateException(); AggregateExceptionchildEx; while(exSlot.ChildExceptions.TryDequeue(outchildEx)) exSlot.Exception.AddChildException(childEx); if(isParent){ Status=TaskStatus.Faulted; ProcessCompleteDelegates(); } } #endregion #regionCancelandWaitrelatedmethod internalvoidCancelReal() { Status=TaskStatus.Canceled; ProcessCompleteDelegates(); } voidHandleGenericException(Exceptione) { HandleGenericException(newAggregateException(e)); } voidHandleGenericException(AggregateExceptione) { ExceptionSlot.Exception=e; Thread.MemoryBarrier(); Status=TaskStatus.Faulted; ProcessCompleteDelegates(); } internalboolWaitOnChildren() { if(Status==TaskStatus.WaitingForChildrenToComplete&&childTasks!=null){ childTasks.Wait(); returntrue; } returnfalse; } publicvoidWait() { Wait(Timeout.Infinite,CancellationToken.None); } publicvoidWait(CancellationTokencancellationToken) { Wait(Timeout.Infinite,cancellationToken); } publicboolWait(TimeSpantimeout) { returnWait(CheckTimeout(timeout),CancellationToken.None); } publicboolWait(intmillisecondsTimeout) { returnWait(millisecondsTimeout,CancellationToken.None); } publicboolWait(intmillisecondsTimeout,CancellationTokencancellationToken) { if(millisecondsTimeout<-1) thrownewArgumentOutOfRangeException("millisecondsTimeout"); boolresult=true; if(!IsCompleted){ //Ifthetaskisreadytoberunandweweresupposedtowaitonitindefinitelywithoutcancellation,justrunit if(Status==TaskStatus.WaitingToRun&&millisecondsTimeout==Timeout.Infinite&&scheduler!=null&&!cancellationToken.CanBeCanceled) scheduler.RunInline(this,true); if(!IsCompleted){ varcontinuation=newManualResetContinuation(); try{ ContinueWith(continuation); result=continuation.Event.Wait(millisecondsTimeout,cancellationToken); }finally{ if(!result) RemoveContinuation(continuation); continuation.Dispose(); } } } if(IsCanceled) thrownewAggregateException(newTaskCanceledException(this)); varexception=Exception; if(exception!=null) throwexception; returnresult; } publicstaticvoidWaitAll(paramsTask[]tasks) { WaitAll(tasks,Timeout.Infinite,CancellationToken.None); } publicstaticvoidWaitAll(Task[]tasks,CancellationTokencancellationToken) { WaitAll(tasks,Timeout.Infinite,cancellationToken); } publicstaticboolWaitAll(Task[]tasks,TimeSpantimeout) { returnWaitAll(tasks,CheckTimeout(timeout),CancellationToken.None); } publicstaticboolWaitAll(Task[]tasks,intmillisecondsTimeout) { returnWaitAll(tasks,millisecondsTimeout,CancellationToken.None); } publicstaticboolWaitAll(Task[]tasks,intmillisecondsTimeout,CancellationTokencancellationToken) { if(tasks==null) thrownewArgumentNullException("tasks"); boolresult=true; foreach(vartintasks){ if(t==null) thrownewArgumentException("tasks","thetasksargumentcontainsanullelement"); result&=t.Status==TaskStatus.RanToCompletion; } if(!result){ varcontinuation=newCountdownContinuation(tasks.Length); try{ foreach(vartintasks) t.ContinueWith(continuation); result=continuation.Event.Wait(millisecondsTimeout,cancellationToken); }finally{ List<Exception>exceptions=null; foreach(vartintasks){ if(result){ if(t.Status==TaskStatus.RanToCompletion) continue; if(exceptions==null) exceptions=newList<Exception>(); if(t.Exception!=null) exceptions.AddRange(t.Exception.InnerExceptions); else exceptions.Add(newTaskCanceledException(t)); }else{ t.RemoveContinuation(continuation); } } continuation.Dispose(); if(exceptions!=null) thrownewAggregateException(exceptions); } } returnresult; } publicstaticintWaitAny(paramsTask[]tasks) { returnWaitAny(tasks,Timeout.Infinite,CancellationToken.None); } publicstaticintWaitAny(Task[]tasks,TimeSpantimeout) { returnWaitAny(tasks,CheckTimeout(timeout)); } publicstaticintWaitAny(Task[]tasks,intmillisecondsTimeout) { returnWaitAny(tasks,millisecondsTimeout,CancellationToken.None); } publicstaticintWaitAny(Task[]tasks,CancellationTokencancellationToken) { returnWaitAny(tasks,Timeout.Infinite,cancellationToken); } publicstaticintWaitAny(Task[]tasks,intmillisecondsTimeout,CancellationTokencancellationToken) { if(tasks==null) thrownewArgumentNullException("tasks"); if(millisecondsTimeout<-1) thrownewArgumentOutOfRangeException("millisecondsTimeout"); CheckForNullTasks(tasks); if(tasks.Length>0){ varcontinuation=newManualResetContinuation(); boolresult=false; try{ for(inti=0;i<tasks.Length;i++){ vart=tasks[i]; if(t.IsCompleted) returni; t.ContinueWith(continuation); } if(!(result=continuation.Event.Wait(millisecondsTimeout,cancellationToken))) return-1; }finally{ if(!result) foreach(vartintasks) t.RemoveContinuation(continuation); continuation.Dispose(); } } intfirstFinished=-1; for(inti=0;i<tasks.Length;i++){ vart=tasks[i]; if(t.IsCompleted){ firstFinished=i; break; } } returnfirstFinished; } staticintCheckTimeout(TimeSpantimeout) { try{ returnchecked((int)timeout.TotalMilliseconds); }catch(System.OverflowException){ thrownewArgumentOutOfRangeException("timeout"); } } staticvoidCheckForNullTasks(Task[]tasks) { foreach(vartintasks) if(t==null) thrownewArgumentException("tasks","thetasksargumentcontainsanullelement"); } #endregion #regionDispose publicvoidDispose() { Dispose(true); } protectedvirtualvoidDispose(booldisposing) { if(!IsCompleted) thrownewInvalidOperationException("Ataskmayonlybedisposedifitisinacompletionstate"); //SetactiontonullsothattheGCcancollectthedelegateandthus //anybigobjectreferencesthattheusermighthavecapturedinaanonymousmethod if(disposing){ invoker=null; state=null; if(cancellationRegistration!=null) cancellationRegistration.Value.Dispose(); } } #endregion #ifNET_4_5||UNITY_5_3_OR_NEWER public #else internal #endif TaskContinueWith(Action<Task,object>continuationAction,objectstate,CancellationTokencancellationToken, TaskContinuationOptionscontinuationOptions,TaskSchedulerscheduler) { if(continuationAction==null) thrownewArgumentNullException("continuationAction"); if(scheduler==null) thrownewArgumentNullException("scheduler"); Taskcontinuation=newTask(TaskActionInvoker.Create(continuationAction), state,cancellationToken, GetCreationOptions(continuationOptions), parent, this); ContinueWithCore(continuation,continuationOptions,scheduler); returncontinuation; } #ifNET_4_5||UNITY_5_3_OR_NEWER publicConfiguredTaskAwaitableConfigureAwait(boolcontinueOnCapturedContext) { returnnewConfiguredTaskAwaitable(this,continueOnCapturedContext); } publicTaskContinueWith(Action<Task,object>continuationAction,objectstate) { returnContinueWith(continuationAction,state,CancellationToken.None,TaskContinuationOptions.None,TaskScheduler.Current); } publicTaskContinueWith(Action<Task,object>continuationAction,objectstate,CancellationTokencancellationToken) { returnContinueWith(continuationAction,state,cancellationToken,TaskContinuationOptions.None,TaskScheduler.Current); } publicTaskContinueWith(Action<Task,object>continuationAction,objectstate,TaskContinuationOptionscontinuationOptions) { returnContinueWith(continuationAction,state,CancellationToken.None,continuationOptions,TaskScheduler.Current); } publicTaskContinueWith(Action<Task,object>continuationAction,objectstate,TaskSchedulerscheduler) { returnContinueWith(continuationAction,state,CancellationToken.None,TaskContinuationOptions.None,scheduler); } publicTask<TResult>ContinueWith<TResult>(Func<Task,object,TResult>continuationFunction,objectstate) { returnContinueWith<TResult>(continuationFunction,state,CancellationToken.None,TaskContinuationOptions.None,TaskScheduler.Current); } publicTask<TResult>ContinueWith<TResult>(Func<Task,object,TResult>continuationFunction,objectstate,TaskContinuationOptionscontinuationOptions) { returnContinueWith<TResult>(continuationFunction,state,CancellationToken.None,continuationOptions,TaskScheduler.Current); } publicTask<TResult>ContinueWith<TResult>(Func<Task,object,TResult>continuationFunction,objectstate,CancellationTokencancellationToken) { returnContinueWith<TResult>(continuationFunction,state,cancellationToken,TaskContinuationOptions.None,TaskScheduler.Current); } publicTask<TResult>ContinueWith<TResult>(Func<Task,object,TResult>continuationFunction,objectstate,TaskSchedulerscheduler) { returnContinueWith<TResult>(continuationFunction,state,CancellationToken.None,TaskContinuationOptions.None,scheduler); } publicTask<TResult>ContinueWith<TResult>(Func<Task,object,TResult>continuationFunction,objectstate,CancellationTokencancellationToken, TaskContinuationOptionscontinuationOptions,TaskSchedulerscheduler) { if(continuationFunction==null) thrownewArgumentNullException("continuationFunction"); if(scheduler==null) thrownewArgumentNullException("scheduler"); vart=newTask<TResult>(TaskActionInvoker.Create(continuationFunction), state, cancellationToken, GetCreationOptions(continuationOptions), parent, this); ContinueWithCore(t,continuationOptions,scheduler); returnt; } publicstaticTaskDelay(intmillisecondsDelay) { returnDelay(millisecondsDelay,CancellationToken.None); } publicstaticTaskDelay(TimeSpandelay) { returnDelay(CheckTimeout(delay),CancellationToken.None); } publicstaticTaskDelay(TimeSpandelay,CancellationTokencancellationToken) { returnDelay(CheckTimeout(delay),cancellationToken); } publicstaticTaskDelay(intmillisecondsDelay,CancellationTokencancellationToken) { if(millisecondsDelay<-1) thrownewArgumentOutOfRangeException("millisecondsDelay"); vartask=newTask(TaskActionInvoker.Delay,millisecondsDelay,cancellationToken,TaskCreationOptions.None,null,TaskConstants.Finished); task.SetupScheduler(TaskScheduler.Current); if(millisecondsDelay!=Timeout.Infinite) task.scheduler.QueueTask(task); returntask; } publicstaticTask<TResult>FromResult<TResult>(TResultresult) { vartcs=newTaskCompletionSource<TResult>(); tcs.SetResult(result); returntcs.Task; } publicTaskAwaiterGetAwaiter() { returnnewTaskAwaiter(this); } publicstaticTaskRun(Actionaction) { returnRun(action,CancellationToken.None); } publicstaticTaskRun(Actionaction,CancellationTokencancellationToken) { if(cancellationToken.IsCancellationRequested) returnTaskConstants.Canceled; returnTask.Factory.StartNew(action,cancellationToken,TaskCreationOptions.DenyChildAttach,TaskScheduler.Default); } publicstaticTaskRun(Func<Task>function) { returnRun(function,CancellationToken.None); } publicstaticTaskRun(Func<Task>function,CancellationTokencancellationToken) { if(cancellationToken.IsCancellationRequested) returnTaskConstants.Canceled; returnTaskExtensionsImpl.Unwrap(Task.Factory.StartNew(function,cancellationToken,TaskCreationOptions.DenyChildAttach,TaskScheduler.Default)); } publicstaticTask<TResult>Run<TResult>(Func<TResult>function) { returnRun(function,CancellationToken.None); } publicstaticTask<TResult>Run<TResult>(Func<TResult>function,CancellationTokencancellationToken) { if(cancellationToken.IsCancellationRequested) returnTaskConstants<TResult>.Canceled; returnTask.Factory.StartNew(function,cancellationToken,TaskCreationOptions.DenyChildAttach,TaskScheduler.Default); } publicstaticTask<TResult>Run<TResult>(Func<Task<TResult>>function) { returnRun(function,CancellationToken.None); } publicstaticTask<TResult>Run<TResult>(Func<Task<TResult>>function,CancellationTokencancellationToken) { if(cancellationToken.IsCancellationRequested) returnTaskConstants<TResult>.Canceled; returnTaskExtensionsImpl.Unwrap(Task.Factory.StartNew(function,cancellationToken,TaskCreationOptions.DenyChildAttach,TaskScheduler.Default)); } publicstaticTaskWhenAll(paramsTask[]tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); returnWhenAllCore(tasks); } publicstaticTaskWhenAll(IEnumerable<Task>tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); //CallToListoninputenumerationorweendup //enumeratingitmorethanonce returnWhenAllCore(newList<Task>(tasks)); } publicstaticTask<TResult[]>WhenAll<TResult>(paramsTask<TResult>[]tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); returnWhenAllCore<TResult>(tasks); } publicstaticTask<TResult[]>WhenAll<TResult>(IEnumerable<Task<TResult>>tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); //CallToListoninputenumerationorweendup //enumeratingitmorethanonce returnWhenAllCore<TResult>(newList<Task<TResult>>(tasks)); } internalstaticTask<TResult[]>WhenAllCore<TResult>(IList<Task<TResult>>tasks) { foreach(vartintasks){ if(t==null) thrownewArgumentException("tasks","thetasksargumentcontainsanullelement"); } vartask=newTask<TResult[]>(TaskActionInvoker.Empty,null,CancellationToken.None,TaskCreationOptions.None,null,TaskConstants.Finished); task.SetupScheduler(TaskScheduler.Current); varcontinuation=newWhenAllContinuation<TResult>(task,tasks); foreach(vartintasks) t.ContinueWith(continuation); returntask; } publicstaticTask<Task>WhenAny(paramsTask[]tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); returnWhenAnyCore(tasks); } publicstaticTask<Task>WhenAny(IEnumerable<Task>tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); returnWhenAnyCore(newList<Task>(tasks)); } publicstaticTask<Task<TResult>>WhenAny<TResult>(paramsTask<TResult>[]tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); returnWhenAnyCore<TResult>(tasks); } publicstaticTask<Task<TResult>>WhenAny<TResult>(IEnumerable<Task<TResult>>tasks) { if(tasks==null) thrownewArgumentNullException("tasks"); returnWhenAnyCore<TResult>(newList<Task<TResult>>(tasks)); } staticTask<Task<TResult>>WhenAnyCore<TResult>(IList<Task<TResult>>tasks) { if(tasks.Count==0) thrownewArgumentException("Thetasksargumentcontainsnotasks","tasks"); intcompleted_index=-1; for(inti=0;i<tasks.Count;++i){ vart=tasks[i]; if(t==null) thrownewArgumentException("tasks","thetasksargumentcontainsanullelement"); if(t.IsCompleted&&completed_index<0) completed_index=i; } vartask=newTask<Task<TResult>>(TaskActionInvoker.Empty,null,CancellationToken.None,TaskCreationOptions.None,null,TaskConstants.Finished); if(completed_index>0){ task.TrySetResult(tasks[completed_index]); returntask; } task.SetupScheduler(TaskScheduler.Current); varcontinuation=newWhenAnyContinuation<Task<TResult>>(task,tasks); foreach(vartintasks) t.ContinueWith(continuation); returntask; } publicstaticYieldAwaitableYield() { returnnewYieldAwaitable(); } #endif internalstaticTaskWhenAllCore(IList<Task>tasks) { boolall_completed=true; foreach(vartintasks){ if(t==null) thrownewArgumentException("tasks","thetasksargumentcontainsanullelement"); all_completed&=t.Status==TaskStatus.RanToCompletion; } if(all_completed) returnTaskConstants.Finished; vartask=newTask(TaskActionInvoker.Empty,null,CancellationToken.None,TaskCreationOptions.None,null,TaskConstants.Finished); task.SetupScheduler(TaskScheduler.Current); varcontinuation=newWhenAllContinuation(task,tasks); foreach(vartintasks) t.ContinueWith(continuation); returntask; } internalstaticTask<Task>WhenAnyCore(IList<Task>tasks) { if(tasks.Count==0) thrownewArgumentException("Thetasksargumentcontainsnotasks","tasks"); intcompleted_index=-1; for(inti=0;i<tasks.Count;++i){ vart=tasks[i]; if(t==null) thrownewArgumentException("tasks","thetasksargumentcontainsanullelement"); if(t.IsCompleted&&completed_index<0) completed_index=i; } vartask=newTask<Task>(TaskActionInvoker.Empty,null,CancellationToken.None,TaskCreationOptions.None,null,TaskConstants.Finished); if(completed_index>0){ task.TrySetResult(tasks[completed_index]); returntask; } task.SetupScheduler(TaskScheduler.Current); varcontinuation=newWhenAnyContinuation<Task>(task,tasks); foreach(vartintasks) t.ContinueWith(continuation); returntask; } #regionProperties internalCancellationTokenCancellationToken{ get{ returntoken; } } publicstaticTaskFactoryFactory{ get{ returndefaultFactory; } } publicstaticint?CurrentId{ get{ Taskt=current; returnt==null?(int?)null:t.Id; } } publicAggregateExceptionException{ get{ if(exSlot==null) returnnull; exSlot.Observed=true; returnexSlot.Exception; } } publicboolIsCanceled{ get{ returnstatus==TaskStatus.Canceled; } } publicboolIsCompleted{ get{ returnstatus>=TaskStatus.RanToCompletion; } } publicboolIsFaulted{ get{ returnstatus==TaskStatus.Faulted; } } publicTaskCreationOptionsCreationOptions{ get{ returncreationOptions&MaxTaskCreationOptions; } } publicTaskStatusStatus{ get{ returnstatus; } internalset{ status=value; Thread.MemoryBarrier(); } } TaskExceptionSlotExceptionSlot{ get{ if(exSlot!=null) returnexSlot; AotInterlocked.CompareExchange(refexSlot,newTaskExceptionSlot(this),null); returnexSlot; } } publicobjectAsyncState{ get{ returnstate; } } boolIAsyncResult.CompletedSynchronously{ get{ returntrue; } } WaitHandleIAsyncResult.AsyncWaitHandle{ get{ returnnull; } } publicintId{ get{ returntaskId; } } boolIsContinuation{ get{ returncontAncestor!=null; } } internalTaskContinuationAncestor{ get{ returncontAncestor; } } internalstringDisplayActionMethod{ get{ Delegated=invoker.Action; returnd==null?"<none>":d.Method.ToString(); } } #endregion } } #endif