MoreLinq

## MoreEnumerable Class |

Provides a set of static methods for querying objects that
implement IEnumerableT. The actual methods
are implemented in files reflecting the method name.

Inheritance Hierarchy

Syntax

The MoreEnumerable type exposes the following members.

Methods

Name | Description | |
---|---|---|

AcquireTSource |
Ensures that a source sequence of IDisposable
objects are all acquired successfully. If the acquisition of any
one IDisposable fails then those successfully
acquired till that point are disposed.
| |

AggregateRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
Applies a right-associative accumulator function over a sequence.
This operator is the right-associative version of the
AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
| |

AggregateRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
Applies a right-associative accumulator function over a sequence.
The specified seed value is used as the initial accumulator value.
This operator is the right-associative version of the
AggregateTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate) LINQ operator.
| |

AggregateRightTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate, FuncTAccumulate, TResult) |
Applies a right-associative accumulator function over a sequence.
The specified seed value is used as the initial accumulator value,
and the specified function is used to select the result value.
This operator is the right-associative version of the
AggregateTSource, TAccumulate, TResult(IEnumerableTSource, TAccumulate, FuncTAccumulate, TSource, TAccumulate, FuncTAccumulate, TResult) LINQ operator.
| |

AssertTSource(IEnumerableTSource, FuncTSource, Boolean) |
Asserts that all elements of a sequence meet a given condition
otherwise throws an Exception object.
| |

AssertTSource(IEnumerableTSource, FuncTSource, Boolean, FuncTSource, Exception) |
Asserts that all elements of a sequence meet a given condition
otherwise throws an Exception object.
| |

AssertCountTSource(IEnumerableTSource, Int32) |
Asserts that a source sequence contains a given count of elements.
| |

AssertCountTSource(IEnumerableTSource, Int32, FuncInt32, Int32, Exception) |
Asserts that a source sequence contains a given count of elements.
A parameter specifies the exception to be thrown.
| |

AtLeastT |
Determines whether or not the number of elements in the sequence is greater than
or equal to the given integer.
| |

AtMostT |
Determines whether or not the number of elements in the sequence is lesser than
or equal to the given integer.
| |

BatchTSource(IEnumerableTSource, Int32) |
Batches the source sequence into sized buckets.
| |

BatchTSource, TResult(IEnumerableTSource, Int32, FuncIEnumerableTSource, TResult) |
Batches the source sequence into sized buckets and applies a projection to each bucket.
| |

CartesianTFirst, TSecond, TResult |
Returns the Cartesian product of two sequences by combining each element of the first set with each in the second
and applying the user=define projection to the pair.
| |

ConcatT(IEnumerableT, T) |
Returns a sequence consisting of the head elements and the given tail element.
| |

ConcatT(T, IEnumerableT) |
Returns a sequence consisting of the head element and the given tail elements.
| |

ConsumeT |
Completely consumes the given sequence. This method uses immediate execution,
and doesn't store any data during execution.
| |

CountBetweenT |
Determines whether or not the number of elements in the sequence is between
an inclusive range of minimum and maximum integers.
| |

CountByTSource, TKey(IEnumerableTSource, FuncTSource, 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.
| |

CountByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
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.
| |

DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, 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.
| |

DistinctByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
Returns all distinct elements of the given source, where "distinctness"
is determined via a projection and the specified comparer for the projected type.
| |

EndsWithT(IEnumerableT, IEnumerableT) |
Determines whether the end of the first sequence is equivalent to
the second sequence, using the default equality comparer.
| |

EndsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Determines whether the end of the first sequence is equivalent to
the second sequence, using the specified element equality comparer.
| |

EquiZipTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) |
Returns a projection of tuples, where each tuple contains the N-th element
from each of the argument sequences.
| |

EquiZipT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) |
Returns a projection of tuples, where each tuple contains the N-th element
from each of the argument sequences.
| |

EquiZipT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |
Returns a projection of tuples, where each tuple contains the N-th element
from each of the argument sequences.
| |

ExactlyT |
Determines whether or not the number of elements in the sequence is equals to the given integer.
| |

ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey) |
Returns the set of elements in the first sequence which aren't
in the second sequence, according to a given key selector.
| |

ExceptByTSource, TKey(IEnumerableTSource, IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
Returns the set of elements in the first sequence which aren't
in the second sequence, according to a given key selector.
| |

ExcludeT |
Excludes a contiguous number of elements from a sequence starting
at a given index.
| |

FallbackIfEmptyT(IEnumerableT, IEnumerableT) |
Returns the elements of a sequence, but if it is empty then
returns an altenate sequence of values.
| |

FallbackIfEmptyT(IEnumerableT, T) |
Returns the elements of the specified sequence or the specified
value in a singleton collection if the sequence is empty.
| |

FallbackIfEmptyT(IEnumerableT, T) |
Returns the elements of a sequence, but if it is empty then
returns an altenate sequence from an array of values.
| |

FallbackIfEmptyT(IEnumerableT, T, T) |
Returns the elements of a sequence, but if it is empty then
returns an altenate sequence of values.
| |

FallbackIfEmptyT(IEnumerableT, T, T, T) |
Returns the elements of a sequence, but if it is empty then
returns an altenate sequence of values.
| |

FallbackIfEmptyT(IEnumerableT, T, T, T, T) |
Returns the elements of a sequence, but if it is empty then
returns an altenate sequence of values.
| |

FillBackwardT(IEnumerableT) |
Returns a sequence with each null reference or value in the source
replaced with the following non-null reference or value in
that sequence.
| |

FillBackwardT(IEnumerableT, FuncT, Boolean) |
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.
| |

FillBackwardT(IEnumerableT, FuncT, Boolean, FuncT, T, T) |
Returns a sequence with each missing element in the source replaced
with the following non-missing element in that sequence. Additional
parameters specifiy two functions, one used to determine if an
element is considered missing or not and another to provide the
replacement for the missing element.
| |

FillForwardT(IEnumerableT) |
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.
| |

FillForwardT(IEnumerableT, FuncT, Boolean) |
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.
| |

FillForwardT(IEnumerableT, FuncT, Boolean, FuncT, 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 specifiy two functions, one used to
determine if an element is considered missing or not and another
to provide the replacement for the missing element.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
9 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
10 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
11 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, 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.
| |

FoldT, TResult(IEnumerableT, FuncT, 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.
| |

FoldT, TResult(IEnumerableT, FuncT, 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.
| |

FoldT, TResult(IEnumerableT, FuncT, 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.
| |

FoldT, TResult(IEnumerableT, FuncT, 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.
| |

FoldT, TResult(IEnumerableT, FuncT, TResult) |
Returns the result of applying a function to a sequence of
1 element.
| |

FoldT, TResult(IEnumerableT, FuncT, T, TResult) |
Returns the result of applying a function to a sequence of
2 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, TResult) |
Returns the result of applying a function to a sequence of
3 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
4 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
5 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
6 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
7 elements.
| |

FoldT, TResult(IEnumerableT, FuncT, T, T, T, T, T, T, T, TResult) |
Returns the result of applying a function to a sequence of
8 elements.
| |

ForEachT(IEnumerableT, ActionT) |
Immediately executes the given action on each element in the source sequence.
| |

ForEachT(IEnumerableT, ActionT, Int32) |
Immediately executes the given action on each element in the source sequence.
Each element's index is used in the logic of the action.
| |

FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey) |
Performs a Full Group Join between the first and second sequences.
| |

FullGroupJoinTFirst, TSecond, TKey(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, IEqualityComparerTKey) |
Performs a Full Group Join between the first and second sequences.
| |

FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult) |
Performs a full group-join between two sequences.
| |

FullGroupJoinTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTKey, IEnumerableTFirst, IEnumerableTSecond, TResult, IEqualityComparerTKey) |
Performs a full group-join between two sequences.
| |

GenerateTResult |
Returns a sequence of values consecutively generated by a generator function.
| |

GenerateByIndexTResult |
Returns a sequence of values based on indexes.
| |

GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
Groups the adjacent elements of a sequence according to a
specified key selector function.
| |

GroupAdjacentTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IEqualityComparerTKey) |
Groups the adjacent elements of a sequence according to a
specified key selector function and compares the keys by using a
specified comparer.
| |

GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, 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.
| |

GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, 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.
| |

GroupAdjacentTSource, TKey, TElement(IEnumerableTSource, FuncTSource, TKey, FuncTSource, TElement, IEqualityComparerTKey) |
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.
| |

GroupAdjacentTSource, TKey, TResult(IEnumerableTSource, FuncTSource, TKey, FuncTKey, IEnumerableTSource, TResult, IEqualityComparerTKey) |
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.
| |

IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, TResult) | Obsolete.
Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
| |

IncrementalTSource, TResult(IEnumerableTSource, FuncTSource, TSource, Int32, TResult) | Obsolete.
Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
| |

IndexTSource(IEnumerableTSource) |
Returns a sequence of KeyValuePairTKey, TValue
where the key is the zero-based index of the value in the source
sequence.
| |

IndexTSource(IEnumerableTSource, Int32) |
Returns a sequence of KeyValuePairTKey, TValue
where the key is the index of the value in the source sequence.
An additional parameter specifies the starting index.
| |

InterleaveT |
Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed
| |

LagTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
| |

LagTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
| |

LeadTSource, TResult(IEnumerableTSource, Int32, FuncTSource, TSource, TResult) |
Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
| |

LeadTSource, TResult(IEnumerableTSource, Int32, TSource, FuncTSource, TSource, TResult) |
Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
| |

MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
Returns the maximal element of the given sequence, based on
the given projection.
| |

MaxByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
Returns the maximal element of the given sequence, based on
the given projection and the specified comparer for projected values.
| |

MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
Returns the minimal element of the given sequence, based on
the given projection.
| |

MinByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
Returns the minimal element of the given sequence, based on
the given projection and the specified comparer for projected values.
| |

NestedLoops |
Produces a sequence from an action based on the dynamic generation of N nested loops
whose iteration counts are defined by a sequence of loop counts.
| |

OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection) |
Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
| |

OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
| |

OrderedMergeT(IEnumerableT, IEnumerableT) |
Merges two ordered sequences into one. Where the elements equal
in both sequences, the element from the first sequence is
returned in the resulting sequence.
| |

OrderedMergeT(IEnumerableT, IEnumerableT, IComparerT) |
Merges two ordered sequences into one with an additional
parameter specifying how to compare the elements of the
sequences. Where the elements equal in both sequences, the
element from the first sequence is returned in the resulting
sequence.
| |

OrderedMergeT, TKey(IEnumerableT, IEnumerableT, FuncT, TKey) |
Merges two ordered sequences into one with an additional
parameter specifying the element key by which the sequences are
ordered. Where the keys equal in both sequences, the
element from the first sequence is returned in the resulting
sequence.
| |

OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult) |
Merges two ordered sequences into one. Additional parameters
specify the element key by which the sequences are ordered,
the result when element is found in first sequence but not in
the second, the result when element is found in second sequence
but not in the first and the result when elements are found in
both sequences.
| |

OrderedMergeT, TKey, TResult(IEnumerableT, IEnumerableT, FuncT, TKey, FuncT, TResult, FuncT, TResult, FuncT, T, TResult, IComparerTKey) |
Merges two ordered sequences into one. Additional parameters
specify the element key by which the sequences are ordered,
the result when element is found in first sequence but not in
the second, the result when element is found in second sequence
but not in the first, the result when elements are found in
both sequences and a method for comparing keys.
| |

OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult) |
Merges two heterogeneous sequences ordered by a common key type
into a homogeneous one. Additional parameters specify the
element key by which the sequences are ordered, the result when
element is found in first sequence but not in the second and
the result when element is found in second sequence but not in
the first, the result when elements are found in both sequences.
| |

OrderedMergeTFirst, TSecond, TKey, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TKey, FuncTSecond, TKey, FuncTFirst, TResult, FuncTSecond, TResult, FuncTFirst, TSecond, TResult, IComparerTKey) |
Merges two heterogeneous sequences ordered by a common key type
into a homogeneous one. Additional parameters specify the
element key by which the sequences are ordered, the result when
element is found in first sequence but not in the second,
the result when element is found in second sequence but not in
the first, the result when elements are found in both sequences
and a method for comparing keys.
| |

PadTSource(IEnumerableTSource, Int32) |
Pads a sequence with default values if it is narrower (shorter
in length) than a given width.
| |

PadTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
Pads a sequence with a dynamic filler value if it is narrower (shorter
in length) than a given width.
| |

PadTSource(IEnumerableTSource, Int32, TSource) |
Pads a sequence with a given filler value if it is narrower (shorter
in length) than a given width.
| |

PadStartTSource(IEnumerableTSource, Int32) |
Pads a sequence with default values in the beginning if it is narrower (shorter
in length) than a given width.
| |

PadStartTSource(IEnumerableTSource, Int32, FuncInt32, TSource) |
Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter
in length) than a given width.
An additional parameter specifies the function to calculate padding.
| |

PadStartTSource(IEnumerableTSource, Int32, TSource) |
Pads a sequence with a given filler value in the beginning if it is narrower (shorter
in length) than a given width.
An additional parameter specifies the value to use for padding.
| |

PairwiseTSource, TResult |
Returns a sequence resulting from applying a function to each
element in the source sequence and its
predecessor, with the exception of the first element which is
only returned as the predecessor of the second element.
| |

PartialSortT(IEnumerableT, Int32) |
Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey),
where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
in a single operation.
| |

PartialSortT(IEnumerableT, Int32, OrderByDirection) |
Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
in a single operation.
An additional parameter specifies the direction of the sort
| |

PartialSortT(IEnumerableT, Int32, IComparerT) |
Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
in a single operation. An additional parameter specifies how the
elements compare to each other.
| |

PartialSortT(IEnumerableT, Int32, IComparerT, OrderByDirection) |
Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection),
where each element is its key, and TakeTSource(IEnumerableTSource, Int32)
in a single operation.
Additional parameters specify how the elements compare to each other and
the direction of the sort.
| |

PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey) |
Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
and TakeTSource(IEnumerableTSource, Int32) in a single operation.
| |

PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, OrderByDirection) |
Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
and TakeTSource(IEnumerableTSource, Int32) in a single operation.
An additional parameter specifies the direction of the sort
| |

PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey) |
Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey),
and TakeTSource(IEnumerableTSource, Int32) in a single operation.
An additional parameter specifies how the keys compare to each other.
| |

PartialSortByTSource, TKey(IEnumerableTSource, Int32, FuncTSource, TKey, IComparerTKey, OrderByDirection) |
Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection),
and TakeTSource(IEnumerableTSource, Int32) in a single operation.
Additional parameters specify how the elements compare to each other and
the direction of the sort.
| |

PartitionT(IEnumerableT, FuncT, Boolean) |
Partitions or splits a sequence in two using a predicate.
| |

PartitionT, TResult(IEnumerableIGroupingBoolean, T, FuncIEnumerableT, IEnumerableT, TResult) |
Partitions a grouping by Boolean keys into a projection of true
elements and false elements, respectively.
| |

PartitionT, TResult(IEnumerableIGroupingNullableBoolean, T, FuncIEnumerableT, IEnumerableT, IEnumerableT, TResult) |
Partitions a grouping by nullable Boolean keys into a projection of
true elements, false elements and null elements, respectively.
| |

PartitionT, TResult(IEnumerableT, FuncT, Boolean, FuncIEnumerableT, IEnumerableT, TResult) |
Partitions or splits a sequence in two using a predicate and then
projects a result from the two.
| |

PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
Partitions a grouping and projects a result from group elements
matching a key and those groups that do not.
| |

PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
Partitions a grouping and projects a result from group elements
matching a key and those groups that do not. An additional parameter
specifies how to compare keys for equality.
| |

PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
Partitions a grouping and projects a result from elements of
groups matching a set of two keys and those groups that do not.
| |

PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
Partitions a grouping and projects a result from elements of
groups matching a set of two keys and those groups that do not.
An additional parameter specifies how to compare keys for equality.
| |

PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
Partitions a grouping and projects a result from elements groups
matching a set of three keys and those groups that do not.
| |

PartitionTKey, TElement, TResult(IEnumerableIGroupingTKey, TElement, TKey, TKey, TKey, IEqualityComparerTKey, FuncIEnumerableTElement, IEnumerableTElement, IEnumerableTElement, IEnumerableIGroupingTKey, TElement, TResult) |
Partitions a grouping and projects a result from elements groups
matching a set of three keys and those groups that do not. An
additional parameter specifies how to compare keys for equality.
| |

PermutationsT |
Generates a sequence of lists that represent the permutations of the original sequence.
| |

PipeT |
Executes the given action on each element in the source sequence
and yields it.
| |

PrependTSource |
Prepends a single value to a sequence.
| |

PreScanTSource |
Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
| |

Random |
Returns an infinite sequence of random integers using the standard
.NET random number generator.
| |

Random(Int32) |
Returns an infinite sequence of random integers between zero and
a given maximum.
| |

Random(Random) |
Returns an infinite sequence of random integers using the supplied
random number generator.
| |

Random(Int32, Int32) |
Returns an infinite sequence of random integers between a given
minimum and a maximum.
| |

Random(Random, Int32) |
Returns an infinite sequence of random integers between zero and a
given maximum using the supplied random number generator.
| |

Random(Random, Int32, Int32) |
Returns an infinite sequence of random integers between a given
minumum and a 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.
| |

RandomSubsetT(IEnumerableT, Int32) |
Returns a sequence of a specified size of random elements from the original sequence
| |

RandomSubsetT(IEnumerableT, Int32, Random) |
Returns a sequence of a specified size of random elements from the original sequence
| |

RankTSource(IEnumerableTSource) |
Ranks each item in the sequence in descending ordering using a default comparer.
| |

RankTSource(IEnumerableTSource, IComparerTSource) |
Rank each item in the sequence using a caller-supplied comparer.
| |

RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey) |
Ranks each item in the sequence in descending ordering by a specified key using a default comparer
| |

RankByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey) |
Ranks each item in a sequence using a specified key and a caller-supplied comparer
| |

RepeatT(IEnumerableT) |
Repeats the sequence forever.
| |

RepeatT(IEnumerableT, Int32) |
Repeats the sequence the specified number of times.
| |

RunLengthEncodeT(IEnumerableT) |
Run-length encodes a sequence by converting consecutive instances of the same element into
a KeyValuePair{T,int} representing the item and its occurrence count.
| |

RunLengthEncodeT(IEnumerableT, IEqualityComparerT) |
Run-length encodes a sequence by converting consecutive instances of the same element into
a KeyValuePair{T,int} representing the item and its occurrence count. This overload
uses a custom equality comparer to identify equivalent items.
| |

ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
Peforms a scan (inclusive prefix sum) on a sequence of elements.
| |

ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) |
Like AggregateTSource(IEnumerableTSource, FuncTSource, TSource, TSource) except returns
the sequence of intermediate results as well as the final one.
An additional parameter specifies a seed.
| |

ScanRightTSource(IEnumerableTSource, FuncTSource, TSource, TSource) |
Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
This operator is the right-associative version of the
ScanTSource(IEnumerableTSource, FuncTSource, TSource, TSource) LINQ operator.
| |

ScanRightTSource, TAccumulate(IEnumerableTSource, TAccumulate, FuncTSource, TAccumulate, TAccumulate) |
Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
The specified seed value is used as the initial accumulator value.
This operator is the right-associative version of the
ScanTSource, TState(IEnumerableTSource, TState, FuncTState, TSource, TState) LINQ operator.
| |

SegmentT(IEnumerableT, FuncT, Boolean) |
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
| |

SegmentT(IEnumerableT, FuncT, Int32, Boolean) |
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
| |

SegmentT(IEnumerableT, FuncT, T, Int32, Boolean) |
Divides a sequence into multiple sequences by using a segment detector based on the original sequence
| |

Sequence(Int32, Int32) |
Generates a sequence of integral numbers within the (inclusive) specified range.
If sequence is ascending the step is +1, otherwise -1.
| |

Sequence(Int32, Int32, Int32) |
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.
| |

SingleOrFallbackTSource | Obsolete.
Returns the single element in the given sequence, or the result
of executing a fallback delegate if the sequence is empty.
This method throws an exception if there is more than one element in the sequence.
| |

SkipLastT |
Bypasses a specified number of elements at the end of the sequence.
| |

SkipUntilTSource |
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.
| |

SliceT |
Extracts a contiguous count of elements from a sequence at a particular zero-based starting index
| |

SortedMergeTSource(IEnumerableTSource, OrderByDirection, IEnumerableTSource) |
Merges two or more sequences that are in a common order (either ascending or descending) into
a single sequence that preserves that order.
| |

SortedMergeTSource(IEnumerableTSource, OrderByDirection, IComparerTSource, IEnumerableTSource) |
Merges two or more sequences that are in a common order (either ascending or descending) into
a single sequence that preserves that order.
| |

SplitTSource(IEnumerableTSource, FuncTSource, Boolean) |
Splits the source sequence by separator elements identified by a
function.
| |

SplitTSource(IEnumerableTSource, TSource) |
Splits the source sequence by a separator.
| |

SplitTSource(IEnumerableTSource, FuncTSource, Boolean, Int32) |
Splits the source sequence by separator elements identified by a
function, given a maximum count of splits.
| |

SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource) |
Splits the source sequence by a separator and then transforms the
splits into results.
| |

SplitTSource(IEnumerableTSource, TSource, Int32) |
Splits the source sequence by a separator given a maximum count of splits.
| |

SplitTSource(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32) |
Splits the source sequence by a separator, given a maximum count
of splits. A parameter specifies how the separator is compared
for equality.
| |

SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, FuncIEnumerableTSource, TResult) |
Splits the source sequence by separator elements identified by
a function and then transforms the splits into results.
| |

SplitTSource, TResult(IEnumerableTSource, TSource, FuncIEnumerableTSource, TResult) |
Splits the source sequence by a separator and then transforms
the splits into results.
| |

SplitTSource, TResult(IEnumerableTSource, FuncTSource, Boolean, Int32, FuncIEnumerableTSource, 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.
| |

SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, FuncIEnumerableTSource, 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.
| |

SplitTSource, TResult(IEnumerableTSource, TSource, Int32, FuncIEnumerableTSource, TResult) |
Splits the source sequence by a separator, given a maximum count
of splits, and then transforms the splits into results.
| |

SplitTSource, TResult(IEnumerableTSource, TSource, IEqualityComparerTSource, Int32, FuncIEnumerableTSource, 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.
| |

StartsWithT(IEnumerableT, IEnumerableT) |
Determines whether the beginning of the first sequence is
equivalent to the second sequence, using the default equality
comparer.
| |

StartsWithT(IEnumerableT, IEnumerableT, IEqualityComparerT) |
Determines whether the beginning of the first sequence is
equivalent to the second sequence, using the specified element
equality comparer.
| |

SubsetsT(IEnumerableT) |
Returns a sequence of IListT 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.
| |

SubsetsT(IEnumerableT, Int32) |
Returns a sequence of IListT 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.
| |

TagFirstLastTSource, 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.
| |

TakeEveryTSource |
Returns every N-th element of a sequence.
| |

TakeLastTSource |
Returns a specified number of contiguous elements from the end of
a sequence.
| |

TakeUntilTSource |
Returns items from the input sequence until the given predicate returns true
when applied to the current source item; that item will be the last returned.
| |

ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, OrderByDirection) |
Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
| |

ThenByT, TKey(IOrderedEnumerableT, FuncT, TKey, IComparerTKey, OrderByDirection) |
Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
| |

ToArrayByIndexT(IEnumerableT, FuncT, Int32) |
Creates an array from an IEnumerableT where a
function is used to determine the index at which an element will
be placed in the array.
| |

ToArrayByIndexT(IEnumerableT, Int32, FuncT, Int32) |
Creates an array of user-specified length from an
IEnumerableT where a function is used to determine
the index at which an element will be placed in the array.
| |

ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, TResult) |
Creates an array from an IEnumerableT 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.
| |

ToArrayByIndexT, TResult(IEnumerableT, FuncT, Int32, FuncT, Int32, TResult) |
Creates an array from an IEnumerableT 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.
| |

ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, TResult) |
Creates an array of user-specified length from an
IEnumerableT 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.
| |

ToArrayByIndexT, TResult(IEnumerableT, Int32, FuncT, Int32, FuncT, Int32, TResult) |
Creates an array of user-specified length from an
IEnumerableT 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.
| |

ToDataTableT(IEnumerableT) |
Converts a sequence to a DataTable object.
| |

ToDataTableT(IEnumerableT, ExpressionFuncT, 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.
| |

ToDataTableT, TTable(IEnumerableT, TTable) |
Appends elements in the sequence as rows of a given DataTable object.
| |

ToDataTableT, TTable(IEnumerableT, TTable, ExpressionFuncT, 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(IEnumerableBoolean) | Obsolete.
Creates a delimited string from a sequence of values. The
delimiter used depends on the current culture of the executing thread.
| |

ToDelimitedString(IEnumerableByte) | Obsolete.
Creates a delimited string from a sequence of values. The
delimiter used depends on the current culture of the executing thread.
| |

ToDelimitedString(IEnumerableChar) | Obsolete.
Creates a delimited string from a sequence of values. The
delimiter used depends on the current culture of the executing thread.
| |

ToDelimitedString(IEnumerableDecimal) | Obsolete. | |

ToDelimitedString(IEnumerableDouble) | Obsolete. | |

ToDelimitedString(IEnumerableInt16) | Obsolete. | |

ToDelimitedString(IEnumerableInt32) | Obsolete. | |

ToDelimitedString(IEnumerableInt64) | Obsolete. | |

ToDelimitedString(IEnumerableSByte) | Obsolete. | |

ToDelimitedString(IEnumerableSingle) | Obsolete. | |

ToDelimitedString(IEnumerableString) | Obsolete. | |

ToDelimitedString(IEnumerableUInt16) | Obsolete. | |

ToDelimitedString(IEnumerableUInt32) | Obsolete. | |

ToDelimitedString(IEnumerableUInt64) | Obsolete. | |

ToDelimitedString(IEnumerableBoolean, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableByte, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableChar, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableDecimal, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableDouble, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableInt16, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableInt32, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableInt64, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableSByte, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableSingle, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableString, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableUInt16, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableUInt32, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedString(IEnumerableUInt64, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDelimitedStringTSource(IEnumerableTSource) | Obsolete. | |

ToDelimitedStringTSource(IEnumerableTSource, String) |
Creates a delimited string from a sequence of values and
a given delimiter.
| |

ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
Creates a DictionaryTKey, TValue from a sequence of
KeyValuePairTKey, TValue elements.
| |

ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue) | ||

ToDictionaryTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
Creates a DictionaryTKey, TValue from a sequence of
KeyValuePairTKey, TValue elements. An additional
parameter specifies a comparer for keys.
| |

ToDictionaryTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | ||

ToHashSetTSource(IEnumerableTSource) |
Returns a HashSetT of the source items using the default equality
comparer for the type.
| |

ToHashSetTSource(IEnumerableTSource, IEqualityComparerTSource) |
Returns a HashSetT of the source items using the specified equality
comparer for the type.
| |

ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue) |
Creates a ILookupTKey, TElement from a sequence of
KeyValuePairTKey, TValue elements.
| |

ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue) | ||

ToLookupTKey, TValue(IEnumerableKeyValuePairTKey, TValue, IEqualityComparerTKey) |
Creates a ILookupTKey, TElement from a sequence of
KeyValuePairTKey, TValue elements. An additional
parameter specifies a comparer for keys.
| |

ToLookupTKey, TValue(IEnumerableValueTupleTKey, TValue, IEqualityComparerTKey) | ||

TraceTSource(IEnumerableTSource) |
Traces the elements of a source sequence for diagnostics.
| |

TraceTSource(IEnumerableTSource, FuncTSource, String) |
Traces the elements of a source sequence for diagnostics using
a custom formatter.
| |

TraceTSource(IEnumerableTSource, String) |
Traces the elements of a source sequence for diagnostics using
custom formatting.
| |

TraverseBreadthFirstT |
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.
| |

TraverseDepthFirstT |
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.
| |

UnfoldTState, T, TResult |
Returns a sequence generated by applying a state to the generator function,
and from its result, determines if the sequence should have a next element, its value,
and the next state in the recursive call.
| |

WindowedTSource |
Processes a sequence into a series of subsequences representing a windowed subset of the original
| |

ZipLongestTFirst, TSecond, TResult | ||

ZipShortestTFirst, TSecond, TResult(IEnumerableTFirst, IEnumerableTSecond, FuncTFirst, TSecond, TResult) | ||

ZipShortestT1, T2, T3, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, FuncT1, T2, T3, TResult) | ||

ZipShortestT1, T2, T3, T4, TResult(IEnumerableT1, IEnumerableT2, IEnumerableT3, IEnumerableT4, FuncT1, T2, T3, T4, TResult) |

See Also