通过反编译得到System.Core程序集中System.Linq命名空间下的Enumerable类
通过反编译得到System.Core程序集中System.Linq命名空间下的Enumerable类如下所示：
using System.Collections;using System.Collections.Generic;using System.Threading;namespace System.Linq{ [__DynamicallyInvokable] public static class Enumerable { private abstract class Iterator<TSource> : IEnumerable<TSource>, IEnumerable, IEnumerator<TSource>, IDisposable, IEnumerator { private int threadId; internal int state; internal TSource current; public TSource Current => current; object IEnumerator.Current => Current; public Iterator() { threadId = Thread.CurrentThread.ManagedThreadId; } public abstract Iterator<TSource> Clone(); public virtual void Dispose() { current = default(TSource); state = -1; } public IEnumerator<TSource> GetEnumerator() { if (threadId == Thread.CurrentThread.ManagedThreadId && state == 0) { state = 1; return this; } Iterator<TSource> iterator = Clone(); iterator.state = 1; return iterator; } public abstract bool MoveNext(); public abstract IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector); public abstract IEnumerable<TSource> Where(Func<TSource, bool> predicate); IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } void IEnumerator.Reset() { throw new NotImplementedException(); } } private class WhereEnumerableIterator<TSource> : Iterator<TSource> { private IEnumerable<TSource> source; private Func<TSource, bool> predicate; private IEnumerator<TSource> enumerator; public WhereEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate) { this.source = source; this.predicate = predicate; } public override Iterator<TSource> Clone() { return new WhereEnumerableIterator<TSource>(source, predicate); } public override void Dispose() { if (enumerator != null) { enumerator.Dispose(); } enumerator = null; base.Dispose(); } public override bool MoveNext() { int state = base.state; if (state != 1) { if (state != 2) { goto IL_0061; } } else { enumerator = source.GetEnumerator(); base.state = 2; } while (enumerator.MoveNext()) { TSource current = enumerator.Current; if (predicate(current)) { base.current = current; return true; } } Dispose(); goto IL_0061; IL_0061: return false; } public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) { return new WhereSelectEnumerableIterator<TSource, TResult>(source, predicate, selector); } public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) { return new WhereEnumerableIterator<TSource>(source, CombinePredicates(this.predicate, predicate)); } } private class WhereArrayIterator<TSource> : Iterator<TSource> { private TSource[] source; private Func<TSource, bool> predicate; private int index; public WhereArrayIterator(TSource[] source, Func<TSource, bool> predicate) { this.source = source; this.predicate = predicate; } public override Iterator<TSource> Clone() { return new WhereArrayIterator<TSource>(source, predicate); } public override bool MoveNext() { if (state == 1) { while (index < source.Length) { TSource val = source[index]; index++; if (predicate(val)) { current = val; return true; } } Dispose(); } return false; } public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) { return new WhereSelectArrayIterator<TSource, TResult>(source, predicate, selector); } public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) { return new WhereArrayIterator<TSource>(source, CombinePredicates(this.predicate, predicate)); } } private class WhereListIterator<TSource> : Iterator<TSource> { private List<TSource> source; private Func<TSource, bool> predicate; private List<TSource>.Enumerator enumerator; public WhereListIterator(List<TSource> source, Func<TSource, bool> predicate) { this.source = source; this.predicate = predicate; } public override Iterator<TSource> Clone() { return new WhereListIterator<TSource>(source, predicate); } public override bool MoveNext() { int state = base.state; if (state != 1) { if (state != 2) { goto IL_0061; } } else { enumerator = source.GetEnumerator(); base.state = 2; } while (enumerator.MoveNext()) { TSource current = enumerator.Current; if (predicate(current)) { base.current = current; return true; } } Dispose(); goto IL_0061; IL_0061: return false; } public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) { return new WhereSelectListIterator<TSource, TResult>(source, predicate, selector); } public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) { return new WhereListIterator<TSource>(source, CombinePredicates(this.predicate, predicate)); } } private class SelectEnumerableIterator<TSource, TResult> : Iterator<TResult>, IIListProvider<TResult>, IEnumerable<TResult>, IEnumerable { private readonly IEnumerable<TSource> _source; private readonly Func<TSource, TResult> _selector; private IEnumerator<TSource> _enumerator; public SelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, TResult> selector) { _source = source; _selector = selector; } public override Iterator<TResult> Clone() { return new SelectEnumerableIterator<TSource, TResult>(_source, _selector); } public override void Dispose() { if (_enumerator != null) { _enumerator.Dispose(); _enumerator = null; } base.Dispose(); } public override bool MoveNext() { int state = base.state; if (state != 1) { if (state != 2) { goto IL_005a; } } else { _enumerator = _source.GetEnumerator(); base.state = 2; } if (_enumerator.MoveNext()) { current = _selector(_enumerator.Current); return true; } Dispose(); goto IL_005a; IL_005a: return false; } public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) { return new SelectEnumerableIterator<TSource, TResult2>(_source, CombineSelectors(_selector, selector)); } public override IEnumerable<TResult> Where(Func<TResult, bool> predicate) { return new WhereEnumerableIterator<TResult>(this, predicate); } public TResult[] ToArray() { LargeArrayBuilder<TResult> largeArrayBuilder = new LargeArrayBuilder<TResult>(initialize: true); foreach (TSource item in _source) { largeArrayBuilder.Add(_selector(item)); } return largeArrayBuilder.ToArray(); } public List<TResult> ToList() { List<TResult> list = new List<TResult>(); foreach (TSource item in _source) { list.Add(_selector(item)); } return list; } public int GetCount(bool onlyIfCheap) { if (onlyIfCheap) { return -1; } int num = 0; foreach (TSource item in _source) { _selector(item); num = checked(num + 1); } return num; } } private class WhereSelectEnumerableIterator<TSource, TResult> : Iterator<TResult> { private IEnumerable<TSource> source; private Func<TSource, bool> predicate; private Func<TSource, TResult> selector; private IEnumerator<TSource> enumerator; public WhereSelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector) { this.source = source; this.predicate = predicate; this.selector = selector; } public override Iterator<TResult> Clone() { return new WhereSelectEnumerableIterator<TSource, TResult>(source, predicate, selector); } public override void Dispose() { if (enumerator != null) { enumerator.Dispose(); } enumerator = null; base.Dispose(); } public override bool MoveNext() { int state = base.state; if (state != 1) { if (state != 2) { goto IL_0074; } } else { enumerator = source.GetEnumerator(); base.state = 2; } while (enumerator.MoveNext()) { TSource current = enumerator.Current; if (predicate == null || predicate(current)) { base.current = selector(current); return true; } } Dispose(); goto IL_0074; IL_0074: return false; } public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) { return new WhereSelectEnumerableIterator<TSource, TResult2>(source, predicate, CombineSelectors(this.selector, selector)); } public override IEnumerable<TResult> Where(Func<TResult, bool> predicate) { return new WhereEnumerableIterator<TResult>(this, predicate); } } private class WhereSelectArrayIterator<TSource, TResult> : Iterator<TResult> { private TSource[] source; private Func<TSource, bool> predicate; private Func<TSource, TResult> selector; private int index; public WhereSelectArrayIterator(TSource[] source, Func<TSource, bool> predicate, Func<TSource, TResult> selector) { this.source = source; this.predicate = predicate; this.selector = selector; } public override Iterator<TResult> Clone() { return new WhereSelectArrayIterator<TSource, TResult>(source, predicate, selector); } public override bool MoveNext() { if (state == 1) { while (index < source.Length) { TSource arg = source[index]; index++; if (predicate == null || predicate(arg)) { current = selector(arg); return true; } } Dispose(); } return false; } public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) { return new WhereSelectArrayIterator<TSource, TResult2>(source, predicate, CombineSelectors(this.selector, selector)); } public override IEnumerable<TResult> Where(Func<TResult, bool> predicate) { return new WhereEnumerableIterator<TResult>(this, predicate); } } private class WhereSelectListIterator<TSource, TResult> : Iterator<TResult> { private List<TSource> source; private Func<TSource, bool> predicate; private Func<TSource, TResult> selector; private List<TSource>.Enumerator enumerator; public WhereSelectListIterator(List<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector) { this.source = source; this.predicate = predicate; this.selector = selector; } public override Iterator<TResult> Clone() { return new WhereSelectListIterator<TSource, TResult>(source, predicate, selector); } public override bool MoveNext() { int state = base.state; if (state != 1) { if (state != 2) { goto IL_0074; } } else { enumerator = source.GetEnumerator(); base.state = 2; } while (enumerator.MoveNext()) { TSource current = enumerator.Current; if (predicate == null || predicate(current)) { base.current = selector(current); return true; } } Dispose(); goto IL_0074; IL_0074: return false; } public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector) { return new WhereSelectListIterator<TSource, TResult2>(source, predicate, CombineSelectors(this.selector, selector)); } public override IEnumerable<TResult> Where(Func<TResult, bool> predicate) { return new WhereEnumerableIterator<TResult>(this, predicate); } } private abstract class AppendPrependIterator<TSource> : Iterator<TSource>, IIListProvider<TSource>, IEnumerable<TSource>, IEnumerable { protected readonly IEnumerable<TSource> _source; protected IEnumerator<TSource> enumerator; protected AppendPrependIterator(IEnumerable<TSource> source) { _source = source; } protected void GetSourceEnumerator() { enumerator = _source.GetEnumerator(); } public abstract AppendPrependIterator<TSource> Append(TSource item); public abstract AppendPrependIterator<TSource> Prepend(TSource item); protected bool LoadFromEnumerator() { if (enumerator.MoveNext()) { current = enumerator.Current; return true; } Dispose(); return false; } public override void Dispose() { if (enumerator != null) { enumerator.Dispose(); enumerator = null; } base.Dispose(); } public override IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) { return new SelectEnumerableIterator<TSource, TResult>(this, selector); } public override IEnumerable<TSource> Where(Func<TSource, bool> predicate) { return new WhereEnumerableIterator<TSource>(this, predicate); } public abstract TSource[] ToArray(); public abstract List<TSource> ToList(); public abstract int GetCount(bool onlyIfCheap); } private class AppendPrepend1Iterator<TSource> : AppendPrependIterator<TSource> { private readonly TSource _item; private readonly bool _appending; public AppendPrepend1Iterator(IEnumerable<TSource> source, TSource item, bool appending) : base(source) { _item = item; _appending = appending; } public override Iterator<TSource> Clone() { return new AppendPrepend1Iterator<TSource>(_source, _item, _appending); } public override bool MoveNext() { switch (state) { case 1: state = 2; if (!_appending) { current = _item; return true; } goto case 2; case 2: GetSourceEnumerator(); state = 3; goto case 3; case 3: if (LoadFromEnumerator()) { return true; } if (_appending) { current = _item; return true; } break; } Dispose(); return false; } public override AppendPrependIterator<TSource> Append(TSource item) { if (_appending) { return new AppendPrependN<TSource>(_source, null, new SingleLinkedNode<TSource>(_item).Add(item), 0, 2); } return new AppendPrependN<TSource>(_source, new SingleLinkedNode<TSource>(_item), new SingleLinkedNode<TSource>(item), 1, 1); } public override AppendPrependIterator<TSource> Prepend(TSource item) { if (_appending) { return new AppendPrependN<TSource>(_source, new SingleLinkedNode<TSource>(item), new SingleLinkedNode<TSource>(_item), 1, 1); } return new AppendPrependN<TSource>(_source, new SingleLinkedNode<TSource>(_item).Add(item), null, 2, 0); } private TSource[] LazyToArray() { LargeArrayBuilder<TSource> largeArrayBuilder = new LargeArrayBuilder<TSource>(initialize: true); if (!_appending) { largeArrayBuilder.SlowAdd(_item); } largeArrayBuilder.AddRange(_source); if (_appending) { largeArrayBuilder.SlowAdd(_item); } return largeArrayBuilder.ToArray(); } public override TSource[] ToArray() { int count = GetCount(onlyIfCheap: true); if (count == -1) { return LazyToArray(); } TSource[] array = new TSource[count]; int arrayIndex; if (_appending) { arrayIndex = 0; } else { array[0] = _item; arrayIndex = 1; } EnumerableHelpers.Copy(_source, array, arrayIndex, count - 1); if (_appending) { array[array.Length - 1] = _item; } return array; } public override List<TSource> ToList() { int count = GetCount(onlyIfCheap: true); List<TSource> list = (count == -1) ? new List<TSource>() : new List<TSource>(count); if (!_appending) { list.Add(_item); } list.AddRange(_source); if (_appending) { list.Add(_item); } return list; } public override int GetCount(bool onlyIfCheap) { IIListProvider<TSource> iIListProvider = _source as IIListProvider<TSource>; if (iIListProvider != null) { int count = iIListProvider.GetCount(onlyIfCheap); if (count != -1) { return count + 1; } return -1; } if (onlyIfCheap && !(_source is ICollection<TSource>)) { return -1; } return _source.Count() + 1; } } private class AppendPrependN<TSource> : AppendPrependIterator<TSource> { private readonly SingleLinkedNode<TSource> _prepended; private readonly SingleLinkedNode<TSource> _appended; private readonly int _prependCount; private readonly int _appendCount; private SingleLinkedNode<TSource> _node; public AppendPrependN(IEnumerable<TSource> source, SingleLinkedNode<TSource> prepended, SingleLinkedNode<TSource> appended, int prependCount, int appendCount) : base(source) { _prepended = prepended; _appended = appended; _prependCount = prependCount; _appendCount = appendCount; } public override Iterator<TSource> Clone() { return new AppendPrependN<TSource>(_source, _prepended, _appended, _prependCount, _appendCount); } public override bool MoveNext() { switch (state) { case 1: _node = _prepended; state = 2; goto case 2; case 2: if (_node != null) { current = _node.Item; _node = _node.Linked; return true; } GetSourceEnumerator(); state = 3; goto case 3; case 3: if (LoadFromEnumerator()) { return true; } if (_appended == null) { return false; } enumerator = _appended.GetEnumerator(_appendCount); state = 4; goto case 4; case 4: return LoadFromEnumerator(); default: Dispose(); return false; } } public override AppendPrependIterator<TSource> Append(TSource item) { SingleLinkedNode<TSource> appended = (_appended != null) ? _appended.Add(item) : new SingleLinkedNode<TSource>(item); return new AppendPrependN<TSource>(_source, _prepended, appended, _prependCount, _appendCount + 1); } public override AppendPrependIterator<TSource> Prepend(TSource item) { SingleLinkedNode<TSource> prepended = (_prepended != null) ? _prepended.Add(item) : new SingleLinkedNode<TSource>(item); return new AppendPrependN<TSource>(_source, prepended, _appended, _prependCount + 1, _appendCount); } private TSource[] LazyToArray() { SparseArrayBuilder<TSource> sparseArrayBuilder = new SparseArrayBuilder<TSource>(initialize: true); if (_prepended != null) { sparseArrayBuilder.Reserve(_prependCount); } sparseArrayBuilder.AddRange(_source); if (_appended != null) { sparseArrayBuilder.Reserve(_appendCount); } TSource[] array = sparseArrayBuilder.ToArray(); int num = 0; for (SingleLinkedNode<TSource> singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked) { array[num++] = singleLinkedNode.Item; } num = array.Length - 1; for (SingleLinkedNode<TSource> singleLinkedNode2 = _appended; singleLinkedNode2 != null; singleLinkedNode2 = singleLinkedNode2.Linked) { array[num--] = singleLinkedNode2.Item; } return array; } public override TSource[] ToArray() { int count = GetCount(onlyIfCheap: true); if (count == -1) { return LazyToArray(); } TSource[] array = new TSource[count]; int num = 0; for (SingleLinkedNode<TSource> singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked) { array[num] = singleLinkedNode.Item; num++; } ICollection<TSource> collection = _source as ICollection<TSource>; if (collection != null) { collection.CopyTo(array, num); } else { foreach (TSource item in _source) { TSource val = array[num] = item; num++; } } num = array.Length; for (SingleLinkedNode<TSource> singleLinkedNode2 = _appended; singleLinkedNode2 != null; singleLinkedNode2 = singleLinkedNode2.Linked) { num--; array[num] = singleLinkedNode2.Item; } return array; } public override List<TSource> ToList() { int count = GetCount(onlyIfCheap: true); List<TSource> list = (count == -1) ? new List<TSource>() : new List<TSource>(count); for (SingleLinkedNode<TSource> singleLinkedNode = _prepended; singleLinkedNode != null; singleLinkedNode = singleLinkedNode.Linked) { list.Add(singleLinkedNode.Item); } list.AddRange(_source); if (_appended != null) { IEnumerator<TSource> enumerator = _appended.GetEnumerator(_appendCount); while (enumerator.MoveNext()) { list.Add(enumerator.Current); } } return list; } public override int GetCount(bool onlyIfCheap) { IIListProvider<TSource> iIListProvider = _source as IIListProvider<TSource>; if (iIListProvider != null) { int count = iIListProvider.GetCount(onlyIfCheap); if (count != -1) { return count + _appendCount + _prependCount; } return -1; } if (onlyIfCheap && !(_source is ICollection<TSource>)) { return -1; } return _source.Count() + _appendCount + _prependCount; } } [__DynamicallyInvokable] public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) { if (source == null) { throw Error.ArgumentNull("source"); } if (predicate == null) { throw Error.ArgumentNull("predicate"); } if (source is Iterator<TSource>) { return ((Iterator<TSource>)source).Where(predicate); } if (source is TSource[]) { return new WhereArrayIterator<TSource>((TSource[])source, predicate); } if (source is List<TSource>) { return new WhereListIterator<TSource>((List<TSource>)source, predicate); } return new WhereEnumerableIterator<TSource>(source, predicate); } [__DynamicallyInvokable] public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate) { if (source == null) { throw Error.ArgumentNull("source"); } if (predicate == null) { throw Error.ArgumentNull("predicate"); } return WhereIterator(source, predicate); } private static IEnumerable<TSource> WhereIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate) { int index = -1; foreach (TSource item in source) { index = checked(index + 1); if (predicate(item, index)) { yield return item; } } } [__DynamicallyInvokable] public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector) { if (source == null) { throw Error.ArgumentNull("source"); } if (selector == null) { throw Error.ArgumentNull("selector"); } if (source is Iterator<TSource>) { return ((Iterator<TSource>)source).Select(selector); } if (source is TSource[]) { return new WhereSelectArrayIterator<TSource, TResult>((TSource[])source, null, selector); } if (source is List<TSource>) { return new WhereSelectListIterator<TSource, TResult>((List<TSource>)source, null, selector); } return new WhereSelectEnumerableIterator<TSource, TResult>(source, null, selector); } [__DynamicallyInvokable] public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector) { if (source == null) { throw Error.ArgumentNull("source"); } if (selector == null) { throw Error.ArgumentNull("selector"); } return SelectIterator(source, selector); } private static IEnumerable<TResult> SelectIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, int, TResult> selector) { int index = -1; foreach (TSource item in source) { index = checked(index + 1); yield return selector(item, index); } } private static Func<TSource, bool> CombinePredicates<TSource>(Func<TSource, bool> predicate1, Func<TSource, bool> predicate2) { return (TSource x) => predicate1(x) && predicate2(x); } private static Func<TSource, TResult> CombineSelectors<TSource, TMiddle, TResult>(Func<TSource, TMiddle> selector1, Func<TMiddle, TResult> selector2) { return (TSource x) => selector2(selector1(x)); } [__DynamicallyInvokable] public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector) { if (source == null) { throw Error.ArgumentNull("source"); } if (selector == null) { throw Error.ArgumentNull("selector"); } return SelectManyIterator(source, selector); } private static IEnumerable<TResult> SelectManyIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector) { foreach (TSource item in source) { foreach (TResult item2 in selector(item)) { yield return item2; } } } [__DynamicallyInvokable] public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector) { if (source == null) { throw Error.ArgumentNull("source"); } if (selector == null) { throw Error.ArgumentNull("selector"); } return SelectManyIterator(source, selector); } private static IEnumerable<TResult> SelectManyIterator<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector) { int index = -1; foreach (TSource item in source) { index = checked(index + 1); foreach (TResult item2 in selector(item, index)) { yield return item2; } } } [__DynamicallyInvokable] public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector) { if (source == null) { throw Error.ArgumentNull("source"); } if (collectionSelector == null) { throw Error.ArgumentNull("collectionSelector"); } if (resultSelector == null) { throw Error.ArgumentNull("resultSelector"); } return SelectManyIterator(source, collectionSelector, resultSelector); } private static IEnumerable<TResult> SelectManyIterator<TSource, TCollection, TResult>(IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector) { int index = -1; foreach (TSource element in source) { index = checked(index + 1); foreach (TCollection item in collectionSelector(element, index)) { yield return resultSelector(element, item); } } } [__DynamicallyInvokable] public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector) { if (source == null) { throw Error.ArgumentNull("source"); } if (collectionSelector == null) { throw Error.ArgumentNull("collectionSelector"); } if (resultSelector == null) { throw Error.ArgumentNull("resultSelector"); } return SelectManyIterator(source, collectionSelector, resultSelector); } private static IEnumerable<TResult> SelectManyIterator<TSource, TCollection, TResult>(IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector) { foreach (TSource element in source) { foreach (TCollection item in collectionSelector(element)) { yield return resultSelector(element, item); } } } [__DynamicallyInvokable] public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count) { if (source == null) { throw Error.ArgumentNull("source"); } return TakeIterator(source, count); } private static IEnumerable<TSource> TakeIterator<TSource>(IEnumerable<TSource> source, int count) { if (count > 0) { foreach (TSource item in source) { yield return item; int num = count - 1; count = num; if (num == 0) { break; } } } } [__DynamicallyInvokable] public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) { if (source == null) { throw Error.ArgumentNull("source"); } if (predicate == null) { throw Error.ArgumentNull("predicate"); } return TakeWhileIterator(source, predicate); } private static IEnumerable<TSource> TakeWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate) { foreach (TSource item in source) { if (!predicate(item)) { break; } yield return item; } } [__DynamicallyInvokable] public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate) { if (source == null) { throw Error.ArgumentNull("source"); } if (predicate == null) { throw Error.ArgumentNull("predicate"); } return TakeWhileIterator(source, predicate); } private static IEnumerable<TSource> TakeWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate) { int index = -1; foreach (TSource item in source) { index = checked(index + 1); if (!predicate(item, index)) { break; } yield return item; } } [__DynamicallyInvokable] public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count) { if (source == null) { throw Error.ArgumentNull("source"); } return SkipIterator(source, count); } private static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count) { using (IEnumerator<TSource> e = source.GetEnumerator()) { while (count > 0 && e.MoveNext()) { count--; } if (count <= 0) { while (e.MoveNext()) { yield return e.Current; } } } } [__DynamicallyInvokable] public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) { if (source == null) { throw Error.ArgumentNull("source"); } if (predicate == null) { throw Error.ArgumentNull("predicate"); } return SkipWhileIterator(source, predicate); } private static IEnumerable<TSource> SkipWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate) { bool yielding = false; foreach (TSource item in source) { if (!yielding && !predicate(item)) { yielding = true; } if (yielding) { yield return item; } } } [__DynamicallyInvokable] public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate) { if (source == null) { throw Error.ArgumentNull("source"); } if (predicate == null) { throw Error.ArgumentNull("predicate"); } return SkipWhileIterator(source, predicate); } private static IEnumerable<TSource> SkipWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate) { int index = -1; bool yielding = false; foreach (TSource item in source) { index = checked(index + 1); if (!yielding && !predicate(item, index)) { yielding = true; } if (yielding) { yield return item; } } } [__DynamicallyInvokable] public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector) { if (outer == null) { throw Error.ArgumentNull("outer"); } if (inner == null) { throw Error.ArgumentNull("inner"); } if (outerKeySelector == null) { throw Error.ArgumentNull("outerKeySelector"); } if (innerKeySelector == null) { throw Error.ArgumentNull("innerKeySelector"); } if (resultSelector == null) { throw Error.ArgumentNull("resultSelector"); } return JoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, null); } [__DynamicallyInvokable] public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer) { if (outer == null) { throw Error.ArgumentNull("outer"); } if (inner == null) { throw Error.ArgumentNull("inner"); } if (outerKeySelector == null) { throw Error.ArgumentNull("outerKeySelector"); } if (innerKeySelector == null) { throw Error.ArgumentNull("innerKeySelector"); } if (resultSelector == null) { throw Error.ArgumentNull("resultSelector"); } return JoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } private static IEnumerable<TResult> JoinIterator<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer) { Lookup<TKey, TInner> lookup = Lookup<TKey, TInner>.CreateForJoin(inner, innerKeySelector, comparer); foreach (TOuter item in outer) { Lookup<TKey, TInner>.Grouping g = lookup.GetGrouping(outerKeySelector(item), create: false); if (g != null) { for (int i = 0; i < g.count; i++) { yield return resultSelector(item, g.elements[i]); } } } } [__DynamicallyInvokable] public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector) { if (outer == null) { throw Error.ArgumentNull("outer"); } if (inner == null) { throw Error.ArgumentNull("inner"); } if (outerKeySelector == null) { throw Error.ArgumentNull("outerKeySelector"); } if (innerKeySelector == null) { throw Error.ArgumentNull("innerKeySelector"); } if (resultSelector == null) { throw Error.ArgumentNull("resultSelector"); } return GroupJoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, null); } [__DynamicallyInvokable] public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer) { if (outer == null) { throw Error.ArgumentNull("outer"); } if (inner == null) { throw Error.ArgumentNull("inner"); } if (outerKeySelector == null) { throw Error.ArgumentNull("outerKeySelector"); } if (innerKeySelector == null) { throw Error.ArgumentNull("innerKeySelector"); } if (resultSelector == null) { throw Error.ArgumentNull("resultSelector"); } return GroupJoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer); } private static IEnumerable<TResult> GroupJoinIterator<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer) { Lookup<TKey, TInner> lookup = Lookup<TKey, TInner>.CreateForJoin(inner, innerKeySelector, comparer); foreach (TOuter item in outer) { yield return resultSelector(item, lookup[outerKeySelector(item)]); } } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) { return new OrderedEnumerable<TSource, TKey>(source, keySelector, null, descending: false); } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) { return new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, descending: false); } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) { return new OrderedEnumerable<TSource, TKey>(source, keySelector, null, descending: true); } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) { return new OrderedEnumerable<TSource, TKey>(source, keySelector, comparer, descending: true); } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector) { if (source == null) { throw Error.ArgumentNull("source"); } return source.CreateOrderedEnumerable(keySelector, null, descending: false); } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) { if (source == null) { throw Error.ArgumentNull("source"); } return source.CreateOrderedEnumerable(keySelector, comparer, descending: false); } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector) { if (source == null) { throw Error.ArgumentNull("source"); } return source.CreateOrderedEnumerable(keySelector, null, descending: true); } [__DynamicallyInvokable] public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) { if (source == null) { throw Error.ArgumentNull("source"); } return source.CreateOrderedEnumerable(keySelector, comparer, descending: true); } [__DynamicallyInvokable] public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) { return new GroupedEnumerable<TSource, TKey, TSource>(source, keySelector, IdentityFunction<TSource>.Instance, null); } [__DynamicallyInvokable] public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) { return new GroupedEnumerable<TSource, TKey, TSource>(source, keySelector, IdentityFunction<TSource>.Instance, comparer); } [__DynamicallyInvokable] public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) { return new GroupedEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, null); } [__DynamicallyInvokable] public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) { return new GroupedEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer); } [__DynamicallyInvokable] public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector) { return new GroupedEnumerable<TSource, TKey, TSource, TResult>(source, keySelector, IdentityFunction<TSource>.Instance, resultSelector, null); } [__DynamicallyInvokable] public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector) { return new GroupedEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, null); } [__DynamicallyInvokable] public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer) { return new GroupedEnumerable<TSource, TKey, TSource, TResult>(source, keySelector, IdentityFunction<TSource>.Instance, resultSelector, comparer); } [__DynamicallyInvokable] public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer) { return new GroupedEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer); } [__DynamicallyInvokable] public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second) { if (first == null) { throw Error.ArgumentNull("first"); } if (second == null) { throw Error.ArgumentNull("second"); } return ConcatIterator(first, second); } private static IEnumerable<TSource> ConcatIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second) { foreach (TSource item in first) { yield return item; } foreach (TSource item2 in second) { yield return item2; } } [__DynamicallyInvokable] public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector) { if (first == null) { throw Error.ArgumentNull("first"); } if (second == null) { throw Error.ArgumentNull("second"); } if (resultSelector == null) { throw Error.ArgumentNull("resultSelector"); } return ZipIterator(first, second, resultSelector); } private static IEnumerable<TResult> ZipIterator<TFirst, TSecond, TResult>(IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector) { using (IEnumerator<TFirst> e3 = first.GetEnumerator()) { using (IEnumerator<TSecond> e2 = second.GetEnumerator()) { while (e3.MoveNext() && e2.MoveNext()) { yield return resultSelector(e3.Current, e2.Current); } } } } [__DynamicallyInvokable] public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source) { if (source == null) { throw Error.ArgumentNull("source"); } return DistinctIterator(source, null); } [__DynamicallyInvokable] public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer) { if (source == null) { throw Error.ArgumentNull("source"); } return DistinctIterator(source, comparer); } private static IEnumerable<TSource> DistinctIterator<TSource>(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer) { Set<TSource> set = new Set<TSource>(comparer); foreach (TSource item in source) { if (set.Add(item)) { yield return item; } } } [__DynamicallyInvokable] public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second) { if (first == null) { throw Error.ArgumentNull("first"); } if (second == null) { throw Error.ArgumentNull("second"); } return UnionIterator(first, second, null); } [__DynamicallyInvokable] public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) { if (first == null) { throw Error.ArgumentNull("first"); } if (second == null) { throw Error.ArgumentNull("second"); } return UnionIterator(first, second, comparer); } private static IEnumerable<TSource> UnionIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) { Set<TSource> set = new Set<TSource>(comparer); foreach (TSource item in first) { if (set.Add(item)) { yield return item; } } foreach (TSource item2 in second) { if (set.Add(item2)) { yield return item2; } } } [__DynamicallyInvokable] public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second) { if (first == null) { throw Error.ArgumentNull("first"); } if (second == null) { throw Error.ArgumentNull("second"); } return IntersectIterator(first, second, null); } [__DynamicallyInvokable] public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) { if (first == null) { throw Error.ArgumentNull("first"); } if (second == null) { throw Error.ArgumentNull("second"); } return IntersectIterator(first, second, comparer); } private static IEnumerable<TSource> IntersectIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer) { Set<TSource> set = new Set<TSource>(comparer); foreach (TSource item in second) { set.A.........本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
