public interface IAwaitQuery<out T> : IEnumerable<T>,
IEnumerable
Public Interface IAwaitQuery(Of Out T)
Inherits IEnumerable(Of T), IEnumerablegeneric<typename T>
public interface class IAwaitQuery : IEnumerable<T>,
IEnumerabletype IAwaitQuery<'T> =
interface
interface IEnumerable<'T>
interface IEnumerable
end| Options | The options that determine how the sequence evaluation behaves when it is iterated. |
| GetEnumerator | Returns an enumerator that iterates through the collection. (Inherited from IEnumerableT) |
| WithOptions | Returns a new query that will use the given options. |
| 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) |
| AsOrderedT |
Returns a query whose results evaluate asynchronously but which
are returned in the order of the source.
(Defined by ExperimentalEnumerable) |
| AsSequentialT |
Converts a query whose results evaluate asynchronously to use
sequential instead of concurrent evaluation.
(Defined by ExperimentalEnumerable) |
| 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) |
| AsUnorderedT |
Returns a query whose results evaluate asynchronously but which
are returned without guarantee of the source order.
(Defined by ExperimentalEnumerable) |
| 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 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) |
| 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) |
| 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) |
| 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) |
| MaxConcurrencyT |
Returns a query whose results evaluate asynchronously to use a
concurrency limit.
(Defined by ExperimentalEnumerable) |
| 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) |
| PreserveOrderT |
Returns a query whose results evaluate asynchronously and a Boolean
argument indicating whether the source order of the results is
preserved.
(Defined by ExperimentalEnumerable) |
| 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) |
| SchedulerT |
Returns a query whose results evaluate asynchronously and uses the
given scheduler for the workhorse task.
(Defined by ExperimentalEnumerable) |
| 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) |
| 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) |
| UnboundedConcurrencyT |
Returns a query whose results evaluate asynchronously and
concurrently with no defined limitation on concurrency.
(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) |