IExtremaEnumerableT Interface

Exposes the enumerator, which supports iteration over a sequence of some extremum property (maximum or minimum) of a specified type.

Definition

Namespace: MoreLinq
Assembly: MoreLinq (in MoreLinq.dll) Version: 3.4.0+b99a6a8cc504caf2d48372fe54a2f8116c59cd0c
C#
public interface IExtremaEnumerable<out T> : IEnumerable<T>, 
	IEnumerable
Implements
IEnumerableT, IEnumerable

Type Parameters

T
The type of objects to enumerate.

Methods

GetEnumeratorReturns an enumerator that iterates through the collection.
(Inherited from IEnumerableT)
Take Returns a specified number of contiguous elements from the start of the sequence.
TakeLast Returns a specified number of contiguous elements at the end of the sequence.

Extension Methods

AggregateT, TResult1, TResult2, TResult Applies two accumulator queries sequentially in a single pass over a sequence.
(Defined by ExperimentalEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TResult Applies two accumulators sequentially in a single pass over a sequence.
(Defined by MoreEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TResult Applies two accumulators sequentially in a single pass over a sequence.
(Defined by AggregateExtension)
AggregateT, TResult1, TResult2, TResult3, TResult Applies three accumulator queries sequentially in a single pass over a sequence.
(Defined by ExperimentalEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult Applies three accumulators sequentially in a single pass over a sequence.
(Defined by MoreEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TResult Applies three accumulators sequentially in a single pass over a sequence.
(Defined by AggregateExtension)
AggregateT, TResult1, TResult2, TResult3, TResult4, TResult Applies four accumulator queries sequentially in a single pass over a sequence.
(Defined by ExperimentalEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult Applies four accumulators sequentially in a single pass over a sequence.
(Defined by MoreEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult Applies four accumulators sequentially in a single pass over a sequence.
(Defined by AggregateExtension)
AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult Applies five accumulator queries sequentially in a single pass over a sequence.
(Defined by ExperimentalEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult Applies five accumulators sequentially in a single pass over a sequence.
(Defined by MoreEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult Applies five accumulators sequentially in a single pass over a sequence.
(Defined by AggregateExtension)
AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult Applies six accumulator queries sequentially in a single pass over a sequence.
(Defined by ExperimentalEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult Applies six accumulators sequentially in a single pass over a sequence.
(Defined by MoreEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult Applies six accumulators sequentially in a single pass over a sequence.
(Defined by AggregateExtension)
AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult Applies seven accumulator queries sequentially in a single pass over a sequence.
(Defined by ExperimentalEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult Applies seven accumulators sequentially in a single pass over a sequence.
(Defined by MoreEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult Applies seven accumulators sequentially in a single pass over a sequence.
(Defined by AggregateExtension)
AggregateT, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult Applies eight accumulator queries sequentially in a single pass over a sequence.
(Defined by ExperimentalEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult Applies eight accumulators sequentially in a single pass over a sequence.
(Defined by MoreEnumerable)
AggregateT, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult Applies eight accumulators sequentially in a single pass over a sequence.
(Defined by AggregateExtension)
AggregateRightT 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.
(Defined by MoreEnumerable)
AggregateRightT 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.
(Defined by AggregateRightExtension)
AggregateRightT, 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.
(Defined by MoreEnumerable)
AggregateRightT, 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.
(Defined by AggregateRightExtension)
AggregateRightT, TAccumulate, 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.
(Defined by MoreEnumerable)
AggregateRightT, TAccumulate, 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.
(Defined by AggregateRightExtension)
AppendT Returns a sequence consisting of the head elements and the given tail element.
(Defined by MoreEnumerable)
AppendT Returns a sequence consisting of the head elements and the given tail element.
(Defined by AppendExtension)
AssertT Asserts that all elements of a sequence meet a given condition otherwise throws an Exception object.
(Defined by MoreEnumerable)
AssertT Asserts that all elements of a sequence meet a given condition otherwise throws an Exception object.
(Defined by AssertExtension)
AssertT Asserts that all elements of a sequence meet a given condition otherwise throws an Exception object.
(Defined by MoreEnumerable)
AssertT Asserts that all elements of a sequence meet a given condition otherwise throws an Exception object.
(Defined by AssertExtension)
AssertCountT Asserts that a source sequence contains a given count of elements.
(Defined by MoreEnumerable)
AssertCountT Asserts that a source sequence contains a given count of elements.
(Defined by AssertCountExtension)
AssertCountT Asserts that a source sequence contains a given count of elements. A parameter specifies the exception to be thrown.
(Defined by MoreEnumerable)
AssertCountT Asserts that a source sequence contains a given count of elements. A parameter specifies the exception to be thrown.
(Defined by AssertCountExtension)
AtLeastT Determines whether or not the number of elements in the sequence is greater than or equal to the given integer.
(Defined by MoreEnumerable)
AtLeastT Determines whether or not the number of elements in the sequence is greater than or equal to the given integer.
(Defined by AtLeastExtension)
AtMostT Determines whether or not the number of elements in the sequence is lesser than or equal to the given integer.
(Defined by MoreEnumerable)
AtMostT Determines whether or not the number of elements in the sequence is lesser than or equal to the given integer.
(Defined by AtMostExtension)
AwaitT, TResult Creates a sequence query that streams the result of each task in the source sequence as it completes asynchronously. A CancellationToken is passed for each asynchronous evaluation to abort any asynchronous operations in flight if the sequence is not fully iterated.
(Defined by ExperimentalEnumerable)
AwaitCompletionT, TTaskResult, TResult Awaits completion of all asynchronous evaluations irrespective of whether they succeed or fail. An additional argument specifies a function that projects the final result given the source item and completed task.
(Defined by ExperimentalEnumerable)
BacksertT 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.
(Defined by MoreEnumerable)
BacksertT 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.
(Defined by BacksertExtension)
BatchT Batches the source sequence into sized buckets.
(Defined by MoreEnumerable)
BatchT Batches the source sequence into sized buckets.
(Defined by BatchExtension)
BatchT, TResult Batches the source sequence into sized buckets and applies a projection to each bucket.
(Defined by MoreEnumerable)
BatchT, TResult Batches the source sequence into sized buckets and applies a projection to each bucket.
(Defined by BatchExtension)
BatchT, TResult Batches the source sequence into sized buckets using an array pool to rent arrays to back each bucket and returns a sequence of elements projected from each bucket.
(Defined by ExperimentalEnumerable)
BatchT, TBucket, TResult Batches the source sequence into sized buckets using an array pool to rent arrays to back each bucket and returns a sequence of elements projected from each bucket.
(Defined by ExperimentalEnumerable)
CartesianT, 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.
(Defined by MoreEnumerable)
CartesianT, 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.
(Defined by CartesianExtension)
CartesianT, 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.
(Defined by MoreEnumerable)
CartesianT, 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.
(Defined by CartesianExtension)
CartesianT, 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.
(Defined by MoreEnumerable)
CartesianT, 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.
(Defined by CartesianExtension)
CartesianT, 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.
(Defined by MoreEnumerable)
CartesianT, 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.
(Defined by CartesianExtension)
CartesianT, 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.
(Defined by MoreEnumerable)
CartesianT, 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.
(Defined by CartesianExtension)
CartesianT, 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.
(Defined by MoreEnumerable)
CartesianT, 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.
(Defined by CartesianExtension)
CartesianT, 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.
(Defined by MoreEnumerable)
CartesianT, 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.
(Defined by CartesianExtension)
ChooseT, 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.
(Defined by MoreEnumerable)
ChooseT, 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.
(Defined by ChooseExtension)
CompareCountT, 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.
(Defined by MoreEnumerable)
CompareCountT, 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.
(Defined by CompareCountExtension)
ConcatT Returns a sequence consisting of the head elements and the given tail element.
(Defined by MoreEnumerable)
ConsumeT Completely consumes the given sequence. This method uses immediate execution, and doesn't store any data during execution.
(Defined by MoreEnumerable)
ConsumeT Completely consumes the given sequence. This method uses immediate execution, and doesn't store any data during execution.
(Defined by ConsumeExtension)
CountBetweenT Determines whether or not the number of elements in the sequence is between an inclusive range of minimum and maximum integers.
(Defined by MoreEnumerable)
CountBetweenT Determines whether or not the number of elements in the sequence is between an inclusive range of minimum and maximum integers.
(Defined by CountBetweenExtension)
CountByT, 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.
(Defined by MoreEnumerable)
CountByT, 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.
(Defined by CountByExtension)
CountByT, 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.
(Defined by MoreEnumerable)
CountByT, 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.
(Defined by CountByExtension)
CountDownT, 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.
(Defined by MoreEnumerable)
CountDownT, 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.
(Defined by CountDownExtension)
DistinctByT, 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.
(Defined by MoreEnumerable)
DistinctByT, 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.
(Defined by DistinctByExtension)
DistinctByT, TKey Returns all distinct elements of the given source, where "distinctness" is determined via a projection and the specified comparer for the projected type.
(Defined by MoreEnumerable)
DistinctByT, TKey Returns all distinct elements of the given source, where "distinctness" is determined via a projection and the specified comparer for the projected type.
(Defined by DistinctByExtension)
EndsWithT Determines whether the end of the first sequence is equivalent to the second sequence, using the default equality comparer.
(Defined by MoreEnumerable)
EndsWithT Determines whether the end of the first sequence is equivalent to the second sequence, using the default equality comparer.
(Defined by EndsWithExtension)
EndsWithT Determines whether the end of the first sequence is equivalent to the second sequence, using the specified element equality comparer.
(Defined by MoreEnumerable)
EndsWithT Determines whether the end of the first sequence is equivalent to the second sequence, using the specified element equality comparer.
(Defined by EndsWithExtension)
EquiZipT, TSecond, TResult Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. An exception is thrown if the input sequences are of different lengths.
(Defined by MoreEnumerable)
EquiZipT, TSecond, TResult Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. An exception is thrown if the input sequences are of different lengths.
(Defined by EquiZipExtension)
EquiZipT, T2, T3, TResult Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. An exception is thrown if the input sequences are of different lengths.
(Defined by MoreEnumerable)
EquiZipT, T2, T3, TResult Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. An exception is thrown if the input sequences are of different lengths.
(Defined by EquiZipExtension)
EquiZipT, T2, T3, T4, TResult Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. An exception is thrown if the input sequences are of different lengths.
(Defined by MoreEnumerable)
EquiZipT, T2, T3, T4, TResult Returns a projection of tuples, where each tuple contains the N-th element from each of the argument sequences. An exception is thrown if the input sequences are of different lengths.
(Defined by EquiZipExtension)
ExactlyT Determines whether or not the number of elements in the sequence is equals to the given integer.
(Defined by MoreEnumerable)
ExactlyT Determines whether or not the number of elements in the sequence is equals to the given integer.
(Defined by ExactlyExtension)
ExceptByT, TKey Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector.
(Defined by MoreEnumerable)
ExceptByT, TKey Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector.
(Defined by ExceptByExtension)
ExceptByT, TKey Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector.
(Defined by MoreEnumerable)
ExceptByT, TKey Returns the set of elements in the first sequence which aren't in the second sequence, according to a given key selector.
(Defined by ExceptByExtension)
ExcludeT Excludes a contiguous number of elements from a sequence starting at a given index.
(Defined by MoreEnumerable)
ExcludeT Excludes a contiguous number of elements from a sequence starting at a given index.
(Defined by ExcludeExtension)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by MoreEnumerable)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by FallbackIfEmptyExtension)
FallbackIfEmptyT Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
(Defined by MoreEnumerable)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence from an array of values.
(Defined by MoreEnumerable)
FallbackIfEmptyT Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
(Defined by FallbackIfEmptyExtension)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence from an array of values.
(Defined by FallbackIfEmptyExtension)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by MoreEnumerable)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by FallbackIfEmptyExtension)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by MoreEnumerable)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by FallbackIfEmptyExtension)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by MoreEnumerable)
FallbackIfEmptyT Returns the elements of a sequence, but if it is empty then returns an alternate sequence of values.
(Defined by FallbackIfEmptyExtension)
FillBackwardT Returns a sequence with each null reference or value in the source replaced with the following non-null reference or value in that sequence.
(Defined by MoreEnumerable)
FillBackwardT Returns a sequence with each null reference or value in the source replaced with the following non-null reference or value in that sequence.
(Defined by FillBackwardExtension)
FillBackwardT 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.
(Defined by MoreEnumerable)
FillBackwardT 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.
(Defined by FillBackwardExtension)
FillBackwardT 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.
(Defined by MoreEnumerable)
FillBackwardT 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.
(Defined by FillBackwardExtension)
FillForwardT 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.
(Defined by MoreEnumerable)
FillForwardT 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.
(Defined by FillForwardExtension)
FillForwardT 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.
(Defined by MoreEnumerable)
FillForwardT 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.
(Defined by FillForwardExtension)
FillForwardT 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.
(Defined by MoreEnumerable)
FillForwardT 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.
(Defined by FillForwardExtension)
FirstT Returns the first element of a sequence.
(Defined by MoreEnumerable)
FirstT Returns the first element of a sequence.
(Defined by FirstExtension)
FirstOrDefaultT Returns the first element of a sequence, or a default value if the sequence contains no elements.
(Defined by MoreEnumerable)
FirstOrDefaultT Returns the first element of a sequence, or a default value if the sequence contains no elements.
(Defined by FirstOrDefaultExtension)
Flatten Flattens a sequence containing arbitrarily-nested sequences.
(Defined by MoreEnumerable)
Flatten Flattens a sequence containing arbitrarily-nested sequences.
(Defined by FlattenExtension)
Flatten 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.
(Defined by MoreEnumerable)
Flatten Flattens a sequence containing arbitrarily-nested sequences. An additional parameter specifies a function that projects an inner sequence via a property of an object.
(Defined by MoreEnumerable)
Flatten 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.
(Defined by FlattenExtension)
Flatten Flattens a sequence containing arbitrarily-nested sequences. An additional parameter specifies a function that projects an inner sequence via a property of an object.
(Defined by FlattenExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 9 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 9 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 10 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 10 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 11 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 11 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 12 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 12 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 13 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 13 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 14 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 14 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 15 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 15 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 16 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 16 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 1 element.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 1 element.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 2 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 2 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 3 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 3 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 4 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 4 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 5 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 5 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 6 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 6 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 7 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 7 elements.
(Defined by FoldExtension)
FoldT, TResult Returns the result of applying a function to a sequence of 8 elements.
(Defined by MoreEnumerable)
FoldT, TResult Returns the result of applying a function to a sequence of 8 elements.
(Defined by FoldExtension)
ForEachT Immediately executes the given action on each element in the source sequence.
(Defined by MoreEnumerable)
ForEachT Immediately executes the given action on each element in the source sequence.
(Defined by ForEachExtension)
ForEachT Immediately executes the given action on each element in the source sequence. Each element's index is used in the logic of the action.
(Defined by MoreEnumerable)
ForEachT Immediately executes the given action on each element in the source sequence. Each element's index is used in the logic of the action.
(Defined by ForEachExtension)
FullGroupJoinT, TSecond, TKey Performs a Full Group Join between the first and second sequences.
(Defined by MoreEnumerable)
FullGroupJoinT, TSecond, TKey Performs a Full Group Join between the first and second sequences.
(Defined by FullGroupJoinExtension)
FullGroupJoinT, TSecond, TKey Performs a Full Group Join between the first and second sequences.
(Defined by MoreEnumerable)
FullGroupJoinT, TSecond, TKey Performs a Full Group Join between the first and second sequences.
(Defined by FullGroupJoinExtension)
FullGroupJoinT, TSecond, TKey, TResult Performs a full group-join between two sequences.
(Defined by MoreEnumerable)
FullGroupJoinT, TSecond, TKey, TResult Performs a full group-join between two sequences.
(Defined by FullGroupJoinExtension)
FullGroupJoinT, TSecond, TKey, TResult Performs a full group-join between two sequences.
(Defined by MoreEnumerable)
FullGroupJoinT, TSecond, TKey, TResult Performs a full group-join between two sequences.
(Defined by FullGroupJoinExtension)
FullJoinT, TKey, TResult Performs a full outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by MoreEnumerable)
FullJoinT, TKey, TResult Performs a full outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by FullJoinExtension)
FullJoinT, TKey, TResult Performs a full outer join on two homogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by MoreEnumerable)
FullJoinT, TKey, TResult Performs a full outer join on two homogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by FullJoinExtension)
FullJoinT, TSecond, TKey, TResult Performs a full outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by MoreEnumerable)
FullJoinT, TSecond, TKey, TResult Performs a full outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by FullJoinExtension)
FullJoinT, TSecond, TKey, TResult Performs a full outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by MoreEnumerable)
FullJoinT, TSecond, TKey, TResult Performs a full outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by FullJoinExtension)
GroupAdjacentT, TKey Groups the adjacent elements of a sequence according to a specified key selector function.
(Defined by MoreEnumerable)
GroupAdjacentT, TKey Groups the adjacent elements of a sequence according to a specified key selector function.
(Defined by GroupAdjacentExtension)
GroupAdjacentT, TKey Groups the adjacent elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
(Defined by MoreEnumerable)
GroupAdjacentT, TKey Groups the adjacent elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
(Defined by GroupAdjacentExtension)
GroupAdjacentT, TKey, 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.
(Defined by MoreEnumerable)
GroupAdjacentT, TKey, 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.
(Defined by MoreEnumerable)
GroupAdjacentT, TKey, 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.
(Defined by GroupAdjacentExtension)
GroupAdjacentT, TKey, 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.
(Defined by GroupAdjacentExtension)
GroupAdjacentT, TKey, TElement 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.
(Defined by MoreEnumerable)
GroupAdjacentT, TKey, 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.
(Defined by MoreEnumerable)
GroupAdjacentT, TKey, TElement 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.
(Defined by GroupAdjacentExtension)
GroupAdjacentT, TKey, 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.
(Defined by GroupAdjacentExtension)
IndexT Returns a sequence of KeyValuePairTKey, TValue where the key is the zero-based index of the value in the source sequence.
(Defined by MoreEnumerable)
IndexT Returns a sequence of KeyValuePairTKey, TValue where the key is the zero-based index of the value in the source sequence.
(Defined by IndexExtension)
IndexT 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.
(Defined by MoreEnumerable)
IndexT 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.
(Defined by IndexExtension)
IndexByT, 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.
(Defined by MoreEnumerable)
IndexByT, 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.
(Defined by IndexByExtension)
IndexByT, 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.
(Defined by MoreEnumerable)
IndexByT, 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.
(Defined by IndexByExtension)
InsertT Inserts the elements of a sequence into another sequence at a specified index.
(Defined by MoreEnumerable)
InsertT Inserts the elements of a sequence into another sequence at a specified index.
(Defined by InsertExtension)
InterleaveT Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed.
(Defined by MoreEnumerable)
InterleaveT Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed.
(Defined by InterleaveExtension)
LagT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
(Defined by MoreEnumerable)
LagT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
(Defined by LagExtension)
LagT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
(Defined by MoreEnumerable)
LagT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
(Defined by LagExtension)
LastT Returns the last element of a sequence.
(Defined by MoreEnumerable)
LastT Returns the last element of a sequence.
(Defined by LastExtension)
LastOrDefaultT Returns the last element of a sequence, or a default value if the sequence contains no elements.
(Defined by MoreEnumerable)
LastOrDefaultT Returns the last element of a sequence, or a default value if the sequence contains no elements.
(Defined by LastOrDefaultExtension)
LeadT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
(Defined by MoreEnumerable)
LeadT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
(Defined by LeadExtension)
LeadT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
(Defined by MoreEnumerable)
LeadT, TResult Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
(Defined by LeadExtension)
LeftJoinT, TKey, TResult Performs a left outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by MoreEnumerable)
LeftJoinT, TKey, TResult Performs a left outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by LeftJoinExtension)
LeftJoinT, TKey, TResult Performs a left outer join on two homogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by MoreEnumerable)
LeftJoinT, TKey, TResult Performs a left outer join on two homogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by LeftJoinExtension)
LeftJoinT, TSecond, TKey, TResult Performs a left outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by MoreEnumerable)
LeftJoinT, TSecond, TKey, TResult Performs a left outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by LeftJoinExtension)
LeftJoinT, TSecond, TKey, TResult Performs a left outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by MoreEnumerable)
LeftJoinT, TSecond, TKey, TResult Performs a left outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by LeftJoinExtension)
MaxByT, TKey Returns the maximal elements of the given sequence, based on the given projection.
(Defined by MoreEnumerable)
MaxByT, TKey Returns the maximal elements of the given sequence, based on the given projection.
(Defined by MaxByExtension)
MaxByT, TKey Returns the maximal elements of the given sequence, based on the given projection and the specified comparer for projected values.
(Defined by MoreEnumerable)
MaxByT, TKey Returns the maximal elements of the given sequence, based on the given projection and the specified comparer for projected values.
(Defined by MaxByExtension)
MemoizeT Creates a sequence that lazily caches the source as it is iterated for the first time, reusing the cache thereafter for future re-iterations. If the source is already cached or buffered then it is returned verbatim.
(Defined by ExperimentalEnumerable)
MinByT, TKey Returns the minimal elements of the given sequence, based on the given projection.
(Defined by MoreEnumerable)
MinByT, TKey Returns the minimal elements of the given sequence, based on the given projection.
(Defined by MinByExtension)
MinByT, TKey Returns the minimal elements of the given sequence, based on the given projection and the specified comparer for projected values.
(Defined by MoreEnumerable)
MinByT, TKey Returns the minimal elements of the given sequence, based on the given projection and the specified comparer for projected values.
(Defined by MinByExtension)
MoveT Returns a sequence with a range of elements in the source sequence moved to a new offset.
(Defined by MoreEnumerable)
MoveT Returns a sequence with a range of elements in the source sequence moved to a new offset.
(Defined by MoveExtension)
OrderByT, TKey Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
(Defined by MoreEnumerable)
OrderByT, TKey Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
(Defined by OrderByExtension)
OrderByT, TKey Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
(Defined by MoreEnumerable)
OrderByT, TKey Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
(Defined by OrderByExtension)
OrderedMergeT 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.
(Defined by MoreEnumerable)
OrderedMergeT 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.
(Defined by OrderedMergeExtension)
OrderedMergeT 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.
(Defined by MoreEnumerable)
OrderedMergeT 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.
(Defined by OrderedMergeExtension)
OrderedMergeT, 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.
(Defined by MoreEnumerable)
OrderedMergeT, 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.
(Defined by OrderedMergeExtension)
OrderedMergeT, TKey, 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.
(Defined by MoreEnumerable)
OrderedMergeT, TKey, 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.
(Defined by OrderedMergeExtension)
OrderedMergeT, TKey, 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, the result when elements are found in both sequences and a method for comparing keys.
(Defined by MoreEnumerable)
OrderedMergeT, TKey, 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, the result when elements are found in both sequences and a method for comparing keys.
(Defined by OrderedMergeExtension)
OrderedMergeT, TSecond, TKey, 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.
(Defined by MoreEnumerable)
OrderedMergeT, TSecond, TKey, 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.
(Defined by OrderedMergeExtension)
OrderedMergeT, TSecond, TKey, 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, 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.
(Defined by MoreEnumerable)
OrderedMergeT, TSecond, TKey, 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, 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.
(Defined by OrderedMergeExtension)
PadT Pads a sequence with default values if it is narrower (shorter in length) than a given width.
(Defined by MoreEnumerable)
PadT Pads a sequence with default values if it is narrower (shorter in length) than a given width.
(Defined by PadExtension)
PadT Pads a sequence with a given filler value if it is narrower (shorter in length) than a given width.
(Defined by MoreEnumerable)
PadT Pads a sequence with a dynamic filler value if it is narrower (shorter in length) than a given width.
(Defined by MoreEnumerable)
PadT Pads a sequence with a given filler value if it is narrower (shorter in length) than a given width.
(Defined by PadExtension)
PadT Pads a sequence with a dynamic filler value if it is narrower (shorter in length) than a given width.
(Defined by PadExtension)
PadStartT Pads a sequence with default values in the beginning if it is narrower (shorter in length) than a given width.
(Defined by MoreEnumerable)
PadStartT Pads a sequence with default values in the beginning if it is narrower (shorter in length) than a given width.
(Defined by PadStartExtension)
PadStartT 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.
(Defined by MoreEnumerable)
PadStartT 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.
(Defined by MoreEnumerable)
PadStartT 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.
(Defined by PadStartExtension)
PadStartT 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.
(Defined by PadStartExtension)
PairwiseT, 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.
(Defined by MoreEnumerable)
PairwiseT, 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.
(Defined by PairwiseExtension)
PartialSortT Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey), where each element is its key, and TakeTSource(IEnumerableTSource, Int32) in a single operation.
(Defined by MoreEnumerable)
PartialSortT Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey), where each element is its key, and TakeTSource(IEnumerableTSource, Int32) in a single operation.
(Defined by PartialSortExtension)
PartialSortT 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
(Defined by MoreEnumerable)
PartialSortT 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.
(Defined by MoreEnumerable)
PartialSortT 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
(Defined by PartialSortExtension)
PartialSortT 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.
(Defined by PartialSortExtension)
PartialSortT 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.
(Defined by MoreEnumerable)
PartialSortT 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.
(Defined by PartialSortExtension)
PartialSortByT, TKey Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), and TakeTSource(IEnumerableTSource, Int32) in a single operation.
(Defined by MoreEnumerable)
PartialSortByT, TKey Combines OrderByTSource, TKey(IEnumerableTSource, FuncTSource, TKey, IComparerTKey), and TakeTSource(IEnumerableTSource, Int32) in a single operation.
(Defined by PartialSortByExtension)
PartialSortByT, TKey Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection), and TakeTSource(IEnumerableTSource, Int32) in a single operation. An additional parameter specifies the direction of the sort
(Defined by MoreEnumerable)
PartialSortByT, TKey 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.
(Defined by MoreEnumerable)
PartialSortByT, TKey Combines OrderByT, TKey(IEnumerableT, FuncT, TKey, OrderByDirection), and TakeTSource(IEnumerableTSource, Int32) in a single operation. An additional parameter specifies the direction of the sort
(Defined by PartialSortByExtension)
PartialSortByT, TKey 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.
(Defined by PartialSortByExtension)
PartialSortByT, TKey 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.
(Defined by MoreEnumerable)
PartialSortByT, TKey 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.
(Defined by PartialSortByExtension)
PartitionT Partitions or splits a sequence in two using a predicate.
(Defined by MoreEnumerable)
PartitionT Partitions or splits a sequence in two using a predicate.
(Defined by PartitionExtension)
PartitionT, TResult Partitions or splits a sequence in two using a predicate and then projects a result from the two.
(Defined by MoreEnumerable)
PartitionT, TResult Partitions or splits a sequence in two using a predicate and then projects a result from the two.
(Defined by PartitionExtension)
PermutationsT Generates a sequence of lists that represent the permutations of the original sequence.
(Defined by MoreEnumerable)
PermutationsT Generates a sequence of lists that represent the permutations of the original sequence.
(Defined by PermutationsExtension)
PipeT Executes the given action on each element in the source sequence and yields it.
(Defined by MoreEnumerable)
PipeT Executes the given action on each element in the source sequence and yields it.
(Defined by PipeExtension)
PrependT Prepends a single value to a sequence.
(Defined by MoreEnumerable)
PrependT Prepends a single value to a sequence.
(Defined by PrependExtension)
PreScanT Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
(Defined by MoreEnumerable)
PreScanT Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
(Defined by PreScanExtension)
RandomSubsetT Returns a sequence of a specified size of random elements from the original sequence.
(Defined by MoreEnumerable)
RandomSubsetT Returns a sequence of a specified size of random elements from the original sequence.
(Defined by RandomSubsetExtension)
RandomSubsetT Returns a sequence of a specified size of random elements from the original sequence. An additional parameter specifies a random generator to be used for the random selection algorithm.
(Defined by MoreEnumerable)
RandomSubsetT Returns a sequence of a specified size of random elements from the original sequence. An additional parameter specifies a random generator to be used for the random selection algorithm.
(Defined by RandomSubsetExtension)
RankT Ranks each item in the sequence in descending ordering using a default comparer.
(Defined by MoreEnumerable)
RankT Ranks each item in the sequence in descending ordering using a default comparer.
(Defined by RankExtension)
RankT Rank each item in the sequence using a caller-supplied comparer.
(Defined by MoreEnumerable)
RankT Rank each item in the sequence using a caller-supplied comparer.
(Defined by RankExtension)
RankByT, TKey Ranks each item in the sequence in descending ordering by a specified key using a default comparer
(Defined by MoreEnumerable)
RankByT, TKey Ranks each item in the sequence in descending ordering by a specified key using a default comparer
(Defined by RankByExtension)
RankByT, TKey Ranks each item in a sequence using a specified key and a caller-supplied comparer
(Defined by MoreEnumerable)
RankByT, TKey Ranks each item in a sequence using a specified key and a caller-supplied comparer
(Defined by RankByExtension)
RepeatT Repeats the sequence forever.
(Defined by MoreEnumerable)
RepeatT Repeats the sequence forever.
(Defined by RepeatExtension)
RepeatT Repeats the sequence the specified number of times.
(Defined by MoreEnumerable)
RepeatT Repeats the sequence the specified number of times.
(Defined by RepeatExtension)
RightJoinT, TKey, TResult Performs a right outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by MoreEnumerable)
RightJoinT, TKey, TResult Performs a right outer join on two homogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by RightJoinExtension)
RightJoinT, TKey, TResult Performs a right outer join on two homogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by MoreEnumerable)
RightJoinT, TKey, TResult Performs a right outer join on two homogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by RightJoinExtension)
RightJoinT, TSecond, TKey, TResult Performs a right outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by MoreEnumerable)
RightJoinT, TSecond, TKey, TResult Performs a right outer join on two heterogeneous sequences. Additional arguments specify key selection functions and result projection functions.
(Defined by RightJoinExtension)
RightJoinT, TSecond, TKey, TResult Performs a right outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by MoreEnumerable)
RightJoinT, TSecond, TKey, TResult Performs a right outer join on two heterogeneous sequences. Additional arguments specify key selection functions, result projection functions and a key comparer.
(Defined by RightJoinExtension)
RunLengthEncodeT 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.
(Defined by MoreEnumerable)
RunLengthEncodeT 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.
(Defined by RunLengthEncodeExtension)
RunLengthEncodeT 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.
(Defined by MoreEnumerable)
RunLengthEncodeT 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.
(Defined by RunLengthEncodeExtension)
ScanT Performs a scan (inclusive prefix sum) on a sequence of elements.
(Defined by MoreEnumerable)
ScanT Performs a scan (inclusive prefix sum) on a sequence of elements.
(Defined by ScanExtension)
ScanT, 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.
(Defined by MoreEnumerable)
ScanT, 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.
(Defined by ScanExtension)
ScanByT, TKey, TState Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states.
(Defined by MoreEnumerable)
ScanByT, TKey, TState Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states.
(Defined by ScanByExtension)
ScanByT, TKey, TState Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. An additional parameter specifies the comparer to use to compare keys.
(Defined by MoreEnumerable)
ScanByT, TKey, TState Applies an accumulator function over sequence element keys, returning the keys along with intermediate accumulator states. An additional parameter specifies the comparer to use to compare keys.
(Defined by ScanByExtension)
ScanRightT Performs 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.
(Defined by MoreEnumerable)
ScanRightT Performs 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.
(Defined by ScanRightExtension)
ScanRightT, TAccumulate Performs 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.
(Defined by MoreEnumerable)
ScanRightT, TAccumulate Performs 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.
(Defined by ScanRightExtension)
SegmentT Divides a sequence into multiple sequences by using a segment detector based on the original sequence
(Defined by MoreEnumerable)
SegmentT Divides a sequence into multiple sequences by using a segment detector based on the original sequence
(Defined by SegmentExtension)
SegmentT Divides a sequence into multiple sequences by using a segment detector based on the original sequence
(Defined by MoreEnumerable)
SegmentT Divides a sequence into multiple sequences by using a segment detector based on the original sequence
(Defined by SegmentExtension)
SegmentT Divides a sequence into multiple sequences by using a segment detector based on the original sequence
(Defined by MoreEnumerable)
SegmentT Divides a sequence into multiple sequences by using a segment detector based on the original sequence
(Defined by SegmentExtension)
ShuffleT Returns a sequence of elements in random order from the original sequence.
(Defined by MoreEnumerable)
ShuffleT Returns a sequence of elements in random order from the original sequence.
(Defined by ShuffleExtension)
ShuffleT 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.
(Defined by MoreEnumerable)
ShuffleT 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.
(Defined by ShuffleExtension)
SingleT Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.
(Defined by MoreEnumerable)
SingleT Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.
(Defined by SingleExtension)
SingleOrDefaultT Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.
(Defined by MoreEnumerable)
SingleOrDefaultT Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.
(Defined by SingleOrDefaultExtension)
SkipLastT Bypasses a specified number of elements at the end of the sequence.
(Defined by MoreEnumerable)
SkipLastT Bypasses a specified number of elements at the end of the sequence.
(Defined by SkipLastExtension)
SkipUntilT 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.
(Defined by MoreEnumerable)
SkipUntilT 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.
(Defined by SkipUntilExtension)
SliceT Extracts a contiguous count of elements from a sequence at a particular zero-based starting index.
(Defined by MoreEnumerable)
SliceT Extracts a contiguous count of elements from a sequence at a particular zero-based starting index.
(Defined by SliceExtension)
SortedMergeT Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order.
(Defined by MoreEnumerable)
SortedMergeT Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order.
(Defined by SortedMergeExtension)
SortedMergeT Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order.
(Defined by MoreEnumerable)
SortedMergeT Merges two or more sequences that are in a common order (either ascending or descending) into a single sequence that preserves that order.
(Defined by SortedMergeExtension)
SplitT Splits the source sequence by separator elements identified by a function.
(Defined by MoreEnumerable)
SplitT Splits the source sequence by separator elements identified by a function.
(Defined by SplitExtension)
SplitT Splits the source sequence by a separator.
(Defined by MoreEnumerable)
SplitT Splits the source sequence by a separator.
(Defined by SplitExtension)
SplitT Splits the source sequence by separator elements identified by a function, given a maximum count of splits.
(Defined by MoreEnumerable)
SplitT Splits the source sequence by separator elements identified by a function, given a maximum count of splits.
(Defined by SplitExtension)
SplitT Splits the source sequence by a separator given a maximum count of splits.
(Defined by MoreEnumerable)
SplitT Splits the source sequence by a separator and then transforms the splits into results.
(Defined by MoreEnumerable)
SplitT Splits the source sequence by a separator given a maximum count of splits.
(Defined by SplitExtension)
SplitT Splits the source sequence by a separator and then transforms the splits into results.
(Defined by SplitExtension)
SplitT Splits the source sequence by a separator, given a maximum count of splits. A parameter specifies how the separator is compared for equality.
(Defined by MoreEnumerable)
SplitT Splits the source sequence by a separator, given a maximum count of splits. A parameter specifies how the separator is compared for equality.
(Defined by SplitExtension)
SplitT, TResult Splits the source sequence by separator elements identified by a function and then transforms the splits into results.
(Defined by MoreEnumerable)
SplitT, TResult Splits the source sequence by separator elements identified by a function and then transforms the splits into results.
(Defined by SplitExtension)
SplitT, TResult Splits the source sequence by a separator and then transforms the splits into results.
(Defined by MoreEnumerable)
SplitT, TResult Splits the source sequence by a separator and then transforms the splits into results.
(Defined by SplitExtension)
SplitT, 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.
(Defined by MoreEnumerable)
SplitT, 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.
(Defined by SplitExtension)
SplitT, TResult Splits the source sequence by a separator, given a maximum count of splits, and then transforms the splits into results.
(Defined by MoreEnumerable)
SplitT, 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.
(Defined by MoreEnumerable)
SplitT, TResult Splits the source sequence by a separator, given a maximum count of splits, and then transforms the splits into results.
(Defined by SplitExtension)
SplitT, 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.
(Defined by SplitExtension)
SplitT, 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.
(Defined by MoreEnumerable)
SplitT, 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.
(Defined by SplitExtension)
StartsWithT Determines whether the beginning of the first sequence is equivalent to the second sequence, using the default equality comparer.
(Defined by MoreEnumerable)
StartsWithT Determines whether the beginning of the first sequence is equivalent to the second sequence, using the default equality comparer.
(Defined by StartsWithExtension)
StartsWithT Determines whether the beginning of the first sequence is equivalent to the second sequence, using the specified element equality comparer.
(Defined by MoreEnumerable)
StartsWithT Determines whether the beginning of the first sequence is equivalent to the second sequence, using the specified element equality comparer.
(Defined by StartsWithExtension)
SubsetsT 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.
(Defined by MoreEnumerable)
SubsetsT 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.
(Defined by SubsetsExtension)
SubsetsT 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.
(Defined by MoreEnumerable)
SubsetsT 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.
(Defined by SubsetsExtension)
TagFirstLastT, 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.
(Defined by MoreEnumerable)
TagFirstLastT, 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.
(Defined by TagFirstLastExtension)
TakeEveryT Returns every N-th element of a sequence.
(Defined by MoreEnumerable)
TakeEveryT Returns every N-th element of a sequence.
(Defined by TakeEveryExtension)
TakeLastT Returns a specified number of contiguous elements from the end of a sequence.
(Defined by MoreEnumerable)
TakeLastT Returns a specified number of contiguous elements from the end of a sequence.
(Defined by TakeLastExtension)
TakeUntilT 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.
(Defined by MoreEnumerable)
TakeUntilT 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.
(Defined by TakeUntilExtension)
ToArrayByIndexT 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.
(Defined by MoreEnumerable)
ToArrayByIndexT 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.
(Defined by ToArrayByIndexExtension)
ToArrayByIndexT 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.
(Defined by MoreEnumerable)
ToArrayByIndexT 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.
(Defined by ToArrayByIndexExtension)
ToArrayByIndexT, 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.
(Defined by MoreEnumerable)
ToArrayByIndexT, 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.
(Defined by MoreEnumerable)
ToArrayByIndexT, 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.
(Defined by ToArrayByIndexExtension)
ToArrayByIndexT, 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.
(Defined by ToArrayByIndexExtension)
ToArrayByIndexT, 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.
(Defined by MoreEnumerable)
ToArrayByIndexT, 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.
(Defined by MoreEnumerable)
ToArrayByIndexT, 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.
(Defined by ToArrayByIndexExtension)
ToArrayByIndexT, 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.
(Defined by ToArrayByIndexExtension)
ToDataTableT Converts a sequence to a DataTable object.
(Defined by MoreEnumerable)
ToDataTableT Converts a sequence to a DataTable object.
(Defined by ToDataTableExtension)
ToDataTableT 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.
(Defined by MoreEnumerable)
ToDataTableT 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.
(Defined by ToDataTableExtension)
ToDataTableT, TTable Appends elements in the sequence as rows of a given DataTable object.
(Defined by MoreEnumerable)
ToDataTableT, TTable Appends elements in the sequence as rows of a given DataTable object.
(Defined by ToDataTableExtension)
ToDataTableT, TTable 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.
(Defined by MoreEnumerable)
ToDataTableT, TTable 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.
(Defined by ToDataTableExtension)
ToDelimitedStringT Creates a delimited string from a sequence of values and a given delimiter.
(Defined by MoreEnumerable)
ToDelimitedStringT Creates a delimited string from a sequence of values and a given delimiter.
(Defined by ToDelimitedStringExtension)
ToHashSetT Returns a HashSetT of the source items using the default equality comparer for the type.
(Defined by MoreEnumerable)
ToHashSetT Returns a HashSetT of the source items using the default equality comparer for the type.
(Defined by ToHashSetExtension)
ToHashSetT Returns a HashSetT of the source items using the specified equality comparer for the type.
(Defined by MoreEnumerable)
ToHashSetT Returns a HashSetT of the source items using the specified equality comparer for the type.
(Defined by ToHashSetExtension)
TraceT Traces the elements of a source sequence for diagnostics.
(Defined by MoreEnumerable)
TraceT Traces the elements of a source sequence for diagnostics.
(Defined by TraceExtension)
TraceT Traces the elements of a source sequence for diagnostics using a custom formatter.
(Defined by MoreEnumerable)
TraceT Traces the elements of a source sequence for diagnostics using a custom formatter.
(Defined by TraceExtension)
TraceT Traces the elements of a source sequence for diagnostics using custom formatting.
(Defined by MoreEnumerable)
TraceT Traces the elements of a source sequence for diagnostics using custom formatting.
(Defined by TraceExtension)
TrySingleT, 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 SingleTSource(IEnumerableTSource).
(Defined by ExperimentalEnumerable)
TrySingleT, TCardinality, 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.
(Defined by ExperimentalEnumerable)
WindowT Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
(Defined by MoreEnumerable)
WindowT Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
(Defined by WindowExtension)
WindowedT Processes a sequence into a series of sub-sequences representing a windowed subset of the original.
(Defined by MoreEnumerable)
WindowLeftT Creates a left-aligned sliding window of a given size over the source sequence.
(Defined by MoreEnumerable)
WindowLeftT Creates a left-aligned sliding window of a given size over the source sequence.
(Defined by WindowLeftExtension)
WindowRightT Creates a right-aligned sliding window over the source sequence of a given size.
(Defined by MoreEnumerable)
WindowRightT Creates a right-aligned sliding window over the source sequence of a given size.
(Defined by WindowRightExtension)
ZipLongestT, TSecond, 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.
(Defined by MoreEnumerable)
ZipLongestT, TSecond, 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.
(Defined by ZipLongestExtension)
ZipLongestT, 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.
(Defined by MoreEnumerable)
ZipLongestT, 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.
(Defined by ZipLongestExtension)
ZipLongestT, 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.
(Defined by MoreEnumerable)
ZipLongestT, 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.
(Defined by ZipLongestExtension)
ZipShortestT, 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.
(Defined by MoreEnumerable)
ZipShortestT, 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.
(Defined by ZipShortestExtension)
ZipShortestT, 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 is as short as the shortest input sequence.
(Defined by MoreEnumerable)
ZipShortestT, 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 is as short as the shortest input sequence.
(Defined by ZipShortestExtension)
ZipShortestT, 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 is as short as the shortest input sequence.
(Defined by MoreEnumerable)
ZipShortestT, 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 is as short as the shortest input sequence.
(Defined by ZipShortestExtension)

See Also