示例#1
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);
        }
示例#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);
                    }

                    result = continuation.Wait(millisecondsTimeout, cancellationToken);
                    if (!result)
                    {
                        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);
        }