Пример #1
0
		public bool Wait (int millisecondsTimeout, CancellationToken cancellationToken)
		{
			if (millisecondsTimeout < -1)
				throw new ArgumentOutOfRangeException ("millisecondsTimeout");

			bool result = true;

			if (!IsCompleted) {
				// If the task is ready to be run and we were supposed to wait on it indefinitely without cancellation, just run it
				if (Status == TaskStatus.WaitingToRun && millisecondsTimeout == Timeout.Infinite && scheduler != null && !cancellationToken.CanBeCanceled)
					scheduler.RunInline (this, true);

				if (!IsCompleted) {
					var continuation = new ManualResetContinuation ();
					try {
						ContinueWith (continuation);
						result = continuation.Event.Wait (millisecondsTimeout, cancellationToken);
					} finally {
						if (!result)
							RemoveContinuation (continuation);
						continuation.Dispose ();
					}
				}
			}

			if (IsCanceled)
				throw new AggregateException (new TaskCanceledException (this));

			var exception = Exception;
			if (exception != null)
				throw exception;

			return result;
		}
Пример #2
0
        public static int WaitAny(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken)
        {
            if (tasks == null)
            {
                throw new ArgumentNullException("tasks");
            }
            if (millisecondsTimeout < -1)
            {
                throw new ArgumentOutOfRangeException("millisecondsTimeout");
            }
            CheckForNullTasks(tasks);

            if (tasks.Length > 0)
            {
                var  continuation = new ManualResetContinuation();
                bool result       = false;
                try {
                    for (int i = 0; i < tasks.Length; i++)
                    {
                        var t = tasks[i];
                        if (t.IsCompleted)
                        {
                            return(i);
                        }
                        t.ContinueWith(continuation);
                    }

                    if (!(result = continuation.Event.Wait(millisecondsTimeout, cancellationToken)))
                    {
                        return(-1);
                    }
                } finally {
                    if (!result)
                    {
                        foreach (var t in tasks)
                        {
                            t.RemoveContinuation(continuation);
                        }
                    }
                    continuation.Dispose();
                }
            }

            int firstFinished = -1;

            for (int i = 0; i < tasks.Length; i++)
            {
                var t = tasks[i];
                if (t.IsCompleted)
                {
                    firstFinished = i;
                    break;
                }
            }

            return(firstFinished);
        }
Пример #3
0
        internal bool WaitCore(int millisecondsTimeout, CancellationToken cancellationToken)
        {
            if (IsCompleted)
            {
                return(true);
            }

            // If the task is ready to be run and we were supposed to wait on it indefinitely without cancellation, just run it
            if (Status == TaskStatus.WaitingToRun && millisecondsTimeout == Timeout.Infinite && scheduler != null && !cancellationToken.CanBeCanceled)
            {
                scheduler.RunInline(this, true);
            }

            bool result = true;

            if (!IsCompleted)
            {
                var continuation = new ManualResetContinuation();
                try
                {
                    ContinueWith(continuation);

                    result = continuation.Wait(millisecondsTimeout, cancellationToken);
                }
                finally
                {
                    if (!result)
                    {
                        RemoveContinuation(continuation);
                    }
                    continuation.Dispose();
                }
            }

            return(result);
        }