Class SuperEnumerable
Provides a set of static methods for querying objects that implement IEnumerable<T>.
Inherited Members
Namespace: SuperLinq
Assembly: SuperLinq.dll
Syntax
public static class SuperEnumerableMethods
| Name | Description |
|---|---|
| AggregateBy<TSource, TKey, TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TAccumulate>, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns an aggregate value for each key. An additional argument specifies a comparer to use for testing equivalence of keys. |
| AggregateBy<TSource, TKey, TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns an aggregate value for each key. An additional argument specifies a comparer to use for testing equivalence of keys. |
| AggregateRight<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) | Applies a right-associative accumulator function over a sequence. This operator is the right-associative version of the Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| AggregateRight<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>) | Applies a right-associative accumulator function over a sequence. The specified |
| AggregateRight<TSource, TAccumulate, TResult>(IEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>, Func<TAccumulate, TResult>) | Applies a right-associative accumulator function over a sequence. The specified |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>, TAccumulate8, Func<TAccumulate8, T, TAccumulate8>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>) | Applies eight accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>) | Applies two accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, Func<TAccumulate1, TAccumulate2, TResult>) | Applies two accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>) | Applies three accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>) | Applies three accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>) | Applies four accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>) | Applies four accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>) | Applies five accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>) | Applies five accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>) | Applies six accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>) | Applies six accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>) | Applies seven accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>) | Applies seven accumulators sequentially in a single pass over a sequence. |
| Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>, TAccumulate8, Func<TAccumulate8, T, TAccumulate8>) | Applies eight accumulators sequentially in a single pass over a sequence. |
| AssertCount<TSource>(IEnumerable<TSource>, int) | Asserts that a source sequence contains a given count of elements. |
| AtLeast<T>(IEnumerable<T>, int) | Determines whether or not the number of elements in the sequence is greater than or equal to the given integer. |
| AtMost<T>(IEnumerable<T>, int) | Determines whether or not the number of elements in the sequence is lesser than or equal to the given integer. |
| Backsert<T>(IEnumerable<T>, IEnumerable<T>, int) | Inserts the elements of a sequence into another sequence at a specified index from the tail of the sequence, where zero always represents the last position, one represents the second-last element, two represents the third-last element and so on. |
| Batch<TSource>(IEnumerable<TSource>, int) | Split the elements of a sequence into chunks of size at most |
| Batch<TSource, TResult>(IEnumerable<TSource>, int, ReadOnlySpanFunc<TSource, TResult>) | Split the elements of a sequence into chunks of size at most |
| Batch<TSource, TResult>(IEnumerable<TSource>, TSource[], ReadOnlySpanFunc<TSource, TResult>) | Split the elements of a sequence into chunks of size at most |
| Batch<TSource, TResult>(IEnumerable<TSource>, TSource[], int, ReadOnlySpanFunc<TSource, TResult>) | Split the elements of a sequence into chunks of size at most |
| BindByIndex<TSource>(IEnumerable<TSource>, IEnumerable<int>) | Selects elements by index from a sequence. |
| BindByIndex<TSource, TResult>(IEnumerable<TSource>, IEnumerable<int>, Func<TSource, int, TResult>, Func<int, TResult>) | Selects elements by index from a sequence and transforms them using the provided functions. |
| Buffer<TSource>(IEnumerable<TSource>, int) | Generates a sequence of non-overlapping adjacent buffers over the source sequence. |
| Buffer<TSource>(IEnumerable<TSource>, int, int) | Generates a sequence of buffers over the source sequence, with specified length and possible overlap. |
| Cartesian<T1, T2>(IEnumerable<T1>, IEnumerable<T2>) | Returns the Cartesian product of two sequences by enumerating all possible combinations of one item from each sequence. |
| Cartesian<T1, T2, T3>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>) | Returns the Cartesian product of three sequences by enumerating all possible combinations of one item from each sequence. |
| Cartesian<T1, T2, TResult>(IEnumerable<T1>, IEnumerable<T2>, Func<T1, T2, TResult>) | Returns the Cartesian product of two sequences by enumerating all possible combinations of one item from each sequence, and applying a user-defined projection to the items in a given combination. |
| Cartesian<T1, T2, T3, T4>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>) | Returns the Cartesian product of four sequences by enumerating all possible combinations of one item from each sequence. |
| Cartesian<T1, T2, T3, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, Func<T1, T2, T3, TResult>) | Returns the Cartesian product of three sequences by enumerating all possible combinations of one item from each sequence, and applying a user-defined projection to the items in a given combination. |
| Cartesian<T1, T2, T3, T4, T5>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>) | Returns the Cartesian product of five sequences by enumerating all possible combinations of one item from each sequence. |
| Cartesian<T1, T2, T3, T4, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, Func<T1, T2, T3, T4, TResult>) | Returns the Cartesian product of four sequences by enumerating all possible combinations of one item from each sequence, and applying a user-defined projection to the items in a given combination. |
| Cartesian<T1, T2, T3, T4, T5, T6>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>) | Returns the Cartesian product of six sequences by enumerating all possible combinations of one item from each sequence. |
| Cartesian<T1, T2, T3, T4, T5, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, Func<T1, T2, T3, T4, T5, TResult>) | Returns the Cartesian product of five sequences by enumerating all possible combinations of one item from each sequence, and applying a user-defined projection to the items in a given combination. |
| Cartesian<T1, T2, T3, T4, T5, T6, T7>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>) | Returns the Cartesian product of seven sequences by enumerating all possible combinations of one item from each sequence. |
| Cartesian<T1, T2, T3, T4, T5, T6, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, Func<T1, T2, T3, T4, T5, T6, TResult>) | Returns the Cartesian product of six sequences by enumerating all possible combinations of one item from each sequence, and applying a user-defined projection to the items in a given combination. |
| Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>, IEnumerable<T8>) | Returns the Cartesian product of eight sequences by enumerating all possible combinations of one item from each sequence. |
| Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>, Func<T1, T2, T3, T4, T5, T6, T7, TResult>) | Returns the Cartesian product of seven sequences by enumerating all possible combinations of one item from each sequence, and applying a user-defined projection to the items in a given combination. |
| Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>, IEnumerable<T8>, Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>) | Returns the Cartesian product of eight sequences by enumerating all possible combinations of one item from each sequence, and applying a user-defined projection to the items in a given combination. |
| Case<TValue, TResult>(Func<TValue>, IDictionary<TValue, IEnumerable<TResult>>) | Returns a sequence from a dictionary based on the result of evaluating a selector function. |
| Case<TValue, TResult>(Func<TValue>, IDictionary<TValue, IEnumerable<TResult>>, IEnumerable<TResult>) | Returns a sequence from a dictionary based on the result of evaluating a selector function. |
| Catch<TSource>(IEnumerable<IEnumerable<TSource>>) | Creates a sequence by concatenating source sequences until a source sequence completes successfully. |
| Catch<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) | Creates a sequence that returns the elements of the first sequence, switching to the second in case of an error. |
| Catch<TSource>(params IEnumerable<TSource>[]) | Creates a sequence by concatenating source sequences until a source sequence completes successfully. |
| Catch<TSource, TException>(IEnumerable<TSource>, Func<TException, IEnumerable<TSource>>) | Creates a sequence that corresponds to the source sequence, concatenating it with the sequence resulting from calling an exception handler function in case of an error. |
| Choose<T, TResult>(IEnumerable<T>, Func<T, (bool, TResult)>) | Applies a function to each element of the source sequence and returns a new sequence of result elements for source elements where the function returns a couple (2-tuple) having a true as its first element and result as the second. |
| CollectionEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) | Determines whether two collections are equal by comparing the elements by using the default equality comparer for their type. |
| CollectionEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>?) | Determines whether two collections are equal by comparing the elements by using a specified IEqualityComparer<T>. |
| CompareCount<TFirst, TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) | Compares two sequences and returns an integer that indicates whether the first sequence has fewer, the same or more elements than the second sequence. |
| Consume<T>(IEnumerable<T>) | Completely consumes the given sequence. |
| CopyTo<TSource>(IEnumerable<TSource>, IList<TSource>) | Copies the contents of a sequence into a provided list. |
| CopyTo<TSource>(IEnumerable<TSource>, IList<TSource>, int) | Copies the contents of a sequence into a provided list. |
| CopyTo<TSource>(IEnumerable<TSource>, Span<TSource>) | Copies the contents of a sequence into a provided span. |
| CopyTo<TSource>(IEnumerable<TSource>, TSource[]) | Copies the contents of a sequence into a provided span. |
| CountBetween<T>(IEnumerable<T>, int, int) | Determines whether or not the number of elements in the sequence is between an inclusive range of minimum and maximum integers. |
| CountBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Applies a key-generating function to each element of a sequence and returns a sequence of unique keys and their number of occurrences in the original sequence. |
| CountBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns a sequence of unique keys and their number of occurrences in the original sequence. An additional argument specifies a comparer to use for testing equivalence of keys. |
| CountDown<TSource>(IEnumerable<TSource>, int) | Provides a countdown counter for a given count of elements at the tail of the sequence where zero always represents the last element, one represents the second-last element, two represents the third-last element and so on. |
| CountDown<TSource, TResult>(IEnumerable<TSource>, int, Func<TSource, int?, TResult>) | Provides a countdown counter for a given count of elements at the tail of the sequence where zero always represents the last element, one represents the second-last element, two represents the third-last element and so on. |
| Defer<TResult>(Func<IEnumerable<TResult>>) | Creates an enumerable sequence based on an enumerable factory function. |
| DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>) | Executes a partial sort of the top |
| DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection) | Executes a |
| DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?) | Executes a partial sort of the top |
| DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection) | Executes a |
| DensePartialSort<T>(IEnumerable<T>, int) | Executes a partial sort of the top |
| DensePartialSort<T>(IEnumerable<T>, int, OrderByDirection) | Executes a |
| DensePartialSort<T>(IEnumerable<T>, int, IComparer<T>?) | Executes a partial sort of the top |
| DensePartialSort<T>(IEnumerable<T>, int, IComparer<T>?, OrderByDirection) | Executes a |
| DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Ranks each item in the sequence in ascending order by a specified key using a default comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>) | Ranks each item in the sequence in ascending order by a specified key using a caller-supplied comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DenseRank<TSource>(IEnumerable<TSource>) | Ranks each item in the sequence in ascending order using a default comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRank<TSource>(IEnumerable<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DenseRank<TSource>(IEnumerable<TSource>, IComparer<TSource>) | Ranks each item in the sequence in ascending order using a caller-supplied comparer, with no gaps in the ranking values. The rank starts at one and keeps incrementing by one for each different item. |
| DenseRank<TSource>(IEnumerable<TSource>, IComparer<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| DistinctBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Returns all distinct elements of the given source, where "distinctness" is determined via a projection and the default equality comparer for the projected type. |
| DistinctBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Returns all distinct elements of the given source, where "distinctness" is determined via a projection and the default equality comparer for the projected type. |
| DistinctUntilChanged<TSource>(IEnumerable<TSource>) | Returns consecutive distinct elements by using the default equality comparer to compare values. |
| DistinctUntilChanged<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>?) | Returns consecutive distinct elements by using the specified equality comparer to compare values. |
| DistinctUntilChanged<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. |
| DistinctUntilChanged<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Returns consecutive distinct elements based on a key value by using the specified equality comparer to compare key values. |
| DoWhile<TSource>(IEnumerable<TSource>, Func<bool>) | Generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds. |
| Do<TSource>(IEnumerable<TSource>, Action<TSource>) | Lazily invokes an action for each value in the sequence. |
| Do<TSource>(IEnumerable<TSource>, Action<TSource>, Action) | Lazily invokes an action for each value in the sequence, and executes an action for successful termination. |
| Do<TSource>(IEnumerable<TSource>, Action<TSource>, Action<Exception>) | Lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination. |
| Do<TSource>(IEnumerable<TSource>, Action<TSource>, Action<Exception>, Action) | Lazily invokes an action for each value in the sequence, and executes an action upon successful or exceptional termination. |
| Duplicates<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>?) | Returns all duplicate elements of the given source. |
| ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index) | Returns the element at a specified index in a sequence or a default value if the index is out of range. |
| ElementAt<TSource>(IEnumerable<TSource>, Index) | Returns the element at a specified index in a sequence. |
| EndsWith<T>(IEnumerable<T>, IEnumerable<T>) | Determines whether the end of the first sequence is equivalent to the second sequence, using the default equality comparer. |
| EndsWith<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?) | Determines whether the end of the first sequence is equivalent to the second sequence, using the specified element equality comparer. |
| EquiZip<TFirst, TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) | Joins the corresponding elements of second sequences, producing a sequence of tuples containing them. |
| EquiZip<TFirst, TSecond, TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>) | Joins the corresponding elements of second sequences, producing a sequence of tuples containing them. |
| EquiZip<TFirst, TSecond, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TSecond, TResult>) | Applies a specified function to the corresponding elements of second sequences, producing a sequence of the results. The resulting sequence has the same length as the input sequences. If the input sequences are of different lengths, an exception is thrown. |
| EquiZip<TFirst, TSecond, TThird, TFourth>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>) | Joins the corresponding elements of second sequences, producing a sequence of tuples containing them. |
| EquiZip<TFirst, TSecond, TThird, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>) | Applies a specified function to the corresponding elements of second sequences, producing a sequence of the results. The resulting sequence has the same length as the input sequences. If the input sequences are of different lengths, an exception is thrown. |
| EquiZip<TFirst, TSecond, TThird, TFourth, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>) | Applies a specified function to the corresponding elements of second sequences, producing a sequence of the results. The resulting sequence has the same length as the input sequences. If the input sequences are of different lengths, an exception is thrown. |
| Evaluate<T>(IEnumerable<Func<T>>) | Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. |
| Exactly<T>(IEnumerable<T>, int) | Determines whether or not the number of elements in the sequence is equals to the given integer. |
| ExceptBy<TSource, TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource, TKey>) | Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector. |
| ExceptBy<TSource, TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector. |
| Exclude<T>(IEnumerable<T>, int, int) | Excludes a contiguous number of elements from a sequence starting at a given index. |
| Exclude<T>(IEnumerable<T>, Range) | Excludes a contiguous number of elements from a sequence starting at a given index. |
| FallbackIfEmpty<T>(IEnumerable<T>, IEnumerable<T>) | Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values. |
| FallbackIfEmpty<T>(IEnumerable<T>, params T[]) | Returns the elements of a sequence, but if it is empty then returns an alternate sequence from an array of values. |
| FillBackward<T>(IEnumerable<T?>) | Returns a sequence with each null reference or value in the source replaced with the following non-null reference or value in that sequence. |
| FillBackward<T>(IEnumerable<T>, Func<T, bool>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. An additional parameter specifies a function used to determine if an element is considered missing or not. |
| FillBackward<T>(IEnumerable<T>, Func<T, bool>, Func<T, T, T>) | Returns a sequence with each missing element in the source replaced with the following non-missing element in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| FillForward<T>(IEnumerable<T?>) | Returns a sequence with each null reference or value in the source replaced with the previous non-null reference or value seen in that sequence. |
| FillForward<T>(IEnumerable<T>, Func<T, bool>) | Returns a sequence with each missing element in the source replaced with the previous non-missing element seen in that sequence. An additional parameter specifies a function used to determine if an element is considered missing or not. |
| FillForward<T>(IEnumerable<T>, Func<T, bool>, Func<T, T, T>) | Returns a sequence with each missing element in the source replaced with one based on the previous non-missing element seen in that sequence. Additional parameters specify two functions, one used to determine if an element is considered missing or not and another to provide the replacement for the missing element. |
| Finally<TSource>(IEnumerable<TSource>, Action) | Creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed. |
| FindIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the first occurrence within the entire IEnumerable<T>. |
| FindIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the first occurrence within the range of elements in the IEnumerable<T> that extends from the specified index to the last element. |
| FindIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index, int) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the first occurrence within the range of elements in the IEnumerable<T> that starts at the specified index to the last element and contains the specified number of elements. |
| FindLastIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the last occurrence within the entire IEnumerable<T>. |
| FindLastIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the last occurrence within the range of elements in the IEnumerable<T> that extends backwards from the specified index to the first element. |
| FindLastIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index, int) | Searches for an element that matches the conditions defined by the specified predicate and returns the zero-based index of the last occurrence within the range of elements in the IEnumerable<T> that ends at the specified index to the last element and contains the specified number of elements. |
| Flatten(IEnumerable) | Flattens a sequence containing arbitrarily-nested sequences. |
| Flatten(IEnumerable, Func<IEnumerable, bool>) | Flattens a sequence containing arbitrarily-nested sequences. An additional parameter specifies a predicate function used to determine whether a nested IEnumerable should be flattened or not. |
| Flatten(IEnumerable, Func<object?, IEnumerable?>) | Flattens a sequence containing arbitrarily-nested sequences. An additional parameter specifies a function that projects an inner sequence via a property of an object. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 16 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 15 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 14 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 13 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 12 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 11 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 10 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 9 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 8 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 7 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 6 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 5 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, TResult>) | Returns the result of applying a function to a sequence of 4 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, TResult>) | Returns the result of applying a function to a sequence of 3 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, T, TResult>) | Returns the result of applying a function to a sequence of 2 elements. |
| Fold<T, TResult>(IEnumerable<T>, Func<T, TResult>) | Returns the result of applying a function to a sequence of 1 element. |
| ForEach<TSource>(IEnumerable<TSource>, Action<TSource, int>) | Immediately executes the given action on each element in the source sequence. Each element's index is used in the logic of the action. |
| ForEach<TSource>(IEnumerable<TSource>, Action<TSource>) | Immediately executes the given action on each element in the source sequence. |
| From<T>(Func<T>) | Returns a single-element sequence containing the result of invoking the function. |
| From<T>(Func<T>, Func<T>) | Returns a sequence containing the result of invoking each parameter function in order. |
| From<T>(Func<T>, Func<T>, Func<T>) | Returns a sequence containing the result of invoking each parameter function in order. |
| From<T>(params Func<T>[]) | Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions. |
| FullGroupJoin<TFirst, TSecond, TKey>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>) | Performs a Full Group Join between the |
| FullGroupJoin<TFirst, TSecond, TKey>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>, IEqualityComparer<TKey>?) | Performs a Full Group Join between the |
| FullGroupJoin<TFirst, TSecond, TKey, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>, Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult>) | Performs a full group-join between two sequences. |
| FullGroupJoin<TFirst, TSecond, TKey, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>, Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult>, IEqualityComparer<TKey>?) | Performs a full group-join between two sequences. |
| FullOuterHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| FullOuterHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| FullOuterMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| FullOuterMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs a full outer join on two heterogeneous sequences. |
| Generate<TResult>(TResult, Func<TResult, TResult>) | Returns a sequence of values consecutively generated by a generator function. |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, Func<TState, bool>) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, Func<TState, bool>, IEqualityComparer<TState>?, IComparer<TCost>?) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, TState) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, Func<TState, bool>) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, Func<TState, bool>, IEqualityComparer<TState>?, IComparer<TCost>?) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, TState) | Calculate the cost of the shortest path from state |
| GetShortestPathCost<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?) | Calculate the cost of the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, Func<TState, bool>) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>>, Func<TState, bool>, IEqualityComparer<TState>?, IComparer<TCost>?) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost, TCost bestGuess)>>, TState) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost traversed, TCost bestGuess)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, Func<TState, bool>) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, Func<TState, bool>, IEqualityComparer<TState>?, IComparer<TCost>?) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, TState) | Find the shortest path from state |
| GetShortestPath<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, TState, IEqualityComparer<TState>?, IComparer<TCost>?) | Find the shortest path from state |
| GetShortestPaths<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>) | Find the shortest path from state |
| GetShortestPaths<TState, TCost>(TState, Func<TState, TCost?, IEnumerable<(TState nextState, TCost cost)>>, IEqualityComparer<TState>?, IComparer<TCost>?) | Find the shortest path from state |
| GroupAdjacent<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Groups the adjacent elements of a sequence according to a specified key selector function. |
| GroupAdjacent<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Groups the adjacent elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer. |
| GroupAdjacent<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>) | Groups the adjacent elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function. |
| GroupAdjacent<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>?) | Groups the adjacent elements of a sequence according to a specified key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. |
| GroupAdjacent<TSource, TKey, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>) | Groups the adjacent elements of a sequence according to a specified key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. |
| GroupAdjacent<TSource, TKey, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>, IEqualityComparer<TKey>?) | Groups the adjacent elements of a sequence according to a specified key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. |
| HasDuplicates<T>(IEnumerable<T>) | Checks if sequence contains duplicates. |
| HasDuplicates<T>(IEnumerable<T>, IEqualityComparer<T>?) | Checks if sequence contains duplicates, using the specified element equality comparer. |
| HasDuplicates<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Checks if sequence contains duplicates according to a specified key selector function. |
| HasDuplicates<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Checks if sequence contains duplicates according to a specified key selector function, using the specified element equality comparer. |
| Identity<T>(T) | Returns the identity function for a given type. |
| If<TResult>(Func<bool>, IEnumerable<TResult>) | Returns an enumerable sequence if the evaluation result of the given condition is true, otherwise returns an empty sequence. |
| If<TResult>(Func<bool>, IEnumerable<TResult>, IEnumerable<TResult>) | Returns an enumerable sequence based on the evaluation result of the given condition. |
| IndexBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Applies a key-generating function to each element of a sequence and returns a sequence that contains the elements of the original sequence as well its key and index inside the group of its key. |
| IndexBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?) | Applies a key-generating function to each element of a sequence and returns a sequence that contains the elements of the original sequence as well its key and index inside the group of its key. An additional parameter specifies a comparer to use for testing the equivalence of keys. |
| IndexOf<TSource>(IEnumerable<TSource>, TSource) | Searches for the specified object and returns the zero-based index of the first occurrence within the entire IEnumerable<T>. |
| IndexOf<TSource>(IEnumerable<TSource>, TSource, Index) | Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the IEnumerable<T> that extends from the specified index to the last element. |
| IndexOf<TSource>(IEnumerable<TSource>, TSource, Index, int) | Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the IEnumerable<T> that starts at the specified index to the last element and contains the specified number of elements. |
| Index<TSource>(IEnumerable<TSource>) | Returns a sequence of tuples where the |
| Index<TSource>(IEnumerable<TSource>, int) | Returns a sequence of tuples where the |
| InnerHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerLoopJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerLoopJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| InnerMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs an inner join on two heterogeneous sequences. |
| Insert<T>(IEnumerable<T>, IEnumerable<T>, Index) | Inserts the elements of a sequence into another sequence at a specified index. |
| Insert<T>(IEnumerable<T>, IEnumerable<T>, int) | Inserts the elements of a sequence into another sequence at a specified index. |
| Interleave<T>(IEnumerable<IEnumerable<T>>) | Interleaves the elements of two or more sequences into a single sequence in a round-robin fashion until all sequences are consumed. |
| Interleave<T>(IEnumerable<T>, params IEnumerable<T>[]) | Interleaves the elements of two or more sequences into a single sequence in a round-robin fashion until all sequences are consumed. |
| Lag<TSource>(IEnumerable<TSource>, int) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| Lag<TSource, TResult>(IEnumerable<TSource>, int, Func<TSource, TSource?, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| Lag<TSource, TResult>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. |
| LastIndexOf<TSource>(IEnumerable<TSource>, TSource) | Searches for the specified object and returns the zero-based index of the last occurrence within the entire IEnumerable<T>. |
| LastIndexOf<TSource>(IEnumerable<TSource>, TSource, Index) | Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the IEnumerable<T> that extends backwards from the specified index to the first element. |
| LastIndexOf<TSource>(IEnumerable<TSource>, TSource, Index, int) | Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the IEnumerable<T> that ends at the specified index to the last element and contains the specified number of elements. |
| Lead<TSource>(IEnumerable<TSource>, int) | Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. |
| Lead<TSource, TResult>(IEnumerable<TSource>, int, Func<TSource, TSource?, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. |
| Lead<TSource, TResult>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>) | Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. |
| LeftOuterHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterLoopJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterLoopJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| LeftOuterMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs a left outer join on two heterogeneous sequences. |
| MaxByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the maximum value of a sequence. |
| MaxByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the maximum value of a sequence. |
| MaxItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the maximum value of a sequence. |
| MaxItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the maximum value of a sequence. |
| MaxItems<T>(IEnumerable<T>) | Returns all of the items that share the maximum value of a sequence. |
| MaxItems<T>(IEnumerable<T>, IComparer<T>?) | Returns all of the items that share the maximum value of a sequence. |
| Memoize<TSource>(IEnumerable<TSource>, bool) | Creates a sequence that lazily caches the source as it is iterated for the first time, reusing the cache thereafter for future re-iterations. By default, all sequences are cached, whether they are instantiated or lazy. |
| MinByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the minimum value of a sequence. |
| MinByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the minimum value of a sequence. |
| MinItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Returns all of the items that share the minimum value of a sequence. |
| MinItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?) | Returns all of the items that share the minimum value of a sequence. |
| MinItems<T>(IEnumerable<T>) | Returns all of the items that share the minimum value of a sequence. |
| MinItems<T>(IEnumerable<T>, IComparer<T>?) | Returns all of the items that share the minimum value of a sequence. |
| Move<T>(IEnumerable<T>, int, int, int) | Returns a sequence with a range of elements in the source sequence moved to a new offset. |
| OnErrorResumeNext<TSource>(IEnumerable<IEnumerable<TSource>>) | Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. |
| OnErrorResumeNext<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) | Creates a sequence that concatenates both given sequences, regardless of whether an error occurs. |
| OnErrorResumeNext<TSource>(params IEnumerable<TSource>[]) | Creates a sequence that concatenates the given sequences, regardless of whether an error occurs in any of the sequences. |
| OrderBy<T, TKey>(IEnumerable<T>, Func<T, TKey>, OrderByDirection) | Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key |
| OrderBy<T, TKey>(IEnumerable<T>, Func<T, TKey>, IComparer<TKey>?, OrderByDirection) | Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key |
| PadStart<TSource>(IEnumerable<TSource>, int) | Pads a sequence with default values in the beginning if it is narrower (shorter in length) than a given width. |
| PadStart<TSource>(IEnumerable<TSource>, int, Func<int, TSource>) | Pads a sequence with default values in the beginning if it is narrower (shorter in length) than a given width. |
| PadStart<TSource>(IEnumerable<TSource>, int, TSource) | Pads a sequence with default values in the beginning if it is narrower (shorter in length) than a given width. |
| Pad<TSource>(IEnumerable<TSource>, int) | Pads a sequence with default values if it is narrower (shorter in length) than a given width. |
| Pad<TSource>(IEnumerable<TSource>, int, Func<int, TSource>) | Pads a sequence with default values if it is narrower (shorter in length) than a given width. |
| Pad<TSource>(IEnumerable<TSource>, int, TSource) | Pads a sequence with default values if it is narrower (shorter in length) than a given width. |
| PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>) | Executes a partial sort of the top |
| PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection) | Executes a |
| PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?) | Executes a partial sort of the top |
| PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection) | Executes a |
| PartialSort<T>(IEnumerable<T>, int) | Executes a partial sort of the top |
| PartialSort<T>(IEnumerable<T>, int, OrderByDirection) | Executes a |
| PartialSort<T>(IEnumerable<T>, int, IComparer<T>?) | Executes a partial sort of the top |
| PartialSort<T>(IEnumerable<T>, int, IComparer<T>?, OrderByDirection) | Executes a |
| Partition<T>(IEnumerable<T>, Func<T, bool>) | Partitions or splits a sequence in two using a predicate. |
| Partition<T, TResult>(IEnumerable<T>, Func<T, bool>, Func<IEnumerable<T>, IEnumerable<T>, TResult>) | Partitions or splits a sequence in two using a predicate and then projects a result from the two. |
| Permutations<T>(IEnumerable<T>) | Generates a sequence of lists that represent the permutations of the original sequence. |
| Pipe<TSource>(IEnumerable<TSource>, Action<TSource>) | Lazily invokes an action for each value in the sequence. |
| PreScan<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>, TSource) | Performs a pre-scan (exclusive prefix sum) on a sequence of elements. |
| Publish<TSource>(IEnumerable<TSource>) | Creates a buffer with a view over the source sequence, causing each enumerator to obtain access to the remainder of the sequence from the current index in the buffer. |
| Random() | Returns an infinite sequence of random integers. |
| Random(int) | Returns an infinite sequence of random integers between zero and a given maximum. |
| Random(int, int) | Returns an infinite sequence of random integers between a given minimum and maximum. |
| Random(Random) | Returns an infinite sequence of random integers using the supplied random number generator. |
| Random(Random, int) | Returns an infinite sequence of random integers between zero and a given maximum using the supplied random number generator. |
| Random(Random, int, int) | Returns an infinite sequence of random integers between zero and a given maximum using the supplied random number generator. |
| RandomDouble() | Returns an infinite sequence of random double values between 0.0 and 1.0. |
| RandomDouble(Random) | Returns an infinite sequence of random double values between 0.0 and 1.0 using the supplied random number generator. |
| RandomSubset<T>(IEnumerable<T>, int) | Returns a sequence of a specified size of random elements from the original sequence. |
| RandomSubset<T>(IEnumerable<T>, int, Random) | Returns a sequence of a specified size of random elements from the original sequence. |
| Range(int, int, int) | Generates a sequence of integral numbers within a specified range. |
| RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>) | Ranks each item in the sequence in ascending order by a specified key using a default comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>) | Ranks each item in the sequence in ascending order by a specified key using a caller-supplied comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| Rank<TSource>(IEnumerable<TSource>) | Ranks each item in the sequence in ascending order using a default comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| Rank<TSource>(IEnumerable<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| Rank<TSource>(IEnumerable<TSource>, IComparer<TSource>) | Ranks each item in the sequence in ascending order using a caller-supplied comparer. The rank is equal to index + 1 of the first element of the item's equality set. |
| Rank<TSource>(IEnumerable<TSource>, IComparer<TSource>, OrderByDirection) | Ranks each item in the sequence in the order defined by |
| Repeat<TSource>(IEnumerable<TSource>) | Repeats and concatenates the source sequence infinitely. |
| Repeat<TSource>(IEnumerable<TSource>, int) | Repeats and concatenates the source sequence the given number of times. |
| Repeat<TResult>(TResult) | Generates a sequence by repeating the given value infinitely. |
| Replace<TSource>(IEnumerable<TSource>, Index, TSource) | Replaces a single value in a sequence at a specified index with the given replacement value. |
| Replace<TSource>(IEnumerable<TSource>, int, TSource) | Replaces a single value in a sequence at a specified index with the given replacement value. |
| Retry<TSource>(IEnumerable<TSource>) | Creates a sequence that retries enumerating the source sequence as long as an error occurs. |
| Retry<TSource>(IEnumerable<TSource>, int) | Creates a sequence that retries enumerating the source sequence as long as an error occurs, with the specified maximum number of retries. |
| Return<T>(T) | Returns a single-element sequence containing the item provided. |
| RightOuterHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RightOuterHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RightOuterMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RightOuterMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?) | Performs a right outer join on two heterogeneous sequences. |
| RunLengthEncode<T>(IEnumerable<T>) | Run-length encodes a sequence by converting consecutive instances of the same element into a tuple representing the item and its occurrence count. |
| RunLengthEncode<T>(IEnumerable<T>, IEqualityComparer<T>?) | Run-length encodes a sequence by converting consecutive instances of the same element into a tuple representing the item and its occurrence count. This overload uses a custom equality comparer to identify equivalent items. |
| ScanBy<TSource, TKey, TState>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>) | Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. |
| ScanBy<TSource, TKey, TState>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>, IEqualityComparer<TKey>?) | Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. |
| ScanRight<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) | Performs a right-associative scan (inclusive prefix) on a sequence of elements. This operator is the right-associative version of the Scan<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| ScanRight<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>) | Performs a right-associative scan (inclusive prefix) on a sequence of elements. This operator is the right-associative version of the Scan<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) LINQ operator. |
| Scan<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) | Performs a scan (inclusive prefix sum) on a sequence of elements. This operator is similar to Aggregate<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) except that Scan<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>) returns the sequence of intermediate results as well as the final one. |
| Scan<TSource, TState>(IEnumerable<TSource>, TState, Func<TState, TSource, TState>) | Performs a scan (inclusive prefix sum) on a sequence of elements. This operator is similar to Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) except that Scan<TSource, TState>(IEnumerable<TSource>, TState, Func<TState, TSource, TState>) returns the sequence of intermediate results as well as the final one. |
| Segment<T>(IEnumerable<T>, Func<T, bool>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Segment<T>(IEnumerable<T>, Func<T, int, bool>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Segment<T>(IEnumerable<T>, Func<T, T, int, bool>) | Divides a sequence into multiple sequences by using a segment detector based on the original sequence |
| Sequence(int, int) | Generates a sequence of integral numbers within the (inclusive) specified range. If sequence is ascending the step is +1, otherwise -1. |
| Sequence(int, int, int) | Generates a sequence of integral numbers within the (inclusive) specified range. An additional parameter specifies the steps in which the integers of the sequence increase or decrease. |
| Share<TSource>(IEnumerable<TSource>) | Creates a buffer with a shared view over the source sequence, causing each enumerator to fetch the next element from the source sequence. |
| Shuffle<T>(IEnumerable<T>) | Returns a sequence of elements in random order from the original sequence. |
| Shuffle<T>(IEnumerable<T>, Random) | Returns a sequence of elements in random order from the original sequence. An additional parameter specifies a random generator to be used for the random selection algorithm. |
| SkipUntil<TSource>(IEnumerable<TSource>, Func<TSource, bool>) | Skips items from the input sequence until the given predicate returns true when applied to the current source item; that item will be the last skipped. |
| Slice<T>(IEnumerable<T>, int, int) | Extracts a contiguous count of elements from a sequence at a particular zero-based starting index |
| SortedMergeBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection, IComparer<TKey>?, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) according to a key into a single sequence that preserves that order. |
| SortedMergeBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) according to a key into a single sequence that preserves that order. |
| SortedMergeBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order according to a key into a single sequence that preserves that order. |
| SortedMergeBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order according to a key into a single sequence that preserves that order. |
| SortedMerge<TSource>(IEnumerable<TSource>, OrderByDirection, IComparer<TSource>?, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order. |
| SortedMerge<TSource>(IEnumerable<TSource>, OrderByDirection, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order. |
| SortedMerge<TSource>(IEnumerable<TSource>, IComparer<TSource>?, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order into a single sequence that preserves that order. |
| SortedMerge<TSource>(IEnumerable<TSource>, params IEnumerable<TSource>[]) | Merges two or more sequences that are in a common order into a single sequence that preserves that order. |
| Split<TSource>(IEnumerable<TSource>, Func<TSource, bool>) | Splits the source sequence by separator elements identified by a function. |
| Split<TSource>(IEnumerable<TSource>, Func<TSource, bool>, int) | Splits the source sequence by separator elements identified by a function, given a maximum count of splits. |
| Split<TSource>(IEnumerable<TSource>, TSource) | Splits the source sequence by a separator. |
| Split<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>?) | Splits the source sequence by a separator and then transforms the splits into results. |
| Split<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int) | Splits the source sequence by a separator, given a maximum count of splits. A parameter specifies how the separator is compared for equality. |
| Split<TSource>(IEnumerable<TSource>, TSource, int) | Splits the source sequence by a separator given a maximum count of splits. |
| Split<TSource, TResult>(IEnumerable<TSource>, Func<TSource, bool>, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by separator elements identified by a function and then transforms the splits into results. |
| Split<TSource, TResult>(IEnumerable<TSource>, Func<TSource, bool>, int, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by separator elements identified by a function, given a maximum count of splits, and then transforms the splits into results. |
| Split<TSource, TResult>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator and then transforms the splits into results. A parameter specifies how the separator is compared for equality. |
| Split<TSource, TResult>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator, given a maximum count of splits, and then transforms the splits into results. A parameter specifies how the separator is compared for equality. |
| Split<TSource, TResult>(IEnumerable<TSource>, TSource, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator and then transforms the splits into results. |
| Split<TSource, TResult>(IEnumerable<TSource>, TSource, int, Func<IReadOnlyList<TSource>, TResult>) | Splits the source sequence by a separator, given a maximum count of splits, and then transforms the splits into results. |
| StartsWith<T>(IEnumerable<T>, IEnumerable<T>) | Determines whether the beginning of the first sequence is equivalent to the second sequence, using the default equality comparer. |
| StartsWith<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?) | Determines whether the beginning of the first sequence is equivalent to the second sequence, using the specified element equality comparer. |
| Subsets<T>(IEnumerable<T>) | Returns a sequence of IList<T> representing all of the subsets of any size that are part of the original sequence. In mathematics, it is equivalent to the power set of a set. |
| Subsets<T>(IEnumerable<T>, int) | Returns a sequence of IList<T> representing all subsets of a given size that are part of the original sequence. In mathematics, it is equivalent to the combinations or k-subsets of a set. |
| TagFirstLast<TSource>(IEnumerable<TSource>) | Returns a sequence of tuples containing the element and flags indicating whether the element is the first and/or last of the sequence. |
| TagFirstLast<TSource, TResult>(IEnumerable<TSource>, Func<TSource, bool, bool, TResult>) | Returns a sequence resulting from applying a function to each element in the source sequence with additional parameters indicating whether the element is the first and/or last of the sequence. |
| TakeEvery<TSource>(IEnumerable<TSource>, int) | Returns every N-th element of a sequence. |
| TakeUntil<TSource>(IEnumerable<TSource>, Func<TSource, bool>) | Takes items from the input sequence until the given predicate returns true when applied to the current source item; that item will be the last taken. |
| Take<TSource>(IEnumerable<TSource>, Range) | Returns a specified range of contiguous elements from a sequence. |
| ThenBy<T, TKey>(IOrderedEnumerable<T>, Func<T, TKey>, OrderByDirection) | Performs a subsequent ordering of elements of a sequence in a particular direction (ascending, descending) according to a key |
| ThenBy<T, TKey>(IOrderedEnumerable<T>, Func<T, TKey>, IComparer<TKey>?, OrderByDirection) | Performs a subsequent ordering of elements of a sequence in a particular direction (ascending, descending) according to a key |
| Throw<TSource>(Exception) | Returns a sequence that throws an exception upon enumeration. |
| ToArrayByIndex<T>(IEnumerable<T>, Func<T, int>) | Creates an array from an IEnumerable<T> where a function is used to determine the index at which an element will be placed in the array. |
| ToArrayByIndex<T>(IEnumerable<T>, int, Func<T, int>) | Creates an array of user-specified length from an IEnumerable<T> where a function is used to determine the index at which an element will be placed in the array. |
| ToArrayByIndex<T, TResult>(IEnumerable<T>, Func<T, int>, Func<T, int, TResult>) | Creates an array from an IEnumerable<T> where a function is used to determine the index at which an element will be placed in the array. The elements are projected into the array via an additional function. |
| ToArrayByIndex<T, TResult>(IEnumerable<T>, Func<T, int>, Func<T, TResult>) | Creates an array from an IEnumerable<T> where a function is used to determine the index at which an element will be placed in the array. The elements are projected into the array via an additional function. |
| ToArrayByIndex<T, TResult>(IEnumerable<T>, int, Func<T, int>, Func<T, int, TResult>) | Creates an array of user-specified length from an IEnumerable<T> where a function is used to determine the index at which an element will be placed in the array. The elements are projected into the array via an additional function. |
| ToArrayByIndex<T, TResult>(IEnumerable<T>, int, Func<T, int>, Func<T, TResult>) | Creates an array of user-specified length from an IEnumerable<T> where a function is used to determine the index at which an element will be placed in the array. The elements are projected into the array via an additional function. |
| ToDataTable<T>(IEnumerable<T>) | Converts a sequence to a DataTable object. |
| ToDataTable<T>(IEnumerable<T>, params Expression<Func<T, object>>[]) | Appends elements in the sequence as rows of a given DataTable object with a set of lambda expressions specifying which members (property or field) of each element in the sequence will supply the column values. |
| ToDataTable<T, TTable>(IEnumerable<T>, TTable) | Appends elements in the sequence as rows of a given DataTable object. |
| ToDataTable<T, TTable>(IEnumerable<T>, TTable, params Expression<Func<T, object>>[]) | Appends elements in the sequence as rows of a given DataTable object with a set of lambda expressions specifying which members (property or field) of each element in the sequence will supply the column values. |
| ToDelimitedString(IEnumerable<bool>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<byte>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<char>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<decimal>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<double>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<short>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<int>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<long>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<sbyte>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<float>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<string>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<ushort>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<uint>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString(IEnumerable<ulong>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDelimitedString<TSource>(IEnumerable<TSource>, string) | Creates a delimited string from a sequence of values and a given delimiter. |
| ToDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>) | Creates a Dictionary<TKey, TValue> from a sequence of KeyValuePair<TKey, TValue> elements. |
| ToDictionary<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<TKey>?) | Creates a Dictionary<TKey, TValue> from a sequence of KeyValuePair<TKey, TValue> elements. An additional parameter specifies a comparer for keys. |
| ToDictionary<TKey, TValue>(IEnumerable<(TKey Key, TValue Value)>) | Creates a Dictionary<TKey, TValue> from a sequence of tuples of 2 where the first item is the key and the second the value. |
| ToDictionary<TKey, TValue>(IEnumerable<(TKey Key, TValue Value)>, IEqualityComparer<TKey>?) | Creates a Dictionary<TKey, TValue> from a sequence of tuples of 2 where the first item is the key and the second the value. An additional parameter specifies a comparer for keys. |
| ToLookup<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>) | Creates an ILookup<TKey, TElement> from a sequence of KeyValuePair<TKey, TValue> elements. |
| ToLookup<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<TKey>?) | Creates an ILookup<TKey, TElement> from a sequence of KeyValuePair<TKey, TValue> elements. An additional parameter specifies a comparer for keys. |
| ToLookup<TKey, TValue>(IEnumerable<(TKey Key, TValue Value)>) | Creates an ILookup<TKey, TElement> /> from a sequence of tuples of 2 where the first item is the key and the second the value. |
| ToLookup<TKey, TValue>(IEnumerable<(TKey Key, TValue Value)>, IEqualityComparer<TKey>?) | Creates an ILookup<TKey, TElement> from a sequence of tuples of 2 where the first item is the key and the second the value. An additional parameter specifies a comparer for keys. |
| Transpose<T>(IEnumerable<IEnumerable<T>>) | Transposes a sequence of rows into a sequence of columns. |
| TraverseBreadthFirst<T>(T, Func<T, IEnumerable<T>>) | Traverses a tree in a breadth-first fashion, starting at a root node and using a user-defined function to get the children at each node of the tree. |
| TraverseDepthFirst<T>(T, Func<T, IEnumerable<T>>) | Traverses a tree in a depth-first fashion, starting at a root node and using a user-defined function to get the children at each node of the tree. |
| TrySingle<TSource>(IEnumerable<TSource>) | Returns the single element in the sequence if it contains exactly one element. Similar to SingleOrDefault<TSource>(IEnumerable<TSource>). |
| TrySingle<T, TCardinality>(IEnumerable<T>, TCardinality, TCardinality, TCardinality) | Returns a tuple with the cardinality of the sequence and the single element in the sequence if it contains exactly one element. similar to Single<TSource>(IEnumerable<TSource>). |
| TrySingle<T, TCardinality, TResult>(IEnumerable<T>, TCardinality, TCardinality, TCardinality, Func<TCardinality, T?, TResult>) | Returns a result projected from the the cardinality of the sequence and the single element in the sequence if it contains exactly one element. |
| Using<TSource, TResource>(Func<TResource>, Func<TResource, IEnumerable<TSource>>) | Generates a sequence that's dependent on a resource object whose lifetime is determined by the sequence usage duration. |
| WhereLag<TSource>(IEnumerable<TSource>, int, Func<TSource, TSource?, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a lagging value. |
| WhereLag<TSource>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a lagging value. |
| WhereLead<TSource>(IEnumerable<TSource>, int, Func<TSource, TSource?, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a leading value. |
| WhereLead<TSource>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>) | Filters a sequence of values based on a predicate evaluated on the current value and a leading value. |
| Where<TSource>(IEnumerable<TSource>, IEnumerable<bool>) | Filters a sequence of values based on an enumeration of boolean values |
| While<TSource>(Func<bool>, IEnumerable<TSource>) | Generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds. |
| WindowLeft<TSource>(IEnumerable<TSource>, int) | Creates a left-aligned sliding window of a given size over the source sequence. |
| WindowLeft<TSource, TResult>(IEnumerable<TSource>, int, ReadOnlySpanFunc<TSource, TResult>) | Creates a right-aligned sliding window over the source sequence of a given size. |
| WindowLeft<TSource, TResult>(IEnumerable<TSource>, TSource[], ReadOnlySpanFunc<TSource, TResult>) | Creates a right-aligned sliding window over the source sequence of a given size. |
| WindowLeft<TSource, TResult>(IEnumerable<TSource>, TSource[], int, ReadOnlySpanFunc<TSource, TResult>) | Creates a right-aligned sliding window over the source sequence of a given size. |
| WindowRight<TSource>(IEnumerable<TSource>, int) | Creates a right-aligned sliding window over the source sequence of a given size. |
| WindowRight<TSource, TResult>(IEnumerable<TSource>, int, ReadOnlySpanFunc<TSource, TResult>) | Creates a right-aligned sliding window over the source sequence of a given size. |
| WindowRight<TSource, TResult>(IEnumerable<TSource>, TSource[], ReadOnlySpanFunc<TSource, TResult>) | Creates a right-aligned sliding window over the source sequence of a given size. |
| WindowRight<TSource, TResult>(IEnumerable<TSource>, TSource[], int, ReadOnlySpanFunc<TSource, TResult>) | Creates a right-aligned sliding window over the source sequence of a given size. |
| Window<TSource>(IEnumerable<TSource>, int) | Processes a sequence into a series of subsequences representing a windowed subset of the original |
| Window<TSource, TResult>(IEnumerable<TSource>, int, ReadOnlySpanFunc<TSource, TResult>) | Processes a sequence into a series of subsequences representing a windowed subset of the original, and then projecting them into a new form. |
| Window<TSource, TResult>(IEnumerable<TSource>, TSource[], ReadOnlySpanFunc<TSource, TResult>) | Processes a sequence into a series of subsequences representing a windowed subset of the original, and then projecting them into a new form. |
| Window<TSource, TResult>(IEnumerable<TSource>, TSource[], int, ReadOnlySpanFunc<TSource, TResult>) | Processes a sequence into a series of subsequences representing a windowed subset of the original, and then projecting them into a new form. |
| ZipLongest<T1, T2>(IEnumerable<T1>, IEnumerable<T2>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, TResult>(IEnumerable<T1>, IEnumerable<T2>, Func<T1?, T2?, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3, T4>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, Func<T1?, T2?, T3?, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipLongest<T1, T2, T3, T4, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, Func<T1?, T2?, T3?, T4?, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipMap<TSource, TResult>(IEnumerable<TSource>, Func<TSource, TResult>) | Applies a function to each element in a sequence and returns a sequence of tuples containing both the original item as well as the function result. |
| ZipShortest<TFirst, TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipShortest<TFirst, TSecond, TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipShortest<TFirst, TSecond, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TSecond, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence is as short as the shortest input sequence. |
| ZipShortest<TFirst, TSecond, TThird, TFourth>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence will always be as long as the longest of input sequences where the default value of each of the shorter sequence element types is used for padding. |
| ZipShortest<TFirst, TSecond, TThird, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence is as short as the shortest input sequence. |
| ZipShortest<TFirst, TSecond, TThird, TFourth, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>) | Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. The resulting sequence is as short as the shortest input sequence. |