Invoke() [1/2]

static void System.Threading.Tasks.Parallel.Invoke ( ParallelOptions parallelOptions, params Action[] actions )

inlinestatic

Definition at line 157 of file Parallel.cs.

    {
        ParallelOptions parallelOptions2 = parallelOptions;
        if (actions == null)
        {
            throw new ArgumentNullException("actions");
        }
        if (parallelOptions2 == null)
        {
            throw new ArgumentNullException("parallelOptions");
        }
        parallelOptions2.CancellationToken.ThrowIfCancellationRequested();
        Action[] actionsCopy = new Action[actions.Length];
        for (int i = 0; i < actionsCopy.Length; i++)
        {
            actionsCopy[i] = actions[i];
            if (actionsCopy[i] == null)
            {
                throw new ArgumentException(System.SR.Parallel_Invoke_ActionNull);
            }
        }
        int forkJoinContextID = 0;
        if (ParallelEtwProvider.Log.IsEnabled())
        {
            forkJoinContextID = Interlocked.Increment(ref s_forkJoinContextID);
            ParallelEtwProvider.Log.ParallelInvokeBegin(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID, ParallelEtwProvider.ForkJoinOperationType.ParallelInvoke, actionsCopy.Length);
        }
        if (actionsCopy.Length < 1)
        {
            return;
        }
        try
        {
            if (OperatingSystem.IsBrowser() || actionsCopy.Length > 10 || (parallelOptions2.MaxDegreeOfParallelism != -1 && parallelOptions2.MaxDegreeOfParallelism < actionsCopy.Length))
            {
                ConcurrentQueue<Exception> exceptionQ = null;
                int actionIndex = 0;
                try
                {
                    TaskReplicator.Run(delegate(ref object state, int timeout, out bool replicationDelegateYieldedBeforeCompletion)
                    {
                        replicationDelegateYieldedBeforeCompletion = false;
                        for (int num = Interlocked.Increment(ref actionIndex); num <= actionsCopy.Length; num = Interlocked.Increment(ref actionIndex))
                        {
                            try
                            {
                                actionsCopy[num - 1]();
                            }
                            catch (Exception item)
                            {
                                LazyInitializer.EnsureInitialized(ref exceptionQ, () => new ConcurrentQueue<Exception>());
                                exceptionQ.Enqueue(item);
                            }
                            parallelOptions2.CancellationToken.ThrowIfCancellationRequested();
                        }
                    }, parallelOptions2, stopOnFirstFailure: false);
                }
                catch (Exception ex)
                {
                    LazyInitializer.EnsureInitialized(ref exceptionQ, () => new ConcurrentQueue<Exception>());
                    if (ex is ObjectDisposedException)
                    {
                        throw;
                    }
                    if (ex is AggregateException ex2)
                    {
                        foreach (Exception innerException in ex2.InnerExceptions)
                        {
                            exceptionQ.Enqueue(innerException);
                        }
                    }
                    else
                    {
                        exceptionQ.Enqueue(ex);
                    }
                }
                if (exceptionQ != null && !exceptionQ.IsEmpty)
                {
                    ThrowSingleCancellationExceptionOrOtherException(exceptionQ, parallelOptions2.CancellationToken, new AggregateException(exceptionQ));
                }
                return;
            }
            Task[] array = new Task[actionsCopy.Length];
            parallelOptions2.CancellationToken.ThrowIfCancellationRequested();
            for (int j = 1; j < array.Length; j++)
            {
                array[j] = Task.Factory.StartNew(actionsCopy[j], parallelOptions2.CancellationToken, TaskCreationOptions.None, parallelOptions2.EffectiveTaskScheduler);
            }
            array[0] = new Task(actionsCopy[0], parallelOptions2.CancellationToken, TaskCreationOptions.None);
            array[0].RunSynchronously(parallelOptions2.EffectiveTaskScheduler);
            try
            {
                Task.WaitAll(array);
            }
            catch (AggregateException ex3)
            {
                ThrowSingleCancellationExceptionOrOtherException(ex3.InnerExceptions, parallelOptions2.CancellationToken, ex3);
            }
        }
        finally
        {
            if (ParallelEtwProvider.Log.IsEnabled())
            {
                ParallelEtwProvider.Log.ParallelInvokeEnd(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID);
            }
        }
    }

References System.array, System.Threading.Tasks.TaskScheduler.Current, System.Threading.Tasks.Task< TResult >.CurrentId, System.Threading.Tasks.Task< TResult >.Factory, System.Threading.Interlocked.Increment(), System.OperatingSystem.IsBrowser(), System.item, System.Threading.Tasks.ParallelEtwProvider.Log, System.SR.Parallel_Invoke_ActionNull, System.Threading.Tasks.Parallel.s_forkJoinContextID, System.state, System.Threading.Tasks.Parallel.ThrowSingleCancellationExceptionOrOtherException(), System.timeout, and System.Threading.Tasks.Task< TResult >.WaitAll().