ForWorker< TLocal >()

static ParallelLoopResult System.Threading.Tasks.Parallel.ForWorker< TLocal > ( int fromInclusive, int toExclusive, ParallelOptions parallelOptions, Action< int > body, Action< int, ParallelLoopState > bodyWithState, Func< int, ParallelLoopState, TLocal, TLocal > bodyWithLocal, Func< TLocal > localInit, Action< TLocal > localFinally )

inlinestaticprivate

Definition at line 448 of file Parallel.cs.

    {
        ParallelLoopResult result = default(ParallelLoopResult);
        if (toExclusive <= fromInclusive)
        {
            result._completed = true;
            return result;
        }
        ParallelLoopStateFlags32 sharedPStateFlags = new ParallelLoopStateFlags32();
        parallelOptions.CancellationToken.ThrowIfCancellationRequested();
        int nNumExpectedWorkers = ((parallelOptions.EffectiveMaxConcurrencyLevel == -1) ? Environment.ProcessorCount : parallelOptions.EffectiveMaxConcurrencyLevel);
        RangeManager rangeManager = new RangeManager(fromInclusive, toExclusive, 1L, nNumExpectedWorkers);
        OperationCanceledException oce = null;
        CancellationTokenRegistration cancellationTokenRegistration = ((!parallelOptions.CancellationToken.CanBeCanceled) ? default(CancellationTokenRegistration) : parallelOptions.CancellationToken.UnsafeRegister((Action<object?>)delegate
        {
            oce = new OperationCanceledException(parallelOptions.CancellationToken);
            sharedPStateFlags.Cancel();
        }, (object?)null));
        int forkJoinContextID = 0;
        if (ParallelEtwProvider.Log.IsEnabled())
        {
            forkJoinContextID = Interlocked.Increment(ref s_forkJoinContextID);
            ParallelEtwProvider.Log.ParallelLoopBegin(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID, ParallelEtwProvider.ForkJoinOperationType.ParallelFor, fromInclusive, toExclusive);
        }
        try
        {
            try
            {
                TaskReplicator.Run(delegate(ref RangeWorker currentWorker, int timeout, out bool replicationDelegateYieldedBeforeCompletion)
                {
                    if (!currentWorker.IsInitialized)
                    {
                        currentWorker = rangeManager.RegisterNewWorker();
                    }
                    replicationDelegateYieldedBeforeCompletion = false;
                    if (!currentWorker.FindNewWork32(out var nFromInclusiveLocal, out var nToExclusiveLocal) || sharedPStateFlags.ShouldExitLoop(nFromInclusiveLocal))
                    {
                        return;
                    }
                    if (ParallelEtwProvider.Log.IsEnabled())
                    {
                        ParallelEtwProvider.Log.ParallelFork(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID);
                    }
                    TLocal val = default(TLocal);
                    bool flag = false;
                    try
                    {
                        ParallelLoopState32 parallelLoopState = null;
                        if (bodyWithState != null)
                        {
                            parallelLoopState = new ParallelLoopState32(sharedPStateFlags);
                        }
                        else if (bodyWithLocal != null)
                        {
                            parallelLoopState = new ParallelLoopState32(sharedPStateFlags);
                            if (localInit != null)
                            {
                                val = localInit();
                                flag = true;
                            }
                        }
                        int timeoutOccursAt = ComputeTimeoutPoint(timeout);
                        do
                        {
                            if (body != null)
                            {
                                for (int i = nFromInclusiveLocal; i < nToExclusiveLocal; i++)
                                {
                                    if (sharedPStateFlags.LoopStateFlags != 0 && sharedPStateFlags.ShouldExitLoop())
                                    {
                                        break;
                                    }
                                    body(i);
                                }
                            }
                            else if (bodyWithState != null)
                            {
                                for (int j = nFromInclusiveLocal; j < nToExclusiveLocal && (sharedPStateFlags.LoopStateFlags == 0 || !sharedPStateFlags.ShouldExitLoop(j)); j++)
                                {
                                    parallelLoopState.CurrentIteration = j;
                                    bodyWithState(j, parallelLoopState);
                                }
                            }
                            else
                            {
                                for (int k = nFromInclusiveLocal; k < nToExclusiveLocal && (sharedPStateFlags.LoopStateFlags == 0 || !sharedPStateFlags.ShouldExitLoop(k)); k++)
                                {
                                    parallelLoopState.CurrentIteration = k;
                                    val = bodyWithLocal(k, parallelLoopState, val);
                                }
                            }
                            if (CheckTimeoutReached(timeoutOccursAt))
                            {
                                replicationDelegateYieldedBeforeCompletion = true;
                                break;
                            }
                        }
                        while (currentWorker.FindNewWork32(out nFromInclusiveLocal, out nToExclusiveLocal) && (sharedPStateFlags.LoopStateFlags == 0 || !sharedPStateFlags.ShouldExitLoop(nFromInclusiveLocal)));
                    }
                    catch (Exception source)
                    {
                        sharedPStateFlags.SetExceptional();
                        ExceptionDispatchInfo.Throw(source);
                    }
                    finally
                    {
                        if (localFinally != null && flag)
                        {
                            localFinally(val);
                        }
                        if (ParallelEtwProvider.Log.IsEnabled())
                        {
                            ParallelEtwProvider.Log.ParallelJoin(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID);
                        }
                    }
                }, parallelOptions, stopOnFirstFailure: true);
            }
            finally
            {
                if (parallelOptions.CancellationToken.CanBeCanceled)
                {
                    cancellationTokenRegistration.Dispose();
                }
            }
            if (oce != null)
            {
                throw oce;
            }
        }
        catch (AggregateException ex)
        {
            ThrowSingleCancellationExceptionOrOtherException(ex.InnerExceptions, parallelOptions.CancellationToken, ex);
        }
        finally
        {
            int loopStateFlags = sharedPStateFlags.LoopStateFlags;
            result._completed = loopStateFlags == 0;
            if (((uint)loopStateFlags & 2u) != 0)
            {
                result._lowestBreakIteration = sharedPStateFlags.LowestBreakIteration;
            }
            if (ParallelEtwProvider.Log.IsEnabled())
            {
                int num = 0;
                num = ((loopStateFlags == 0) ? (toExclusive - fromInclusive) : (((loopStateFlags & 2) == 0) ? (-1) : (sharedPStateFlags.LowestBreakIteration - fromInclusive)));
                ParallelEtwProvider.Log.ParallelLoopEnd(TaskScheduler.Current.Id, Task.CurrentId.GetValueOrDefault(), forkJoinContextID, num);
            }
        }
        return result;
    }

References System.Threading.Tasks.Parallel.CheckTimeoutReached(), System.Threading.Tasks.Parallel.ComputeTimeoutPoint(), System.Threading.Tasks.TaskScheduler.Current, System.Threading.Tasks.Task< TResult >.CurrentId, System.Threading.Interlocked.Increment(), System.L, System.Threading.Tasks.ParallelEtwProvider.Log, System.Environment.ProcessorCount, System.Threading.Tasks.Parallel.s_forkJoinContextID, System.source, System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw(), System.Threading.Tasks.Parallel.ThrowSingleCancellationExceptionOrOtherException(), and System.timeout.