TakeRangeFromEndIterator< TSource >()

static IEnumerable< TSource > System.Linq.Enumerable.TakeRangeFromEndIterator< TSource > ( IEnumerable< TSource > source, bool isStartIndexFromEnd, int startIndex, bool isEndIndexFromEnd, int endIndex )

inlinestaticprivate

Definition at line 8131 of file Enumerable.cs.

    {
        if (source.TryGetNonEnumeratedCount(out var count2))
        {
            startIndex = CalculateStartIndex(isStartIndexFromEnd, startIndex, count2);
            endIndex = CalculateEndIndex(isEndIndexFromEnd, endIndex, count2);
            if (startIndex >= endIndex)
            {
                yield break;
            }
            foreach (TSource item in TakeRangeIterator(source, startIndex, endIndex))
            {
                yield return item;
            }
            yield break;
        }
        if (isStartIndexFromEnd)
        {
            Queue<TSource> queue;
            using (IEnumerator<TSource> enumerator2 = source.GetEnumerator())
            {
                if (!enumerator2.MoveNext())
                {
                    yield break;
                }
                queue = new Queue<TSource>();
                queue.Enqueue(enumerator2.Current);
                count2 = 1;
                while (enumerator2.MoveNext())
                {
                    if (count2 < startIndex)
                    {
                        queue.Enqueue(enumerator2.Current);
                        count2++;
                        continue;
                    }
                    do
                    {
                        queue.Dequeue();
                        queue.Enqueue(enumerator2.Current);
                        count2 = checked(count2 + 1);
                    }
                    while (enumerator2.MoveNext());
                    break;
                }
            }
            startIndex = CalculateStartIndex(isStartIndexFromEnd: true, startIndex, count2);
            endIndex = CalculateEndIndex(isEndIndexFromEnd, endIndex, count2);
            for (int rangeIndex = startIndex; rangeIndex < endIndex; rangeIndex++)
            {
                yield return queue.Dequeue();
            }
            yield break;
        }
        using (IEnumerator<TSource> enumerator = source.GetEnumerator())
        {
            for (count2 = 0; count2 < startIndex; count2++)
            {
                if (!enumerator.MoveNext())
                {
                    break;
                }
            }
            if (count2 != startIndex)
            {
                yield break;
            }
            Queue<TSource> queue = new Queue<TSource>();
            while (enumerator.MoveNext())
            {
                if (queue.Count == endIndex)
                {
                    do
                    {
                        queue.Enqueue(enumerator.Current);
                        yield return queue.Dequeue();
                    }
                    while (enumerator.MoveNext());
                    break;
                }
                queue.Enqueue(enumerator.Current);
            }
        }
        static int CalculateEndIndex(bool isEndIndexFromEnd, int endIndex, int count)
        {
            return Math.Min(count, isEndIndexFromEnd ? (count - endIndex) : endIndex);
        }
        static int CalculateStartIndex(bool isStartIndexFromEnd, int startIndex, int count)
        {
            return Math.Max(0, isStartIndexFromEnd ? (count - startIndex) : startIndex);
        }
    }

References System.Linq.count, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.endIndex, System.Collections.Generic.Dictionary< TKey, TValue >.GetEnumerator(), System.item, System.Math.Max(), System.Math.Min(), System.Linq.source, and System.startIndex.